setedge.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
#ifndef BIOPROCESSING_GRAPH_SETEDGE
#define BIOPROCESSING_GRAPH_SETEDGE
 
//--- bioprocessing ----------------------------------------------------------
#include <bioprocessing/graph/baseedge.h>                     // bio::BaseEdge
//--- cartobase --------------------------------------------------------------
#include <cartobase/smart/rcptr.h>                            // carto::rc_ptr
//--- std --------------------------------------------------------------------
#include <set>                                                     // std::set
//----------------------------------------------------------------------------
 
namespace bio {
 
  template <typename V> class SetEdge;
  template <typename V> class SetEdgeRef;
 
//============================================================================
// Set EDGE: DECLARATION
//============================================================================
  template <typename V>
  class SetEdge: public BaseEdge<V>
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef SetEdge<V>              This;         
    typedef BaseEdge<V>             Base;         
    typedef std::set<V>             VertexSet;    
  public:
    typedef V                       Vertex;       
    typedef SetEdgeRef<V>           Edge;         
    typedef SetEdgeRef<V>           Ref;          
 
    //--- constructor --------------------------------------------------------
  public:
    SetEdge( const Vertex & x, const Vertex & y ): _set()
    {
      _set.insert(x);
      _set.insert(y);
    }

    SetEdge( const This & other ): _set(other._set) {}
    SetEdge( const Base & other ): _set()
    {
      _set.insert( other.x() );
      _set.insert( other.y() );
    }
    virtual ~SetEdge() {}
 
    //--- iterators ----------------------------------------------------------
  public:
    typedef typename VertexSet::const_iterator  const_iterator;
    typedef typename VertexSet::iterator        iterator;
    const_iterator begin() const { return _set.begin(); }
    const_iterator end()   const { return _set.end(); }
    iterator       begin()       { return _set.begin(); }
    iterator       end()         { return _set.end(); }
 
    //--- accessor -----------------------------------------------------------
  public:
          Vertex x()       { return *( begin() ); }
    const Vertex x() const { return *( begin() ); }
          Vertex y()       { return *( ++( begin() ) ); }
    const Vertex y() const { return *( ++( begin() ) ); }
          Vertex other( const Vertex & v )
    {
      iterator i = begin();
      return( v == *i ? *(++i) : *i );
    }

    const Vertex other( const Vertex & v ) const
    {
      const_iterator i = begin();
      return( v == *i ? *(++i) : *i );
    }
 
    //--- virtual operators ----------------------------------------------------
  public:
    virtual bool operator== ( const This & other ) const
    {
      return x() == other.x() && y() == other.y();
    }

    virtual bool operator!= ( const This & other ) const
    {
      return x() != other.x() || y() != other.y();
    }

    virtual bool operator>  ( const This & other ) const
    {
      const_iterator i, j;
      for( i = begin(), j = other.begin(); i != end(); ++i, ++j )
      {
        if( *i > *j )
          return true;
        else if( *i < *j )
          return false;
      }
      return false;
    }

    virtual bool operator<  ( const This & other ) const
    {
      const_iterator i, j;
      for( i = begin(), j = other.begin(); i != end(); ++i, ++j )
      {
        if( *i < *j )
          return true;
        else if( *i > *j )
          return false;
      }
      return false;
    }

    virtual bool operator>= ( const This & other ) const
    {
      return ( *this == other ) || ( *this > other );
    }

    virtual bool operator<= ( const This & other ) const
    {
      return ( *this == other ) || ( *this < other );
    }
 
    //--- members ------------------------------------------------------------
    VertexSet _set;
 
    //--- friends ------------------------------------------------------------
    friend class SetEdgeRef<V>;
  };
 
//============================================================================
// SET EDGE REF
//============================================================================
  template <typename V>
  class SetEdgeRef: public BaseEdgeRef<V>
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef SetEdgeRef<V>                 This;     
    typedef BaseEdgeRef<V>                Base;     
    typedef SetEdge<V>                    Pointed;  
  public:
    typedef typename Pointed::Vertex      Vertex;   
    typedef typename Pointed::Edge        Edge;     
 
    //--- constructor --------------------------------------------------------
  protected:
    SetEdgeRef(): Base() {}
  public:
    SetEdgeRef( const Vertex & x, const Vertex & y ): Base( new Pointed(x,y) ) {}
    SetEdgeRef( Pointed * e ): Base(e) {}
    SetEdgeRef( const Base & other ): Base(other) {}
    virtual ~SetEdgeRef() {}
 
    //--- none factory -------------------------------------------------------
  public:
    static Edge none() { return This( (Pointed*)0 ); }
 
    //--- iterators ----------------------------------------------------------
  public:
    typedef typename Pointed::iterator        iterator;
    typedef typename Pointed::const_iterator  const_iterator;
    virtual const_iterator begin() const { return ((Pointed*)(this->get()))->begin(); }
    virtual const_iterator end() const { return ((Pointed*)(this->get()))->end(); }
    virtual iterator       begin() { return ((Pointed*)(this->get()))->begin(); }
    virtual iterator       end() { return ((Pointed*)(this->get()))->end(); }
 
    //--- virtual operators --------------------------------------------------
  public:
    virtual bool operator== ( const This & other ) const
    {
      if( !(*this) && !other )
        return true;
      else if( !(*this) || !other )
        return false;
      else
        return *((Pointed*)this->get()) == *((Pointed*)other.get());
    }
    virtual bool operator!= ( const This & other ) const
    {
      return !( *this == other );
    }
    virtual bool operator>  ( const This & other ) const
    {
      if( *this == other )
        return false;
      else if( !(*this) || !other )
        return false;
      else
        return *((Pointed*)this->get()) > *((Pointed*)other.get());
    }
    virtual bool operator<  ( const This & other ) const
    {
      if( *this == other )
        return false;
      else if( !(*this) || !other )
        return false;
      else
        return *((Pointed*)this->get()) < *((Pointed*)other.get());
    }
    virtual bool operator>= ( const This & other ) const
    {
      return ( *this == other ) || ( *this > other );
    }
    virtual bool operator<= ( const This & other ) const
    {
      return ( *this == other ) || ( *this < other );
    }
 
    //--- friends ------------------------------------------------------------
    friend class SetEdge<V>;
  };
 
} // namespace bio
 
#endif // BIOPROCESSING_GRAPH_BASEEDGE