pointvertex.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_POINTVERTEX
#define BIOPROCESSING_GRAPH_POINTVERTEX
 
//--- bioprocessing ----------------------------------------------------------
#include <bioprocessing/graph/basevertex.h>                 // bio::BaseVertex
//--- cartobase --------------------------------------------------------------
#include <cartobase/smart/rcptr.h>                            // carto::rc_ptr
//--- std --------------------------------------------------------------------
#include <typeinfo>                                                  // typeid
//----------------------------------------------------------------------------
namespace bio {
 
  template <typename P> class PointVertex;
  template <typename P> class PointVertexRef;
 
//============================================================================
// POINT VERTEX
//============================================================================
  template <typename P>
  class PointVertex: public BaseVertex
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef PointVertex<P>         This;      
    typedef BaseVertex             Base;      
  public:
    typedef PointVertexRef<P>      Vertex;    
    typedef PointVertexRef<P>      Ref;       
    typedef P                      Point;     
 
    //--- constructor --------------------------------------------------------
  public:
    PointVertex( const Point & p ): _point(p) {}
    PointVertex( const This & other ): _point(other._point) {}
    virtual ~PointVertex() {}
 
    //--- accessor -----------------------------------------------------------
  public:
    const Point & point() const { return _point; }
          Point & point() { return _point; }
 
    //--- comparison ---------------------------------------------------------
  public:
    virtual bool operator==( const This & other ) const
    {
      if( typeid(other) != typeid(*this) )
        return false;
      return _point == ( (const This &)other )._point;
    }
    virtual bool operator!=( const This & other ) const
    {
      return !operator==( other );
    }
    virtual bool operator>( const This & other ) const
    {
      if( typeid(other) != typeid(*this) )
        return this > &other;
 
      for( int i = _point.size()-1; i >= 0; --i )
      {
        if( _point[i] > ( (const This &)other )._point[i] )
          return true;
        else if( _point[i] < ( (const This &)other )._point[i] )
          return false;
      }
      return false;
    }
    virtual bool operator<( const This & other ) const
    {
      if( operator>( other ) || operator==( other ) )
        return false;
      return true;
    }
    virtual bool operator<=( const This & other ) const
    {
      if( operator<( other ) || operator==( other ) )
        return true;
      return false;
    }
    virtual bool operator>=( const This & other ) const
    {
      if( operator>( other ) || operator==( other ) )
        return true;
      return false;
    }
 
    //--- members ------------------------------------------------------------
  protected:
    Point _point;
 
    //--- friends ------------------------------------------------------------
    friend class PointVertexRef<P>;
  };
 
} // namespace bio
 
//============================================================================
// BASE EDGE: STREAM
//============================================================================
template <typename P>
std::ostream & operator<<( std::ostream & os, const bio::PointVertex<P> & v )
{
  os << "V{ " << v.point() << " }";
  return os;
}
 
namespace bio {
 
//============================================================================
// POINT VERTEX REF
//============================================================================
  template <typename P>
  class PointVertexRef: public BaseVertexRef
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef PointVertexRef<P>   This;               
    typedef BaseVertexRef       Base;               
    typedef PointVertex<P>      Pointed;            
  public:
    typedef typename Pointed::Vertex     Vertex;    
    typedef typename Pointed::Point      Point;     
 
    //--- constructor --------------------------------------------------------
  public:
    PointVertexRef(): Base() {}
    PointVertexRef( const Point & p ): Base( new Pointed( p ) ) {}
    PointVertexRef( Pointed * v ): Base(v) {}
    PointVertexRef( const Base & other ): Base( other ) {}
    virtual ~PointVertexRef() {}
 
    //--- none factory -------------------------------------------------------
  public:
    static Vertex none() { return This( (Pointed*)0 ); }
 
    //--- 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 );
    }
 
    //--- accessor -----------------------------------------------------------
  public:
    const Point & point() const { return ((Pointed*)(this->get()))->point(); }
          Point & point() { return ((Pointed*)(this->get()))->point(); }
  };
 
} // namespace bio
 
//============================================================================
// BASE EDGE REF: STREAM
//============================================================================
template <typename P>
std::ostream & operator<<( std::ostream & os, const bio::PointVertexRef<P> & v )
{
  if( v.get() )
    os << *( (bio::PointVertex<P> *)v.get() );
  else
    os << "V{ NULL }";
  return os;
}
 
#endif // BIOPROCESSING_GRAPH_POINTVERTEX