gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/gecode/kernel/reflection.icc

@@ -1,1012 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Guido Tack, 2007
- *
- *  Last modified:
- *     $Date: 2008-03-05 09:20:52 +0100 (Wed, 05 Mar 2008) $ by $Author: tack $
- *     $Revision: 6414 $
- *
- *  This file is part of Gecode, the generic constraint
- *  development environment:
- *     http://www.gecode.org
- *
- *  Permission is hereby granted, free of charge, to any person obtaining
- *  a copy of this software and associated documentation files (the
- *  "Software"), to deal in the Software without restriction, including
- *  without limitation the rights to use, copy, modify, merge, publish,
- *  distribute, sublicense, and/or sell copies of the Software, and to
- *  permit persons to whom the Software is furnished to do so, subject to
- *  the following conditions:
- *
- *  The above copyright notice and this permission notice shall be
- *  included in all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include <iostream>
-#include <cstring>
-
-/**
- * \namespace Gecode::Reflection
- * \brief %Reflection support
- */
-
-namespace Gecode { namespace Reflection {
-  
-  /** \addtogroup TaskReflection
-    * @{
-    */
-  
-  /// Exception for errors during reflection
-  class GECODE_VTABLE_EXPORT ReflectionException : public Exception {
-  public:
-    /// Constructor
-    ReflectionException(const char* what) : Exception("Reflection", what) {}
-  };
-
-  /// Exception: no reflection defined
-  class GECODE_VTABLE_EXPORT NoReflectionDefinedException
-  : public ReflectionException {
-  public:
-    NoReflectionDefinedException(void)
-    : ReflectionException("No reflection defined") {}
-  };
-
-  //@}
-  
-  class ArrayArg;
-  class IntArrayArg;
-  
-  /**
-    * \brief Arguments for actor and variable specifications
-    *
-    * These arguments implement a simple term language. A term is
-    * an integer, a variable, an array of terms, an array of integers,
-    * a string, a pair, a shared object, or a reference to a shared object.
-    *
-    * Variables are represented by integers that correspond to indices in a
-    * VarMap.
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT Arg {
-  protected:
-    /// The different types of arguments
-    enum argtype {
-      INT_ARG,           ///< Integer argument
-      VAR_ARG,           ///< Variable argument
-      ARRAY_ARG,         ///< Array argument
-      INT_ARRAY_ARG,     ///< Integer array argument
-      STRING_ARG,        ///< String argument
-      PAIR_ARG,          ///< Pair argument
-      SHARED_OBJECT_ARG, ///< Shared object argument
-      SHARED_REF_ARG     ///< Reference to shared object argument
-    };
-
-    /// Argument type of this Arg
-    argtype t;
-    
-    union {
-      /// The integer of an INT_ARG, the index of a VAR_ARG or SHARED_REF_ARG, or the size of an ARRAY_ARG or INT_ARRAY_ARG
-      int i;
-      /// The string of a STRING_ARG
-      char* s;
-      /// The first argument of a PAIR_ARG, or the object of a SHARED_OBJECT_ARG
-      Arg* first;
-    } arg1;
-
-    union {
-      /// The second argument of a PAIR_ARG
-      Arg* second;
-      /// The array of an ARRAY_ARG
-      Arg** aa;
-      /// The array of an INT_ARRAY_ARG
-      int* ia;
-    } arg2;
-    /// Constructor
-    Arg(argtype t);
-    
-  public:
-    /// %Test if this represents an integer
-    bool         isInt(void) const;
-    /// Return the integer that this argument represents
-    int          toInt(void) const;
-    /// Create new int argument
-    static Arg*  newInt(int i);
-    /// Initialize this as an int argument
-    void         initInt(int i);
-    
-    /// %Test if this represents a variable
-    bool         isVar(void) const;
-    /// Return the variable index that this argument represents
-    int          toVar(void) const;
-    /// Create new variable argument
-    static Arg*  newVar(int i);
-    /// Initialize this as a variable argument
-    void         initVar(int i);
-    
-    /// %Test if this represents an array
-    bool             isArray(void) const;
-    /// Return the array that this argument represents
-    ArrayArg*        toArray(void);
-    /// Return the array that this argument represents
-    const ArrayArg*  toArray(void) const;
-    /// Create new array argument with size \a n
-    static ArrayArg* newArray(int n);
-    /// Initialize this as an array argument with size \a n
-    void         initArray(int n);
-    
-    /// %Test if this represents an array
-    bool                isIntArray(void) const;
-    /// Return the array that this argument represents
-    IntArrayArg*        toIntArray(void);
-    /// Return the array that this argument represents
-    const IntArrayArg*  toIntArray(void) const;
-    /// Create new integer array argument with size \a n
-    static IntArrayArg* newIntArray(int n);
-    /// Create new integer array argument from array \a a
-    template <class A>
-    static IntArrayArg* newIntArray(const A& a);
-    /// Initialize this as an int array argument with size \a n
-    void         initIntArray(int n);
-
-    /// %Test if this represents a string
-    bool         isString(void) const;
-    /// Return the string that this argument represents
-    const char*  toString(void) const;
-    /// Create new string argument
-    static Arg*  newString(const char* s);
-    /// Initialize this as a string argument
-    void         initString(const char* s);
-    
-    /// %Test if this represents a pair
-    bool         isPair(void) const;
-    /// Return the first component of the pair that this argument represents
-    Arg*         first(void);
-    /// Return the first component of the pair that this argument represents
-    const Arg*   first(void) const;
-    /// Return the second component of the pair that this argument represents
-    Arg*         second(void);
-    /// Return the second component of the pair that this argument represents
-    const Arg*   second(void) const;
-    /// Create new pair argument from \a a and \a b
-    static Arg*  newPair(Arg* a, Arg* b);
-    /// Initialize this as a pair argument from \a a and \a b
-    void         initPair(Arg* a, Arg* b);
-    
-    /// %Test if this represents a shared object
-    bool         isSharedObject(void) const;
-    /// Return the shared object that this argument represents
-    Arg*         toSharedObject(void);
-    /// Return the shared object that this argument represents
-    const Arg*   toSharedObject(void) const;
-    /// Create new shared object
-    static Arg*  newSharedObject(Arg* a);
-    /// Initialize this as a shared object
-    void         initSharedObject(Arg* a);
-    
-    /// %Test if this represents a shared object reference
-    bool         isSharedReference(void) const;
-    /// Return the shared object that this argument represents
-    int          toSharedReference(void) const;
-    /// Create new reference to shared object
-    static Arg*  newSharedReference(int ref);
-    /// Initialize this as a reference to a shared object
-    void         initSharedReference(int ref);
-    
-    /// Destructor
-    GECODE_MSC_VIRTUAL ~Arg(void);
-  };
-  
-
-  /**
-    * \brief Array arguments
-    *
-    * This is a convenience class that exposes an array interface
-    * for an Arg that was created via Arg::newArray.
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT ArrayArg : public Arg {
-  private:
-    /// Use Arg::newArray instead
-    ArrayArg(void);
-  public:
-    /// Element access
-    const Arg* operator[](int i) const;
-    /// Element access
-    Arg*& operator[](int i);
-    /// Size of the array
-    int size(void) const;
-  };
-
-  /**
-    * \brief Integer array arguments
-      *
-      * This is a convenience class that exposes an array interface
-      * for an Arg that was created via Arg::newIntArray.
-      *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT IntArrayArg : public Arg {
-  private:
-    /// Use Arg::newIntArray instead
-    IntArrayArg(void);
-  public:
-    /// Element access
-    const int& operator[](int i) const;
-    /// Element access
-    int& operator[](int i);
-    /// Size of the array
-    int size(void) const;
-  };
-
-  /**
-    * \brief Iterate over an IntArrayArg, interpreting consecutive
-    * pairs of integers as ranges
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT IntArrayArgRanges {
-  private:
-    /// The array
-    Reflection::IntArrayArg* a;
-    /// The current position
-    int n;
-  public:
-    /// Constructor
-    IntArrayArgRanges(Reflection::IntArrayArg* a0);
-    /// %Test whether iterator is still at a valid range
-    bool operator()(void);
-    /// Move iterator to next range
-    void operator++(void);
-    /// Minimum of current range
-    int min(void) const;
-    /// Maximum of current range
-    int max(void) const;
-    /// Width of current range
-    unsigned int width(void) const;
-  };
-  
-  /**
-    * \brief %Variable specification
-    *
-    * A VarSpec contains an abstract specification of a variable 
-    * implementation. These specifications are typically stored in a VarMap.
-    *
-    * The type of the variable is represented as a Symbol and called vti 
-    * (variable type identifier). In order to find out what type of variable a 
-    * VarSpec corresponds to, you can compare the vti with VarImp::vti of a 
-    * concrete variable type (e.g. IntVarImp::vti).
-    *
-    * The domain of a variable is represented as an Arg. The concrete encoding 
-    * depends on the variable type.
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT VarSpec {
-  private:
-    class Domain;
-    /// A representation of the domain of this variable
-    Domain* _dom;
-  public:
-    /// Construct empty VarSpec
-    VarSpec(void);
-    /// Construct specification for a variable
-    VarSpec(Support::Symbol vti, Arg* domain);
-    /// Copy constructor
-    VarSpec(const VarSpec& s);
-    /// Assignment operator
-    const VarSpec& operator=(const VarSpec& s);
-    /// Destructor
-    GECODE_MSC_VIRTUAL ~VarSpec(void);
-    /// Set the name for this variable
-    void name(const Support::Symbol& n0);
-    /// Get the name of this variable
-    Support::Symbol name(void) const;
-    /// Return if variable has a name
-    bool hasName(void) const;
-    /// Get the domain of this variable
-    Arg* dom(void) const;
-    // Get the variable type identifier for this variable
-    Support::Symbol vti(void) const;
-  };
-  
-  /**
-    * \brief %Actor specification
-    *
-    * An ActorSpec contains all the information that characterizes an Actor. 
-    * The specifications for all the actors in a Space object can be accessed 
-    * using an ActorSpecIter.
-    *
-    * Each ActorSpec describes either a Branching or a Propagator 
-    * (reflected by ActorSpec::isBranching). As a user of the Reflection API,
-    * you can access the information describing an Actor as an array of 
-    * arguments, represented as objects of the Arg class.
-    *
-    * Every propagator and branching must be able to return a specification
-    * through the virtual function Actor::spec. If you use one of the 
-    * convenience classes like BinaryPropagator, have a look at the 
-    * implementation of AbsBnd::spec. If you subclass Propagator directly, or 
-    * you have additional arguments that have to be put into the ActorSpec, 
-    * please look at BinaryPropagator::spec.
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT ActorSpec {
-    friend class BranchingSpec;
-  private:
-    class Arguments;
-    /// The arguments of this actor
-    Arguments* _args;
-    /// Resize argument array
-    void resize(void);
-    friend class ActorSpecIter;
-    /// Set the queue of the actor to \a q
-    void queue(int q);
-    /** \brief Return identifier of the branching
-     *  Only valid if isBranching returns true
-     */
-    unsigned int branchingId(void) const;
-  public:
-    /// Construct empty ActorSpec
-    ActorSpec(void);
-    /// Construct actor specification with \a name
-    ActorSpec(const Support::Symbol& name);
-    /// Copy constructor
-    ActorSpec(const ActorSpec& s);
-    /// Assignment operator
-    const ActorSpec& operator=(const ActorSpec& s);
-    /// Destructor
-    GECODE_MSC_VIRTUAL ~ActorSpec(void);
-    
-    /// \name Actor information
-    //@{
-    /// Return actor type identifier
-    Support::Symbol ati(void) const;
-    /// Return number of arguments
-    int noOfArgs(void) const;
-    /// Check that the number of arguments is \a n, throw exception otherwise
-    void checkArity(int n) const;
-    /// Return argument \a i
-    Arg* operator[](int i) const;
-
-    /// Return whether the actor is a branching
-    bool isBranching(void) const;
-    /** \brief Return queue where the actor is currently scheduled
-     *  Only valid if isBranching returns false
-     */
-    int queue(void) const;
-    //@}
-    
-    /// \name Populating the specification
-    //@{
-    /// Add \a arg to the specification (as last argument)
-    void add(Arg* arg);
-    //@}
-  };
-
-}}
-
-/** \brief Add \a a to specification
- *  \relates Gecode::Reflection::ActorSpec
- */
-Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, Gecode::Reflection::Arg* arg);
-
-
-/** \brief Add \a i to specification
- *  \relates Gecode::Reflection::ActorSpec
- */
-Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, int i);
-
-/** \brief Add \a i to specification
- *  \relates Gecode::Reflection::ActorSpec
- */
-Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, unsigned int i);
-
-/** \brief Add \a d to specification, where \a d is cast into an integer
- *  \relates Gecode::Reflection::ActorSpec
- */
-Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, double i);
-
-/* Implementation of ActorSpec operators */
-
-forceinline Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, Gecode::Reflection::Arg* arg) {
-  s.add(arg);
-  return s;
-}
-forceinline Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, int i) {
-  return s << Gecode::Reflection::Arg::newInt(i);
-}
-forceinline Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, unsigned int i) {
-  return s << Gecode::Reflection::Arg::newInt(static_cast<int>(i));
-}
-forceinline Gecode::Reflection::ActorSpec
-operator<<(Gecode::Reflection::ActorSpec s, double i) {
-  return s << Gecode::Reflection::Arg::newInt(static_cast<int>(i));
-}
-
-namespace Gecode { namespace Reflection {
-
-  /**
-    * \brief %Branching specification
-    *
-    * A BranchingSpec contains information about the alternatives of a Space.
-    * It is similar to a BranchingDesc, but not opaque: you can query the
-    * information.
-    *
-    * The specification for an alternative is an ArrayArg that may contain 
-    * strings and references to variables. The concatenation of the strings 
-    * and variables is a human-readable description of what constraints are 
-    * posted for the given alternative.
-    *
-    * \ingroup TaskReflection
-    */  
-  class GECODE_KERNEL_EXPORT BranchingSpec {
-  private:
-    class Arguments;
-    /// The arguments of this branching
-    Arguments* _args;
-  public:
-    /// Default constructor
-    BranchingSpec(void);
-    /** \brief Construct spec for branching description \a d
-     *
-     * This constructor is used by a Branching to create a BranchingSpec.
-     * As a user of the reflection API, you have to query use the function
-     * Gecode::Space::branchingSpec instead.
-     *
-     */
-    BranchingSpec(const BranchingDesc* d);
-    /// Copy constructor
-    BranchingSpec(const BranchingSpec& s);
-    /// Assignment operator
-    const BranchingSpec& operator=(const BranchingSpec& s);
-    /// Destructor
-    GECODE_MSC_VIRTUAL ~BranchingSpec(void);
-    
-    ///\name Branching information
-    //@{
-    /// Check if specification was created by \a b
-    bool createdBy(const ActorSpec& b) const;
-    /// Return number of alternatives
-    unsigned int alternatives(void) const;
-    /// Return specification of alternative \a i
-    Arg* operator[](int i) const;
-    
-    /// Return specification of alternative \a i
-    Arg*& operator[](int i);
-    //@}
-  };
-  
-  class VarMap;
-
-  /**
-    * \brief Iterating actor specifications
-    *
-    * Use this iterator to access specifications of all actors (propagators 
-    * and branchings) of a space. The iterator also provides access to the
-    * corresponding variable map.
-    *
-    * \ingroup TaskReflection
-    */
-  class GECODE_KERNEL_EXPORT ActorSpecIter {
-  private:
-    /// The variable map used by this iterator
-    VarMap*      m;
-    /// The space for which to iterate the actors
-    const Space* s;
-    /// The queue to iterate
-    const ActorLink *active;
-    /// The current actor
-    const ActorLink *cur;
-    /// Whether the current actor is a branching
-    bool       isBranching;
-  public:
-    /// Constructor
-    ActorSpecIter(const Space*, VarMap&);
-    /// %Test whether iterator still has actor specifications or is done
-    bool operator()(void) const;
-    /// Move iterator to next actor
-    void operator++(void);
-    /// Return actor specification for current iterator position
-    ActorSpec actor(void) const;
-  };
-
-  /**
-    * \brief Registry of constraint posting and variable creation functions
-    * \ingroup TaskReflection
-    */
-  class Registry {
-  private:
-    class RegistryObject;
-    RegistryObject* ro;
-  public:
-    /// The type of constraint posting functions
-    typedef void (*poster) (Space*, VarMap&, const ActorSpec&);
-    /// The type of variable creation functions
-    typedef VarImpBase* (*varCreator) (Space*, VarSpec&);
-    /// The type of variable domain constraint functions
-    typedef void (*varConstrainer) (Space*, VarImpBase*, VarSpec&);
-    /// The type of variable update functions
-    typedef VarImpBase* (*varUpdater) (Space*, bool, VarImpBase*);
-    /// The type of variable printing functions
-    typedef std::ostream& (*varPrinter) (std::ostream&, VarImpBase*);
-    /// The type of variable reflection functions
-    typedef Arg* (*varSpec) (const Space* home, VarMap& m, VarImpBase*);
-
-    /// Constructor
-    GECODE_KERNEL_EXPORT Registry(void);
-    /// Destructor
-    GECODE_KERNEL_EXPORT GECODE_MSC_VIRTUAL ~Registry(void);
-
-    /// Create a new variable in \a home from \a spec and return it
-    GECODE_KERNEL_EXPORT VarImpBase*
-    createVar(Space* home, VarSpec& spec) const;
-
-    /// Constrain \a v to \a spec
-    GECODE_KERNEL_EXPORT void
-    constrainVar(Space* home, VarImpBase* v, VarSpec& spec) const;
-
-    /// Update variable \a v with type identifier \a vti during cloning
-    GECODE_KERNEL_EXPORT VarImpBase*
-    updateVariable(Space* home, bool share, VarImpBase* v,
-                   const Support::Symbol& vti) const;
-
-    /// Print variable \a v with type identifier \a vti to \a os
-    GECODE_KERNEL_EXPORT std::ostream&
-    printVariable(std::ostream& os, VarImpBase* v,
-                  const Support::Symbol& vti) const;
-
-    /// Reflection for variable \a v with type identifier \a vti
-    GECODE_KERNEL_EXPORT Arg*
-    spec(const Space* home, VarMap& vm,
-         VarImpBase* v, const Support::Symbol& vti) const;
-
-    /// Post constraint in \a home for \a spec using variables \a vars
-    GECODE_KERNEL_EXPORT void
-    post(Space* home, VarMap& vm, const ActorSpec& spec) const;
-
-    /// Register variable creation function for \a vti
-    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varCreator vc);
-    /// Register variable domain constraining function for \a vti
-    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varConstrainer vc);
-    /// Register variable update function for \a vti
-    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varUpdater vu);
-    /// Register variable print function for \a vti
-    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varPrinter vp);
-    /// Register variable reflection function for \a vti
-    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varSpec vp);
-    /// Register constraint posting function for actor type identifier \a ati
-    GECODE_KERNEL_EXPORT void add(const Support::Symbol& ati, poster p);
-    /// Print list of all registered posters to \a out
-    GECODE_KERNEL_EXPORT void print(std::ostream& out);
-  private:
-    /// Do not allow copying
-    Registry(const Registry&);
-    /// Do not allow assignment
-    Registry& operator=(const Registry&);
-  };
-  
-  /// The registry object \ingroup TaskReflection
-  GECODE_KERNEL_EXPORT Registry& registry(void);
-
-  /** \brief Class used for registering actors
-    *
-    * \ingroup TaskReflection
-    *
-    * The registered Actor class \a P has to provide two functions:
-    *  - static Support::Symbol ati(void)
-    *  - static void post(Space*, const VarMap&, const ActorSpec&)
-    */
-  template <class P>
-  class ActorRegistrar {
-  public:
-    /// Default constructor
-    ActorRegistrar(void);
-  };
-
-  template <class P>
-  ActorRegistrar<P>::ActorRegistrar(void) {
-    registry().add(P::ati(), &P::post);
-  }
-
-  /** \brief Class used for registering variable implementations
-    *
-    * \ingroup TaskReflection
-    *
-    * The registered variable implementation class \a V has to
-    * provide two functions:
-    *  - static void create(Space*, Reflection::VarSpec&)
-    *  - static void contrain(Space*, VarImpBase*, Reflection::VarSpec&)
-    */
-  template <class V>
-  class VarImpRegistrar {
-  private:
-    static VarImpBase* updateVar(Space* home, bool share, VarImpBase* v);
-    static std::ostream& printVar(std::ostream& os, VarImpBase* v);
-    static Reflection::Arg* spec(const Space* home, Reflection::VarMap& m,
-                                 VarImpBase* v);
-  public:
-    /// Default constructor
-    VarImpRegistrar(void);
-  };
-
-  template <class V>
-  VarImpBase*
-  VarImpRegistrar<V>::updateVar(Space* home, bool share, VarImpBase* v) {
-    typedef typename VarImpVarTraits<V>::Var Var;
-    typedef typename VarViewTraits<Var>::View View;
-    View view(static_cast<V*>(v));
-    Var var(view);
-    Var varCopy;
-    varCopy.update(home, share, var);
-    View viewCopy(varCopy);
-    return viewCopy.var();
-  }
-
-  template <class V>
-  std::ostream&
-  VarImpRegistrar<V>::printVar(std::ostream& os, VarImpBase* v) {
-    typedef typename VarImpVarTraits<V>::Var Var;
-    typedef typename VarViewTraits<Var>::View View;
-    View view(static_cast<V*>(v));
-    Var var(view);
-    return os << var;
-  }
-
-  template <class V>
-  Reflection::Arg*
-  VarImpRegistrar<V>::spec(const Space* home, Reflection::VarMap& m,
-                           VarImpBase* v) {
-    typedef typename VarImpVarTraits<V>::Var Var;
-    typedef typename VarViewTraits<Var>::View View;
-    View view(static_cast<V*>(v));
-    return view.spec(home, m);
-  }
-
-  template <class V>
-  VarImpRegistrar<V>::VarImpRegistrar(void) {
-    registry().add(V::vti, &V::create);
-    registry().add(V::vti, &V::constrain);
-    registry().add(V::vti, &VarImpRegistrar<V>::updateVar);
-    registry().add(V::vti, &VarImpRegistrar<V>::printVar);
-    registry().add(V::vti, &VarImpRegistrar<V>::spec);
-  }
-
-  /**
-   * \brief Generic variables
-   *
-   * \ingroup TaskReflection
-   *
-   * A generic variable can represent any Gecode variable. It can be
-   * used in VarArrays, and it supports generic update during cloning.
-   *
-   */
-  class Var {
-  private:
-    /// The actual variable
-    VarImpBase* _var;
-    /// The variable type identifier
-    Support::Symbol _vti;
-  public:
-    /// Default constructor
-    Var(void);
-    /// Construct from \a v
-    template <class V> explicit Var(const V& v);
-    /// Construct from \a var with variable type identifier \a vti
-    Var(VarImpBase* var, const Support::Symbol& vti);
-    /// Update during cloning
-    GECODE_KERNEL_EXPORT void update(Space* home, bool share, Var& v);
-    /// Output to \a os
-    GECODE_KERNEL_EXPORT std::ostream& print(std::ostream& os) const;
-    /// Reflection
-    GECODE_KERNEL_EXPORT Arg* spec(const Space* home, VarMap& vm) const;
-    /// Cast to concrete variable type
-    template <class VarImp>
-    VarImp* var(void) const;
-  };
-
-  /**
-   * \brief Unreflection from VarSpec and ActorSpec
-   * \ingroup TaskReflection
-   *
-   * An Unreflector allows you to install variables and propagators in a 
-   * Space using variable and actor specifications.
-   *
-   */
-  class GECODE_KERNEL_EXPORT Unreflector {
-  private:
-    /// The space in which to create variables and post constraints
-    Space* home;
-    /// The VarMap that indicates which variables to reuse
-    Reflection::VarMap& m;
-    
-  public:
-    /// Constructor
-    Unreflector(Space* home0, Reflection::VarMap& m0);
-
-    /// Destructor
-    GECODE_MSC_VIRTUAL ~Unreflector(void);
-    
-    /// Return the VarMap
-    Reflection::VarMap& varMap(void) const;
-    
-    /// Create a new variable from \a spec
-    void var(Reflection::VarSpec& spec);
-
-    /// Post the constraint defined by \a spec
-    void post(Reflection::ActorSpec& spec);
-  };
-
-  forceinline
-  Var::Var(void) {}
-    
-  template <class V>
-  Var::Var(const V& v) {
-    typedef typename VarViewTraits<V>::View View;
-    View view(v);
-    _var = view.var();
-    _vti = view.var()->vti;
-  }
-
-  template <>
-  inline
-  Var::Var(const Var& v) : _var(v._var), _vti(v._vti) {}
-  
-  inline
-  Var::Var(VarImpBase* var, const Support::Symbol& vti)
-    : _var(var), _vti(vti) {}
-
-  template <>
-  inline VarImpBase*
-  Var::var(void) const {
-    return static_cast<VarImpBase*>(_var);
-  }
-  
-  template <class VarImp>
-  VarImp*
-  Var::var(void) const {
-    if (! (VarImp::vti == _vti))
-      throw ReflectionException("VTI mismatch");
-    return static_cast<VarImp*>(_var);
-  }
-
-  /** \addtogroup TaskReflection
-   *  @{
-   */
-
-/// Register a propagator with zero or one template argument
-#define GECODE_REGISTER1(P) \
-  ::Gecode::Reflection::ActorRegistrar< P > GECODE_FRESH(r);
-/// Register a propagator with two template arguments
-#define GECODE_REGISTER2(P1,P2) \
-  ::Gecode::Reflection::ActorRegistrar< P1,P2 > GECODE_FRESH(r);
-/// Register a propagator with three template arguments
-#define GECODE_REGISTER3(P1,P2,P3) \
-  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3 > GECODE_FRESH(r);
-/// Register a propagator with four template arguments
-#define GECODE_REGISTER4(P1,P2,P3,P4) \
-  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3,P4 > GECODE_FRESH(r);
-/// Register a propagator with five template arguments
-#define GECODE_REGISTER5(P1,P2,P3,P4,P5) \
-  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3,P4,P5 > GECODE_FRESH(r);
-/// Register a propagator with six template arguments
-#define GECODE_REGISTER6(P1,P2,P3,P4,P5,P6) \
-  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3,P4,P5,P6 > GECODE_FRESH(r);
-
-  //@}
-
-  /**************************************
-   * Implementations
-   **************************************/
-
-  template <class A>
-  IntArrayArg*
-  Arg::newIntArray(const A& a) {
-    IntArrayArg* ret = Arg::newIntArray(a.size());
-    for (int i=a.size(); i--;)
-      (*ret)[i] = a[i];
-    return ret;
-  }
-  
-  /** \addtogroup TaskReflection
-   *  @{
-   */  
-
-  /** \brief String representation for View types, used for name mangling
-    */
-  template <class View>
-  class TypeOf {
-  public:
-    /// Return string representation
-    static Support::Symbol t(void) { return View::type(); }
-  };
-  
-  /** \brief String representation for bool, used for name mangling
-    */
-  template <>
-  class TypeOf<bool> {
-  public:
-    /// Return string representation
-    static Support::Symbol t(void) { return Support::Symbol("bool"); }
-  };
-
-  /** \brief String representation for ints, used for name mangling
-    */
-  template <>
-  class TypeOf<int> {
-  public:
-    /// Return string representation
-    static Support::Symbol t(void) { return Support::Symbol("int"); }
-  };
-
-  /** \brief String representation for doubles, used for name mangling
-    */
-  template <>
-  class TypeOf<double> {
-  public:
-    /// Return string representation
-    static Support::Symbol t(void) { return Support::Symbol("double"); }
-  };
-
-  //@}
-
-}
-  class IntSet;
-namespace Reflection {
-
-  /** \addtogroup TaskReflection
-   *  @{
-   */
-
-  /** \brief String representation for IntSets, used for name mangling
-    */
-  template <>
-  class TypeOf<const IntSet> {
-  public:
-    /// Return string representation
-    static Support::Symbol t(void) { return Support::Symbol("IntSet"); }    
-  };
-
-  /// Mangle ati with type information
-  template <class View0>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, bool b>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += (b ? "true" : "false");
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1, bool b>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ",";
-    mangled += (b ? "true" : "false");
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1, class View2>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ",";
-    mangled += TypeOf<View2>::t();
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1, class View2, bool b>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ",";
-    mangled += TypeOf<View2>::t();
-    mangled += ",";
-    mangled += (b ? "true" : "false");
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1, class View2, class View3>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ",";
-    mangled += TypeOf<View2>::t();
-    mangled += ",";
-    mangled += TypeOf<View3>::t();
-    mangled += ">";
-    return mangled;
-  }
-  /// Mangle ati with type information
-  template <class View0, class View1, class View2, class View3, bool b>
-  Support::Symbol
-  mangle(const Support::Symbol& ati) {
-    Support::Symbol mangled = ati.copy();
-    mangled += "<";
-    mangled += TypeOf<View0>::t();
-    mangled += ",";
-    mangled += TypeOf<View1>::t();
-    mangled += ",";
-    mangled += TypeOf<View2>::t();
-    mangled += ",";
-    mangled += TypeOf<View3>::t();
-    mangled += ",";
-    mangled += (b ? "true" : "false");
-    mangled += ">";
-    return mangled;
-  }
-  
-  //@}
-
-}}
-
-/// Print \a v to \a os
-GECODE_KERNEL_EXPORT std::ostream&
-operator<<(std::ostream& os, const Gecode::Reflection::Var& v);
-
-// STATISTICS: kernel-other