BasicBoolFunctors.h

 
#pragma once
 
#if defined(BasicBoolFunctors_RECURSES)
#error Recursive header files inclusion detected in BasicBoolFunctors.h
#else // defined(BasicBoolFunctors_RECURSES)
#define BasicBoolFunctors_RECURSES
 
#if !defined BasicBoolFunctors_h
#define BasicBoolFunctors_h
 
// Inclusions
#include <iostream>
#include <boost/function.hpp>
 
// @since 0.8 In DGtal::functors
namespace DGtal {
  namespace functors {
 
  typedef boost::function0< bool > BoolFunctor0;
 
  typedef boost::function1< bool, bool > BoolFunctor1;
 
  typedef boost::function2< bool, bool, bool > BoolFunctor2;
 
  typedef boost::function3< bool, bool, bool, bool > BoolFunctor3;
 
  struct TrueBoolFct0 {
    bool operator()() const;
  };
 
  struct FalseBoolFct0 {
    bool operator()() const;
  };
 
  static const BoolFunctor0 trueBF0 = TrueBoolFct0();
 
  static const BoolFunctor0 falseBF0 = FalseBoolFct0();
 
  struct IdentityBoolFct1 {
    bool operator()( bool b ) const;
  };
 
  struct NotBoolFct1 {
    bool operator()( bool b ) const;
  };
 
  static const BoolFunctor1 identityBF1 = IdentityBoolFct1();
 
  static const BoolFunctor1 notBF1 = NotBoolFct1();
 
  struct AndBoolFct2 {
    bool operator()( bool b1, bool b2 ) const;
  };
 
  struct OrBoolFct2 {
    bool operator()( bool b1, bool b2 ) const;
  };
 
  struct XorBoolFct2 {
    bool operator()( bool b1, bool b2 ) const;
  };
 
  struct ImpliesBoolFct2 {
    bool operator()( bool b1, bool b2 ) const;
  };
 
  static const BoolFunctor2 andBF2 = AndBoolFct2();
 
  static const BoolFunctor2 orBF2 = OrBoolFct2();
 
  static const BoolFunctor2 xorBF2 = XorBoolFct2();
 
  static const BoolFunctor2 impliesBF2 = ImpliesBoolFct2();
 
} // namespace functors
} // namespace DGtal
 
 
// Includes inline functors.
#include "DGtal/base/BasicBoolFunctors.ih"
 
//                                                                           //
 
#endif // !defined BasicBoolFunctors_h
 
#undef BasicBoolFunctors_RECURSES
#endif // else defined(BasicBoolFunctors_RECURSES)