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)