CDigitalSet.h

 
#pragma once
 
#if defined(CDigitalSet_RECURSES)
#error Recursive header files inclusion detected in CDigitalSet.h
#else // defined(CDigitalSet_RECURSES)
#define CDigitalSet_RECURSES
 
#if !defined CDigitalSet_h
#define CDigitalSet_h
 
// Inclusions
#include <iostream>
#include "boost/concept_check.hpp"
#include "DGtal/base/Common.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/domains/CDomain.h"
 
namespace DGtal
{
  namespace concepts
  {
  // class CDigitalSet
  // class CDigitalSet
  template <typename T> 
  struct CDigitalSet :
    boost::CopyConstructible< T >, 
    concepts::CPointPredicate< T >
  {
    // ----------------------- Concept checks ------------------------------
  public:
    // 1. define first provided types (i.e. inner types), like
    typedef typename T::Domain Domain;
    typedef typename T::Point Point;
    typedef typename T::Size Size;
    typedef typename T::Iterator Iterator;
    typedef typename T::ConstIterator ConstIterator;
 
    BOOST_CONCEPT_ASSERT(( concepts::CDomain<Domain> ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<ConstIterator > ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::SinglePassIteratorConcept<ConstIterator > ));
    
    // 2. then check the presence of data members, operators and methods with
    BOOST_CONCEPT_USAGE( CDigitalSet )
    {
      checkConstConstraints();
      checkNonConstConstraints();
    }
    void checkConstConstraints() const
    {
      ConceptUtils::sameType( myDomain, myX.domain() );
      ConceptUtils::sameType( myDomainPtr, myX.domainPointer() );
      ConceptUtils::sameType( mySize, myX.size() );
      ConceptUtils::sameType( myBool, myX.empty() );
 
      ConceptUtils::sameType( myConstIterator, myX.find( myPoint ) );
      ConceptUtils::sameType( myConstIterator, myX.begin() );
      ConceptUtils::sameType( myConstIterator, myX.end() );
    }
 
    void checkNonConstConstraints()
    {
      myX.insert( myPoint );
      // template <typename PointInputIterator>
      //   BOOST_CONCEPT_REQUIRES
      //   ( ((boost::InputIterator<PointInputIterator>)),
      //     (void) )
      //   myX.insert( PointInputIterator, PointInputIterator );
      myX.insertNew( myPoint );
      ConceptUtils::sameType( mySize, myX.erase( myPoint ) );
      myX.erase( myIterator );
      myX.erase( myIterator, myIterator );
      myX.clear();
      ConceptUtils::sameType( myX, myX.operator+=( myX ) );
      myX.computeComplement( myOutputIt );
      myX.assignFromComplement( myX );
      myX.computeBoundingBox( myPoint, myPoint );
      ConceptUtils::sameType( myIterator, myX.find( myPoint ) );
      ConceptUtils::sameType( myIterator, myX.begin() );
      ConceptUtils::sameType( myIterator, myX.end() );
    }
 
    // ------------------------- Private Datas --------------------------------
  private:
    T myX; // only if T is default constructible.
    Domain myDomain;
    CowPtr<Domain> myDomainPtr;
    Size mySize;
    bool myBool;
    Point myPoint;
    Iterator myIterator;
    ConstIterator myConstIterator;
    Point* myOutputIt; 
    // ------------------------- Internals ------------------------------------
  private:
    
  }; // end of concept CDigitalSet
  }  
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined CDigitalSet_h
 
#undef CDigitalSet_RECURSES
#endif // else defined(CDigitalSet_RECURSES)