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)