main page modules namespaces classes files
Gecode home

search for 

bool.hh

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  Last modified:
 *     $Date: 2006-09-05 21:48:13 +0200 (Tue, 05 Sep 2006) $ by $Author: schulte $
 *     $Revision: 3600 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#ifndef __GECODE_INT_BOOL_HH__
#define __GECODE_INT_BOOL_HH__

#include "gecode/int.hh"

namespace Gecode { namespace Int { namespace Bool {

  /*
   * Base Classes
   *
   */

  template<class BVA, class BVB>
  class BoolBinary : public Propagator {
  protected:
    BVA x0; 
    BVB x1; 

    BoolBinary(Space* home, BVA b0, BVB b1);
    BoolBinary(Space* home, bool share, BoolBinary& p);
    BoolBinary(Space* home, bool share, Propagator& p,
               BVA b0, BVB b1);
  public:
    virtual PropCost cost(void) const;
    virtual size_t dispose(Space* home);
  };

  template<class BVA, class BVB, class BVC>
  class BoolTernary : public Propagator {
  protected:
    BVA x0; 
    BVB x1; 
    BVC x2; 

    BoolTernary(Space* home, BVA b0, BVB b1, BVC b2);
    BoolTernary(Space* home, bool share, BoolTernary& p);
  public:
    BoolTernary(Space* home, bool share, Propagator& p,
                BVA b0, BVB b1, BVC b2);
    virtual PropCost cost(void) const;
    virtual size_t dispose(Space* home);
  };

  template<class BVA, class BVB>
  class Eq : public BoolBinary<BVA,BVB> {
  protected:
    using BoolBinary<BVA,BVB>::x0;
    using BoolBinary<BVA,BVB>::x1;
    Eq(Space* home, BVA b0, BVB b1);
    Eq(Space* home, bool share, Eq& p);
  public:
    Eq(Space* home, bool share, Propagator& p,
       BVA b0, BVB b1);
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, BVA b0, BVB b1);
  };


  template<class BVA, class BVB>
  class OrTrue : public BoolBinary<BVA,BVB> {
  protected:
    using BoolBinary<BVA,BVB>::x0;
    using BoolBinary<BVA,BVB>::x1;
    OrTrue(Space* home, BVA b0, BVB b1);
    OrTrue(Space* home, bool share, OrTrue& p);
  public:
    OrTrue(Space* home, bool share, Propagator& p,
             BVA b0, BVB b1);
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, BVA b0, BVB b1);
  };

  template<class BVA, class BVB, class BVC>
  class Or : public BoolTernary<BVA,BVB,BVC> {
  protected:
    using BoolTernary<BVA,BVB,BVC>::x0;
    using BoolTernary<BVA,BVB,BVC>::x1;
    using BoolTernary<BVA,BVB,BVC>::x2;
    Or(Space* home, BVA b0, BVB b1, BVC b2);
    Or(Space* home, bool share, Or& p);
  public:
    Or(Space* home, bool share, Propagator& p, BVA b0, BVB b1, BVC b2);
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, BVA b0, BVB b1, BVC b2);
  };

  template<class View>
  class NaryOr : public NaryOnePropagator<View,PC_INT_VAL> {
  protected:
    using NaryOnePropagator<View,PC_INT_VAL>::x;
    using NaryOnePropagator<View,PC_INT_VAL>::y;
    NaryOr(Space* home,  ViewArray<View>& b, View c);
    NaryOr(Space* home, bool share, NaryOr<View>& p);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, ViewArray<View>& b, View c);
  };


  template<class View>
  class NaryOrTrue : public BinaryPropagator<View,PC_INT_VAL> {
  protected:
    using BinaryPropagator<View,PC_INT_VAL>::x0;
    using BinaryPropagator<View,PC_INT_VAL>::x1;
    ViewArray<View> x;
    ExecStatus resubscribe(Space* home, View& x0, View x1);
    NaryOrTrue(Space* home,  ViewArray<View>& b);
    NaryOrTrue(Space* home, bool share, NaryOrTrue<View>& p);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual PropCost cost(void) const;
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, ViewArray<View>& b);
  };


  template<class BVA, class BVB, class BVC>
  class Eqv : public BoolTernary<BVA,BVB,BVC> {
  protected:
    using BoolTernary<BVA,BVB,BVC>::x0;
    using BoolTernary<BVA,BVB,BVC>::x1;
    using BoolTernary<BVA,BVB,BVC>::x2;
    Eqv(Space* home, bool share, Eqv& p);
    Eqv(Space* home, BVA b0 ,BVB b1, BVC b2);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, BVA b0, BVB b1, BVC b2);
  };

}}}

#include "gecode/int/bool/base.icc"
#include "gecode/int/bool/eq.icc"
#include "gecode/int/bool/or.icc"
#include "gecode/int/bool/eqv.icc"

#endif

// STATISTICS: int-prop