Edge.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
//
#ifndef EDGE_H
#define EDGE_H
 
#include <stdint.h>
#include <QtCore/QHash>
 
#include <Config.hpp>
#include <Common.hpp>
 
 
namespace mgx 
{
  typedef intptr_t edge_identity_t;
  
  template <typename EdgeContent> class Edge {
  public:
    typedef edge_identity_t identity_t;
  
    typedef EdgeContent content_t;
  
    typedef EdgeContent* pointer;
  
    Edge();
  
    Edge(identity_t src, identity_t tgt, EdgeContent* content);
  
    Edge(const Edge& copy);
  
    EdgeContent* operator->() const {
      return _content;
    }
  
    EdgeContent& operator*() const {
      return *_content;
    }
  
    template <typename R> R& operator->*(R EdgeContent::*ptr) {
      return _content->*ptr;
    }
    template <typename R> const R& operator->*(R EdgeContent::*ptr) const {
      return _content->*ptr;
    }
  
    Edge& operator=(const Edge& other);
  
    bool operator==(const Edge& other) const {
      return _content == other._content;
    }
    bool operator!=(const Edge& other) const {
      return _content != other._content;
    }
    bool operator>(const Edge& other) const {
      return _content > other._content;
    }
    bool operator<(const Edge& other) const {
      return _content < other._content;
    }
  
    bool isNull() const {
      return _content == 0;
    }
  
    operator bool() const { return _content != 0; }
  
    identity_t source() const {
      return _source;
    }
    identity_t target() const {
      return _target;
    }
  
    void clear()
    {
      _source = 0;
      _target = 0;
      _content = 0;
    }
  
    static Edge null;
  
  protected:
    identity_t _source;
    identity_t _target;
    EdgeContent* _content;
  };
  
  template <typename EdgeContent> Edge<EdgeContent> Edge<EdgeContent>::null;
  
  template <typename EdgeContent>
  Edge<EdgeContent>::Edge()
    : _source(0)
    , _target(0)
    , _content(0)
  {
  }
  
  template <typename EdgeContent>
  Edge<EdgeContent>::Edge(const Edge& copy)
    : _source(copy._source)
    , _target(copy._target)
    , _content(copy._content)
  {
  }
  
  template <typename EdgeContent>
  Edge<EdgeContent>::Edge(identity_t src, identity_t tgt, EdgeContent* content)
    : _source(src)
    , _target(tgt)
    , _content(content)
  {
  }
  
  template <typename EdgeContent> Edge<EdgeContent>& Edge<EdgeContent>::operator=(const Edge<EdgeContent>& other)
  {
    _source = other._source;
    _target = other._target;
    _content = other._content;
    return *this;
  }
  
  template <typename T> void copy_symmetric(T& e2, const T& e1) {
    e2 = e1;
  }
  
  template <typename EdgeContent> struct Arc {
    typedef edge_identity_t identity_t;
  
    typedef EdgeContent content_t;
  
    typedef Edge<EdgeContent> edge_t;
  
    Arc();
  
    Arc(const Arc& copy);
  
    Arc(identity_t src, identity_t tgt, EdgeContent* c1, EdgeContent* c2);
  
    operator edge_t() const { return edge_t(_source, _target, main); }
  
    Arc inv() const;
  
    Arc operator-() const {
      return inv();
    }
  
    ~Arc() {
      sync();
    }
  
    bool isNull() const {
      return main == 0;
    }
  
    operator bool() const { return main != 0; }
  
    EdgeContent& operator*() const {
      return *main;
    }
    EdgeContent* operator->() const {
      return main;
    }
  
    identity_t source() const {
      return _source;
    }
    identity_t target() const {
      return _target;
    }
  
    void sync() const
    {
      if(main)
        copy_symmetric(*other, *main);
    }
  
  protected:
    identity_t _source, _target;
    mutable EdgeContent* main, *other;
  };
  
  template <typename EdgeContent>
  Arc<EdgeContent>::Arc()
    : _source(0)
    , _target(0)
    , main(0)
    , other(0)
  {
  }
  
  template <typename EdgeContent>
  Arc<EdgeContent>::Arc(identity_t src, identity_t tgt, EdgeContent* e1, EdgeContent* e2)
    : _source(src)
    , _target(tgt)
    , main(e1)
    , other(e2)
  {
  }
  
  template <typename EdgeContent>
  Arc<EdgeContent>::Arc(const Arc& copy)
    : _source(copy._source)
    , _target(copy._target)
    , main(copy.main)
    , other(copy.other)
  {
  }
  
  template <typename EdgeContent> Arc<EdgeContent> Arc<EdgeContent>::inv() const
  {
    sync();
    return Arc(_target, _source, other, main);
  }
}
 
namespace std 
{
  HASH_NS_ENTER
  template <typename EdgeContent> struct hash<mgx::Edge<EdgeContent> >          {
    size_t operator()(const mgx::Edge<EdgeContent>& e) const {
      return e.source() + e.target();
    }
  };
  HASH_NS_EXIT
}
 
template <typename EdgeContent> uint qHash(const mgx::Edge<EdgeContent>& e)
{
  return qHash(uint(e.source() >> 4)) ^ qHash(uint(e.target() >> 4));
}
 
#endif