CDigitalSetArchetype.h

 
#pragma once
 
#ifndef _MSC_VER
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
 
 
#if defined(CDigitalSetArchetype_RECURSES)
#error Recursive header files inclusion detected in CDigitalSetArchetype.h
#else // defined(CDigitalSetArchetype_RECURSES)
#define CDigitalSetArchetype_RECURSES
 
#if !defined CDigitalSetArchetype_h
#define CDigitalSetArchetype_h
 
// Inclusions
#include <iostream>
#include <set>
#include <string>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
 
namespace DGtal
{
  namespace concepts
  {
  // template class CDigitalSetArchetype
  template <typename TDomain>
  class CDigitalSetArchetype
  {
  public:
    typedef TDomain Domain;
    typedef typename Domain::Point Point;
    typedef typename Domain::Size Size;
    //typedef boost::bidirectional_iterator_archetype<Point> Iterator;
    typedef CSinglePassIteratorArchetype<Point> Iterator;
    typedef Iterator ConstIterator;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~CDigitalSetArchetype() {}
 
    CDigitalSetArchetype( const Domain & d ) {}
 
    CDigitalSetArchetype ( const CDigitalSetArchetype & other ) {}
 
    CDigitalSetArchetype & operator= ( const CDigitalSetArchetype & other ) 
    { return *this; }
 
    const Domain & domain() const { return DummyObject<Domain>::get(); }
 
    CowPtr<Domain> domainPointer() const { return DummyObject< CowPtr<Domain> >::get(); }
 
    // ----------------------- Standard Set services --------------------------
  public:
 
    Size size() const { return 0; }
 
    bool empty() const { return true; }
     
    void insert( const Point & p ) {}
 
    template <typename PointInputIterator>
    void insert( PointInputIterator first, PointInputIterator last ) {}
 
    void insertNew( const Point & p ) {}
 
    template <typename PointInputIterator>
    void insertNew( PointInputIterator first, PointInputIterator last ) {}
 
    Size erase( const Point & p ) { return 0; }
 
    void erase( Iterator it ) {}
 
    void erase( Iterator first, Iterator last ) {}
 
    void clear() {}
 
    ConstIterator find( const Point & p ) const 
    { return DummyObject<ConstIterator>::get(); }
 
    Iterator find( const Point & p )
    { return DummyObject<Iterator>::get(); }
 
    ConstIterator begin() const
    { return DummyObject<ConstIterator>::get(); }
 
    ConstIterator end() const
    { return DummyObject<ConstIterator>::get(); }
 
    Iterator begin()
    { return DummyObject<Iterator>::get(); }
 
    Iterator end()
    { return DummyObject<Iterator>::get(); }
 
    CDigitalSetArchetype<Domain> & operator+=
    ( const CDigitalSetArchetype<Domain> & aSet )
    { return *this; }
 
    // ----------------------- Model of concepts::CPointPredicate -----------------------------
  public:
 
    bool operator()( const Point & p ) const
    { return p == p; }
 
    // ----------------------- Other Set services -----------------------------
  public:
    
   template< typename TOutputIterator >
    void computeComplement(TOutputIterator& ito) const {}
 
    void assignFromComplement( const CDigitalSetArchetype<Domain> & other_set )
    {}
    
    void computeBoundingBox( Point & lower, Point & upper ) const {}
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const {}
 
    bool isValid() const { return true; }
 
 
  }; // end of class CDigitalSetArchetype
  }
} // namespace DGtal
 
 
//                                                                           //
 
#endif // !defined CDigitalSetArchetype_h
 
#undef CDigitalSetArchetype_RECURSES
#endif // else defined(CDigitalSetArchetype_RECURSES)