BasicPointPredicates.h

#pragma once

#if defined(BasicPointPredicates_RECURSES)
#error Recursive header files inclusion detected in BasicPointPredicates.h
#else // defined(BasicPointPredicates_RECURSES)

#define BasicPointPredicates_RECURSES

#if !defined BasicPointPredicates_h

#define BasicPointPredicates_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/BasicBoolFunctions.h"
#include "DGtal/base/CUnaryFunctor.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/kernel/CPointPredicate.h"

namespace DGtal
{

  // template class ConstantPointPredicate
  template <typename TPoint, bool boolCst>
  struct ConstantPointPredicate
  {
    typedef TPoint Point;

    bool operator()( const Point & p ) const;

  }; // end of class ConstantPointPredicates

  // template class TruePointPredicate
  template <typename TPoint>
  struct TruePointPredicate : public ConstantPointPredicate<TPoint,true>
  {
      typedef TPoint Point;
  };

  // template class FalsePointPredicate
  template <typename TPoint>
  struct FalsePointPredicate : public ConstantPointPredicate<TPoint,false>
  {
      typedef TPoint Point;
  };

  // template class IsLowerPointPredicate
  template <typename TPoint>
  struct IsLowerPointPredicate
  {
    typedef TPoint Point;
    IsLowerPointPredicate( const Point & upperBound );

    bool operator()( const Point & p ) const;

    Point myUpperBound;
  };

  // template class IsUpperPointPredicate
  template <typename TPoint>
  struct IsUpperPointPredicate
  {
    typedef TPoint Point;
    IsUpperPointPredicate( const Point & lowerBound );

    bool operator()( const Point & p ) const;

    Point myLowerBound;
  };

  // template class IsWithinPointPredicate
  template <typename TPoint>
  struct IsWithinPointPredicate
  {
    typedef TPoint Point;
    IsWithinPointPredicate( const Point & lowerBound,
          const Point & upperBound );

    bool operator()( const Point & p ) const;

    Point myLowerBound;
    Point myUpperBound;
  };

  // template class NotPointPredicate
  template <typename TPointPredicate>
  struct NotPointPredicate
  {
    typedef TPointPredicate PointPredicate;
    //BOOST_CONCEPT_ASSERT (( CPointPredicate<PointPredicate> )); 
   
    typedef typename PointPredicate::Point Point;

    NotPointPredicate( const PointPredicate & pred );

    bool operator()( const Point & p ) const;

    const PointPredicate & myPred;
  };

  // template class EqualPointPredicate
  template <typename TPoint>
  struct EqualPointPredicate
  {
    typedef TPoint Point;

    EqualPointPredicate( const Point & aPoint );

    bool operator()( const Point & p ) const;

    Point myPoint;
  };

  // template class BinaryPointPredicate
  template <typename TPointPredicate1, typename TPointPredicate2, 
            typename TBinaryFunctor = BoolFunction2 >
  struct BinaryPointPredicate
  {
    typedef TPointPredicate1 PointPredicate1;
    typedef TPointPredicate2 PointPredicate2;
    typedef typename PointPredicate1::Point Point;
    // should be the same.
    BOOST_STATIC_ASSERT ((boost::is_same< Point, typename PointPredicate2::Point >::value)); 
    //BOOST_CONCEPT_ASSERT (( CPointPredicate<PointPredicate1> )); 
    //BOOST_CONCEPT_ASSERT (( CPointPredicate<PointPredicate2> )); 
    
    typedef typename PointPredicate2::Point Point2;

    BinaryPointPredicate( const PointPredicate1 & pred1,
        const PointPredicate2 & pred2,
        const TBinaryFunctor & boolFunctor );

    BinaryPointPredicate(  const BinaryPointPredicate& other );

    BinaryPointPredicate& operator=( const BinaryPointPredicate& other );

    ~BinaryPointPredicate();

    bool operator()( const Point & p ) const;

    const PointPredicate1* myPred1;
    const PointPredicate2* myPred2;
    const TBinaryFunctor* myBoolFunctor;
  };

  // template class PointFunctorPredicate
  template <typename TPointFunctor, typename TPredicate>
  struct PointFunctorPredicate
  {
    BOOST_CONCEPT_ASSERT (( CPointFunctor< TPointFunctor > ));  
    BOOST_CONCEPT_ASSERT (( CUnaryFunctor< TPredicate, typename TPointFunctor::Value, bool > ));  

    typedef TPointFunctor PointFunctor;
    typedef TPredicate Predicate;
    typedef typename PointFunctor::Point Point; 

    PointFunctorPredicate( const PointFunctor & aFun,
        const Predicate & aPred );

    PointFunctorPredicate(  const PointFunctorPredicate& other );

    PointFunctorPredicate& operator=( const PointFunctorPredicate& other );

    ~PointFunctorPredicate();

    bool operator()( const Point & p ) const;

    const PointFunctor* myFun;
    const Predicate* myPred;
  };

} // namespace DGtal


// Includes inline functions.
#include "DGtal/kernel/BasicPointPredicates.ih"

//                                                                           //

#endif // !defined BasicPointPredicates_h

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