Vertex.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 VERTEX_HPP
#define VERTEX_HPP
 
#include <Config.hpp>
 
#include <Mangling.hpp>
 
#include <iostream>
#include <map>
#include <memory>
#include <stdint.h>
#include <typeinfo>
#include <utility>
 
#include <Common.hpp>
 
namespace mgx 
{
  typedef intptr_t vertex_identity_t;
  
  extern mgx_EXPORT size_t vertex_counter;
  
  template <typename VertexContent> class Vertex 
  {
  
  protected:
    struct CountedContent : public VertexContent {
      CountedContent() : VertexContent(), num(vertex_counter++)
      {
        count = 1u;       // To be used with tbb::atomic
      }
  
      CountedContent(const CountedContent& copy)
        : VertexContent(copy), count(copy.count), num(vertex_counter++) {}
  
      CountedContent(const VertexContent& copy)
        : VertexContent(copy), num(vertex_counter++)
      {
        count = 1u;       // To be used with tbb::atomic
      }
  
  public:
      unsigned int count;
  
      size_t num;
    };
  
  public:
    typedef vertex_identity_t identity_t;
  
    typedef VertexContent content_t;
  
    typedef VertexContent* pointer;
  
    Vertex();
  
    explicit Vertex(identity_t id); // bad idea to allow implicit conversion
  
    Vertex(const Vertex& copy);
  
    ~Vertex();
  
    VertexContent* operator->() const 
    {
      return content;
    }
    VertexContent& operator*() const {
      return *content;
    }
  
    Vertex& operator=(const Vertex& other);
  
    Vertex& operator=(const identity_t& id);
  
    Vertex& operator=(const VertexContent* value);
  
    bool operator==(const Vertex& other) const {
      return id() == other.id();
    }
    bool operator!=(const Vertex& other) const {
      return id() != other.id();
    }
    bool operator>(const Vertex& other) const {
      return id() > other.id();
    }
    bool operator<(const Vertex& other) const {
      return id() < other.id();
    }
    bool operator>=(const Vertex& other) const {
      return id() >= other.id();
    }
    bool operator<=(const Vertex& other) const {
      return id() <= other.id();
    }
  
    bool isNull() const {
      return content == 0;
    }
  
    identity_t id() const {
      return (identity_t)content;
    }
  
    size_t num() const {
      return content->num;
    }
  
    operator bool() const { return content; }
  
    static Vertex null;
  
    unsigned int count() const
    {
      if(content)
        return content->count;
      return 0;
    }
  
  protected:
    mutable CountedContent* content;
  
    void release();
  
    void acquire();
  };
  
  template <typename VertexContent> Vertex<VertexContent> Vertex<VertexContent>::null(0);
  
  template <typename VertexContent> Vertex<VertexContent>::~Vertex() 
  {
    this->release();
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>::Vertex() : content(0)
  {
    content = new CountedContent();
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>::Vertex(identity_t id)
    : content(reinterpret_cast<CountedContent*>(id))
  {
    acquire();
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>::Vertex(const Vertex& copy)
    : content(copy.content)
  {
    acquire();
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>& Vertex<VertexContent>::operator=(const identity_t& id)
  {
    if((identity_t)content == id)
      return *this;
    this->release();
    content = reinterpret_cast<CountedContent*>(id);
    acquire();
    return *this;
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>& Vertex<VertexContent>::operator=(const VertexContent* id)
  {
    const CountedContent* cid = dynamic_cast<const CountedContent*>(id);
    if(cid != 0)
      return *this = (const identity_t&)cid;
    else {
      return *this = (const identity_t&)(*(new CountedContent(*id)));
    }
  }
  
  template <typename VertexContent> void Vertex<VertexContent>::acquire()
  {
    if(content) {
      if(content->count == 0)
        content = 0;
      else
        #pragma omp atomic
        ++(content->count);
    }
  }
  
  template <typename VertexContent> void Vertex<VertexContent>::release()
  {
    if(content) {
      #pragma omp atomic
      --(content->count);
      if(content->count == 0) {
        delete content;
      }
    }
  }
  
  template <typename VertexContent>
  Vertex<VertexContent>& Vertex<VertexContent>::operator=(const Vertex& other)
  {
    if(content == other.content) {
      return *this;
    } else
      this->release();
                content = other.content;
                acquire();
    return *this;
  }
  
  template <typename VertexContent, typename Alloc, typename charT>
  std::basic_ostream<charT>& operator<<(std::basic_ostream<charT>& ss, const Vertex<VertexContent>& v)
  {
    ss << "Vertex<" << demangle(typeid(VertexContent).name()) << ">(" << v.id() << ")";
    return ss;
  }
}
 
namespace std 
{
  HASH_NS_ENTER
  template <typename VertexContent>
  struct hash<mgx::Vertex<VertexContent> > 
  {
    size_t operator()(const mgx::Vertex<VertexContent> &v) const
    {
      hash<size_t> h;
      return h((size_t)v.id());
      //return ((size_t)v.id()) >> 2;         // Shift to consider memory alignment!
    }
  };
  HASH_NS_EXIT
}
 
 
#endif // VERTEX_HPP