CDigitalSurfaceContainer.h

 
#pragma once

 
#if defined(CDigitalSurfaceContainer_RECURSES)
#error Recursive header files inclusion detected in CDigitalSurfaceContainer.h
#else // defined(CDigitalSurfaceContainer_RECURSES)
#define CDigitalSurfaceContainer_RECURSES
 
#if !defined CDigitalSurfaceContainer_h
#define CDigitalSurfaceContainer_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/topology/Topology.h"
#include "DGtal/topology/CCellularGridSpaceND.h"
#include "DGtal/topology/CDigitalSurfaceTracker.h"
 
// @since 0.8 In DGtal::concepts
namespace DGtal {
  namespace concepts {

  // class CDigitalSurfaceContainer
  template <typename T>
  struct CDigitalSurfaceContainer : boost::CopyConstructible<T>
  {
    // ----------------------- Concept checks ------------------------------
  public:
    typedef typename T::KSpace KSpace;
    typedef typename T::Surfel Surfel;
    typedef typename T::SurfelConstIterator SurfelConstIterator;
    typedef typename T::DigitalSurfaceTracker DigitalSurfaceTracker;
    typedef typename T::Size Size;
 
    BOOST_CONCEPT_ASSERT(( boost_concepts::SinglePassIteratorConcept<SurfelConstIterator> ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<SurfelConstIterator> ));
    BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND<KSpace> ));
    BOOST_CONCEPT_ASSERT(( CDigitalSurfaceTracker<DigitalSurfaceTracker> ));
 
    // 2. then check the presence of data members, operators and methods with
    BOOST_CONCEPT_USAGE( CDigitalSurfaceContainer )
    {
      // check const methods.
      checkConstConstraints();
    }
    void checkConstConstraints() const
    {
      // x.space() const, returns a const KSpace &
      ConceptUtils::sameType( myKSpace, myX.space() );
      // x.isInside( Surfel ) const, returns bool.
      ConceptUtils::sameType( myBool, myX.isInside( mySurfel ) );
      // x.begin() const, returns SurfelConstIterator
      ConceptUtils::sameType( mySurfelCIt, myX.begin() );
      // x.end() const, returns SurfelConstIterator
      ConceptUtils::sameType( mySurfelCIt, myX.end() );
      // x.newTracker( Surfel ) const, returns DigitalSurfaceTracker*
      ConceptUtils::sameType( myPtrTracker, myX.newTracker( mySurfel ) );
      // x.connectedness() const, returns Connectedness
      ConceptUtils::sameType( myConnectedness, myX.connectedness() );
      // x.nbSurfels() const, returns Connectedness
      ConceptUtils::sameType( mySize, myX.nbSurfels() );
      // x.empty() const, returns bool
      ConceptUtils::sameType( myBool, myX.empty() );
    }
    // ------------------------- Private Data --------------------------------
  private:
    T myX; // do not require T to be default constructible.
    KSpace myKSpace;
    Surfel mySurfel;
    bool myBool;
    SurfelConstIterator mySurfelCIt;
    DigitalSurfaceTracker* myPtrTracker;
    Connectedness myConnectedness;
    Size mySize;
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of concept CDigitalSurfaceContainer
 
} // namespace concepts
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined CDigitalSurfaceContainer_h
 
#undef CDigitalSurfaceContainer_RECURSES
#endif // else defined(CDigitalSurfaceContainer_RECURSES)