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"

namespace DGtal
{

  // class CDigitalSet
  // class CDigitalSet
  template <typename T> 
  struct CDigitalSet :
    boost::CopyConstructible< T >, 
    boost::Assignable< 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(( boost::BidirectionalIterator< Iterator > ));
    //    BOOST_CONCEPT_ASSERT(( boost_concepts::LvalueIteratorConcept<Iterator > ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<Iterator > ));
//DigitalSetFromMap cannot be a model of CDigitalSet if lvalue is required because 
//in STL maps, in pairs <const key, value>, key is const... 
    BOOST_CONCEPT_ASSERT(( boost_concepts::BidirectionalTraversalConcept<Iterator > ));

    //BOOST_CONCEPT_ASSERT(( boost::BidirectionalIterator<ConstIterator > ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<ConstIterator > ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::BidirectionalTraversalConcept<ConstIterator > ));

    // To test if two types A and Y are equals, use
    // BOOST_STATIC_ASSERT( ConceptUtils::sameType<A,X>::value );    

    // 2. then check the presence of data members, operators and methods with
    BOOST_CONCEPT_USAGE( CDigitalSet )
    {
      ConceptUtils::sameType( myDomain, myX.domain() );
      ConceptUtils::sameType( mySize, myX.size() );
      ConceptUtils::sameType( myBool, myX.empty() );
      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( myIterator, myX.begin() );
      ConceptUtils::sameType( myIterator, myX.end() );
      ConceptUtils::sameType( myX, myX.operator+=( myX ) );
      myX.computeComplement( myOutputIt );
      myX.assignFromComplement( myX );
      myX.computeBoundingBox( myPoint, myPoint );
      checkConstConstraints();
      checkNonConstConstraints();
      // look at CInteger.h for testing tags.
    }
    void checkConstConstraints() const
    {
      ConceptUtils::sameType( myConstIterator, myX.find( myPoint ) );
      ConceptUtils::sameType( myConstIterator, myX.begin() );
      ConceptUtils::sameType( myConstIterator, myX.end() );
    }

    void checkNonConstConstraints()
    {
      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;
    Size mySize;
    bool myBool;
    Point myPoint;
    Iterator myIterator;
    ConstIterator myConstIterator;
    Point* myOutputIt; 
    // ------------------------- Internals ------------------------------------
  private:
    
  }; // end of concept CDigitalSet
  
} // namespace DGtal


// Includes inline functions.
#include "DGtal/kernel/sets/CDigitalSet.ih"

//                                                                           //

#endif // !defined CDigitalSet_h

#undef CDigitalSet_RECURSES
#endif // else defined(CDigitalSet_RECURSES)