gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -1,921 +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-04 10:14:14 +0100 (Tue, 04 Mar 2008) $ by $Author: tack $
- *     $Revision: 6403 $
- *
- *  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 "gecode/kernel.hh"
-
-namespace Gecode { namespace Reflection {
-
-  // Registry
-
-  /// The actual registry, holding SymbolMap objects
-  class Registry::RegistryObject {
-  public:
-    /// The registry of constraint posting functions
-    Support::SymbolMap<poster> posters;
-    /// The registry of variable creation functions
-    Support::SymbolMap<varCreator> varCreators;
-    /// The registry of variable constraining functions
-    Support::SymbolMap<varConstrainer> varConstrainers;
-    /// The registry of variable update functions
-    Support::SymbolMap<varUpdater> varUpdaters;
-    /// The registry of variable print functions
-    Support::SymbolMap<varPrinter> varPrinters;
-    /// The registry of variable reflection functions
-    Support::SymbolMap<varSpec> varSpecs;
-  };
-  
-  Registry::Registry(void) : ro(new RegistryObject()) {}
-
-  Registry::~Registry(void) { delete ro; }
-
-  Registry& registry(void) {
-    static Registry r;
-    return r;
-  };
-  
-  VarImpBase*
-  Registry::createVar(Space* home, VarSpec& spec) const {
-    varCreator vc = NULL;
-    if (!ro->varCreators.get(spec.vti(),vc)) {
-      throw Reflection::ReflectionException("VTI not found");
-    }
-    return vc(home, spec);
-  }
-
-  void
-  Registry::constrainVar(Space* home, VarImpBase* v, VarSpec& spec) const {
-    varConstrainer vc = NULL;
-    if (!ro->varConstrainers.get(spec.vti(),vc)) {
-      throw Reflection::ReflectionException("VTI not found");
-    }
-    vc(home, v, spec);
-  }
-
-  VarImpBase*
-  Registry::updateVariable(Space* home, bool share, VarImpBase* v,
-                           const Support::Symbol& vti) const {
-    varUpdater vu = NULL;
-    if (!ro->varUpdaters.get(vti,vu)) {
-      throw Reflection::ReflectionException("VTI not found");
-    }
-    return vu(home, share, v);
-  }
-
-  std::ostream&
-  Registry::printVariable(std::ostream& os, VarImpBase* v,
-                          const Support::Symbol& vti) const {
-    varPrinter vp = NULL;
-    if (!ro->varPrinters.get(vti,vp)) {
-      throw Reflection::ReflectionException("VTI not found");
-    }
-    return vp(os, v);
-  }
-
-  Arg*
-  Registry::spec(const Space* home, VarMap& vm,
-                 VarImpBase* v, const Support::Symbol& vti) const {
-    varSpec vs = NULL;
-    if (!ro->varSpecs.get(vti,vs)) {
-      throw Reflection::ReflectionException("VTI not found");      
-    }
-    return vs(home, vm, v);
-  }
-
-  void
-  Registry::post(Space* home, VarMap& vm, const ActorSpec& spec) const {
-    poster p = NULL;
-    if (!ro->posters.get(spec.ati(),p)) {
-      throw Reflection::ReflectionException("Constraint not found");
-    }
-    p(home, vm, spec);
-  }
-
-  void
-  Registry::add(Support::Symbol vti, varCreator vc) {
-    ro->varCreators.put(vti, vc);
-  }
-
-  void
-  Registry::add(Support::Symbol vti, varConstrainer vc) {
-    ro->varConstrainers.put(vti, vc);
-  }
-
-  void
-  Registry::add(Support::Symbol vti, varUpdater vu) {
-    ro->varUpdaters.put(vti, vu);
-  }
-
-  void
-  Registry::add(Support::Symbol vti, varPrinter vp) {
-    ro->varPrinters.put(vti, vp);
-  }
-
-  void
-  Registry::add(Support::Symbol vti, varSpec vs) {
-    ro->varSpecs.put(vti, vs);
-  }
-
-  void
-  Registry::add(const Support::Symbol& id, poster p) {
-    ro->posters.put(id, p);
-  }
-
-  void
-  Registry::print(std::ostream&) {
-  }
-
-  /*
-   * Arguments
-   *
-   */
-
-  Arg::Arg(argtype t0) : t(t0) {}
-  
-  bool
-  Arg::isInt(void) const {
-    return t == INT_ARG;
-  }
-  int
-  Arg::toInt(void) const {
-    if (!isInt())
-      throw ReflectionException("not an IntArg");
-    return arg1.i;
-  }
-  Arg*
-  Arg::newInt(int i) {
-    Arg* ret = new Arg(INT_ARG);
-    ret->arg1.i = i;
-    return ret;
-  }
-  void
-  Arg::initInt(int i) {
-    t = INT_ARG;
-    arg1.i = i;
-  }
-
-  bool
-  Arg::isVar(void) const {
-    return (t == VAR_ARG);
-  }
-  int
-  Arg::toVar(void) const {
-    if (!isVar())
-      throw ReflectionException("not a VarArg");
-    return arg1.i;
-  }
-  Arg*
-  Arg::newVar(int i) {
-    Arg* ret = new Arg(VAR_ARG);
-    ret->arg1.i = i;
-    return ret;
-  }
-  void
-  Arg::initVar(int i) {
-    t = VAR_ARG;
-    arg1.i = i;
-  }
-
-  bool
-  Arg::isArray(void) const {
-    return (t == ARRAY_ARG);
-  }
-  ArrayArg*
-  Arg::toArray(void) {
-    if (!isArray())
-      throw ReflectionException("not an ArrayArg");
-    return static_cast<ArrayArg*>(this);
-  }
-  const ArrayArg*
-  Arg::toArray(void) const {
-    if (!isArray())
-      throw ReflectionException("not an ArrayArg");
-    return static_cast<const ArrayArg*>(this);
-  }
-  ArrayArg*
-  Arg::newArray(int n) {
-    Arg* ret = new Arg(ARRAY_ARG);
-    ret->arg1.i = n;
-    if (n > 0)
-      ret->arg2.aa = static_cast<Arg**>(Memory::malloc(sizeof(Arg*)*n));
-    else
-      ret->arg2.aa = NULL;
-    return static_cast<ArrayArg*>(ret);
-  }
-  void
-  Arg::initArray(int n) {
-    t = ARRAY_ARG;
-    arg1.i = n;
-    arg2.aa = static_cast<Arg**>(Memory::malloc(sizeof(Arg*)*n));
-  }
-
-  bool
-  Arg::isIntArray(void) const {
-    return (t == INT_ARRAY_ARG);
-  }
-  IntArrayArg*
-  Arg::toIntArray(void) {
-    if (!isIntArray())
-      throw ReflectionException("not an IntArrayArg");
-    return static_cast<IntArrayArg*>(this);
-  }
-  const IntArrayArg*
-  Arg::toIntArray(void) const {
-    if (!isIntArray())
-      throw ReflectionException("not an IntArrayArg");
-    return static_cast<const IntArrayArg*>(this);
-  }
-  IntArrayArg*
-  Arg::newIntArray(int n) {
-    Arg* ret = new Arg(INT_ARRAY_ARG);
-    ret->arg1.i = n;
-    if (n > 0)
-      ret->arg2.ia = static_cast<int*>(Memory::malloc(sizeof(int)*n));
-    else
-      ret->arg2.ia = NULL;
-    return static_cast<IntArrayArg*>(ret);
-  }
-  void
-  Arg::initIntArray(int n) {
-    t = INT_ARRAY_ARG;
-    arg1.i = n;
-    arg2.ia = static_cast<int*>(Memory::malloc(sizeof(int)*n));
-  }
-
-  bool
-  Arg::isString(void) const {
-    return (t == STRING_ARG);
-  }
-  const char*
-  Arg::toString(void) const {
-    if (!isString())
-      throw ReflectionException("not a StringArg");
-    return arg1.s;
-  }
-
-#if defined(_MSC_VER)
-#define strdup _strdup
-#endif
-
-  Arg*
-  Arg::newString(const char* s) {
-    Arg* ret = new Arg(STRING_ARG);
-    ret->arg1.s = strdup(s);
-    return ret;    
-  }
-  void
-  Arg::initString(const char* s) {
-    t = STRING_ARG;
-    arg1.s = strdup(s);
-  }
-
-#if defined(_MSC_VER)
-#undef strdup
-#endif
-
-  bool
-  Arg::isPair(void) const {
-    return (t == PAIR_ARG);
-  }
-  Arg*
-  Arg::first(void) {
-    if (!isPair())
-      throw ReflectionException("not a PairArg");
-    return arg1.first;
-  }
-  const Arg*
-  Arg::first(void) const {
-    if (!isPair())
-      throw ReflectionException("not a PairArg");
-    return arg1.first;
-  }
-  Arg*
-  Arg::second(void) {
-    if (!isPair())
-      throw ReflectionException("not a PairArg");
-    return arg2.second;
-  }
-  const Arg*
-  Arg::second(void) const {
-    if (!isPair())
-      throw ReflectionException("not a PairArg");
-    return arg2.second;
-  }
-  Arg*
-  Arg::newPair(Arg* a, Arg* b) {
-    Arg* ret = new Arg(PAIR_ARG);
-    ret->arg1.first = a;
-    ret->arg2.second = b;
-    return ret;
-  }
-  void
-  Arg::initPair(Arg* a, Arg* b) {
-    t = PAIR_ARG;
-    arg1.first = a;
-    arg2.second = b;
-  }
-
-  bool
-  Arg::isSharedObject(void) const {
-    return (t == SHARED_OBJECT_ARG);
-  }
-  Arg*
-  Arg::toSharedObject(void) {
-    if (!isSharedObject())
-      throw ReflectionException("not a SharedObjectArg");
-    return arg1.first;
-  }
-  const Arg*
-  Arg::toSharedObject(void) const {
-    if (!isSharedObject())
-      throw ReflectionException("not a SharedObjectArg");
-    return arg1.first;
-  }
-  Arg*
-  Arg::newSharedObject(Arg* a) {
-    Arg* ret = new Arg(SHARED_OBJECT_ARG);
-    ret->arg1.first = a;
-    return ret;
-  }
-  void
-  Arg::initSharedObject(Arg* a) {
-    t = SHARED_OBJECT_ARG;
-    arg1.first = a;
-  }
-  
-  bool
-  Arg::isSharedReference(void) const {
-    return (t == SHARED_REF_ARG);
-  }
-  int
-  Arg::toSharedReference(void) const {
-    if (!isSharedReference())
-      throw ReflectionException("not a SharedReferenceArg");
-    return arg1.i;
-  }
-  Arg*
-  Arg::newSharedReference(int ref) {
-    Arg* ret = new Arg(SHARED_REF_ARG);
-    ret->arg1.i = ref;
-    return ret;
-  }
-  void
-  Arg::initSharedReference(int ref) {
-    t = SHARED_REF_ARG;
-    arg1.i = ref;
-  }
-
-  Arg::~Arg(void) {
-    switch (t) {
-    case ARRAY_ARG:
-      for (int i=arg1.i; i--;)
-        delete arg2.aa[i];
-      if (arg2.aa != NULL)
-        Memory::free(arg2.aa);
-      break;
-    case INT_ARRAY_ARG:
-      if (arg2.ia != NULL)
-        Memory::free(arg2.ia);
-      break;
-    case PAIR_ARG:
-      delete arg1.first;
-      delete arg2.second;
-      break;
-    case STRING_ARG:
-      ::free(arg1.s);
-      break;
-    case SHARED_OBJECT_ARG:
-      delete arg1.first;
-      break;
-    default:
-      break;
-    }
-  }
-
-  const Arg*
-  ArrayArg::operator[](int i) const {
-    if (i >= arg1.i)
-      throw ReflectionException("Array index out of range");
-    return arg2.aa[i];
-  }
-  Arg*&
-  ArrayArg::operator[](int i) {
-    if (i >= arg1.i)
-      throw ReflectionException("Array index out of range");
-    return arg2.aa[i];
-  }
-  int
-  ArrayArg::size(void) const {
-    return arg1.i;
-  }
-
-  const int&
-  IntArrayArg::operator[](int i) const {
-    if (i >= arg1.i)
-      throw ReflectionException("Array index out of range");
-    return arg2.ia[i];
-  }
-  int&
-  IntArrayArg::operator[](int i) {
-    if (i >= arg1.i)
-      throw ReflectionException("Array index out of range");
-    return arg2.ia[i];
-  }
-  int
-  IntArrayArg::size(void) const {
-    return arg1.i;
-  }
-
-  IntArrayArgRanges::IntArrayArgRanges(Reflection::IntArrayArg* a0) 
-    : a(a0), n(0) {}
-
-  bool
-  IntArrayArgRanges::operator()(void) { return n < a->size(); }
-
-  void
-  IntArrayArgRanges::operator++(void) { n += 2; }
-
-  int
-  IntArrayArgRanges::min(void) const { return (*a)[n]; }
-
-  int
-  IntArrayArgRanges::max(void) const { return (*a)[n+1]; }
-
-  unsigned int
-  IntArrayArgRanges::width(void) const { 
-    return static_cast<unsigned int>(max() - min()) + 1; 
-  }
-
-  //
-  // VarSpec
-  //
-
-  /// Implementation of a VarSpec, holding all information about a variable
-  class VarSpec::Domain {
-  public:
-    /// The variable type identifier for this variable
-    Support::Symbol _vti;
-    /// The name of this variable
-    Support::Symbol _n;
-    /// A representation of the domain of this variable
-    Arg* _dom;
-    /// Reference count
-    int r;
-    /// Constructor
-    Domain(Support::Symbol vti, Arg* domain);
-    /// Destructor
-    ~Domain(void);
-  };
-
-  /*
-   * Variable specifications
-   *
-   */
-
-  inline
-  VarSpec::Domain::Domain(Support::Symbol vti, Arg* domain)
-  : _vti(vti), _dom(domain), r(1) {}
-
-  inline
-  VarSpec::Domain::~Domain(void) {
-    delete _dom;
-  }
-
-  VarSpec::VarSpec(void) : _dom(NULL) {}
-  
-  VarSpec::VarSpec(Support::Symbol vti, Arg* dom) 
-  : _dom(new Domain(vti,dom)) {}
-
-  VarSpec::VarSpec(const VarSpec& s) : _dom(s._dom) {
-    if (_dom)
-      _dom->r++;
-  }
-  
-  const VarSpec&
-  VarSpec::operator=(const VarSpec& s) {
-    if (this != &s) {
-      if (_dom && --_dom->r == 0)
-        delete _dom;
-      _dom = s._dom;
-      if (_dom)
-        _dom->r++;
-    }
-    return *this;
-  }
-  
-  VarSpec::~VarSpec(void) {
-    if (_dom && --_dom->r == 0)
-      delete _dom;
-  }
-
-  void
-  VarSpec::name(const Support::Symbol& n) {
-    if (_dom == NULL)
-      throw ReflectionException("Empty VarSpec");
-    _dom->_n = n;
-  }
-  
-  Support::Symbol
-  VarSpec::name(void) const {
-    if (_dom == NULL)
-      throw ReflectionException("Empty VarSpec");
-    return _dom->_n;
-  }
-
-  bool
-  VarSpec::hasName(void) const {
-    if (_dom == NULL)
-      throw ReflectionException("Empty VarSpec");
-    return !_dom->_n.empty();
-  }
-
-  Support::Symbol
-  VarSpec::vti(void) const {
-    if (_dom == NULL)
-      throw ReflectionException("Empty VarSpec");
-    return _dom->_vti;
-  }
-
-  Arg*
-  VarSpec::dom(void) const {
-    if (_dom == NULL)
-      throw ReflectionException("Empty VarSpec");
-    return _dom->_dom;
-  }
-
-  //
-  // ActorSpec
-  //
-
-  /// Implementation of an ActorSpec, holding all information about an actor
-  class ActorSpec::Arguments {
-  public:
-    /// The actor type identifier of this actor
-    Support::Symbol _ati;
-    /// The size of the argument array
-    int   size;
-    /// The number of arguments of this actor
-    int   n;
-    /// The arguments of this actor
-    Arg** a;
-    /// The queue where the actor is schedules
-    int queue;
-    /// Reference counter
-    int r;
-    /// Construct empty arguments
-    Arguments(const Support::Symbol&);
-    /// Destructor
-    ~Arguments(void);
-  };
-
-  /*
-   * Actor specifications
-   *
-   */
-
-  inline
-  ActorSpec::Arguments::Arguments(const Support::Symbol& ati)
-   :  _ati(ati), size(4), n(0), r(1) {
-     a = static_cast<Arg**>(Memory::malloc(sizeof(Arg*)*size));
-  }
-
-  inline
-  ActorSpec::Arguments::~Arguments(void) {
-    for (int i=n; i--;)
-      delete a[i];
-    Memory::free(a);
-  }
-
-  void
-  ActorSpec::resize(void) {
-    assert(_args != NULL);
-    _args->size = _args->size * 3 / 2;
-    Arg** newargs =
-      static_cast<Arg**>(Memory::malloc(sizeof(Arg*)*_args->size));
-    for (int i=_args->n; i--;)
-      newargs[i] = _args->a[i];
-    Memory::free(_args->a);
-    _args->a = newargs;
-  }
-
-  ActorSpec::ActorSpec(void) : _args(NULL) {}
-
-  ActorSpec::ActorSpec(const Support::Symbol& ati) {
-    _args = new Arguments(ati);
-  }
-
-  ActorSpec::ActorSpec(const ActorSpec& s) : _args(s._args) {
-    if (_args != NULL)
-      _args->r++;
-  }
-  
-  const ActorSpec&
-  ActorSpec::operator=(const ActorSpec& s) {
-    if (this != &s) {
-      if (_args && --_args->r == 0)
-        delete _args;
-      _args = s._args;
-      if (_args)
-        _args->r++;
-    }
-    return *this;
-  }
-
-  Arg*
-  ActorSpec::operator[](int i) const {
-    if (_args == NULL || i < 0 || i >= _args->n)
-      throw ReflectionException("Array index out of range");
-    return _args->a[i];
-  }
-
-  int
-  ActorSpec::noOfArgs(void) const {
-    return _args == NULL ? 0 : _args->n;
-  }
-
-  void
-  ActorSpec::checkArity(int n) const {
-    if (_args == NULL || _args->n != n) {
-      throw ReflectionException("Illegal arity in ActorSpec");
-    }
-  }
-
-  Support::Symbol
-  ActorSpec::ati(void) const {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    return _args->_ati;
-  }
-
-  bool
-  ActorSpec::isBranching(void) const {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    return _args->queue < 0;
-  }
-
-  int
-  ActorSpec::queue(void) const {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    return _args->queue-1;
-  }
-
-  unsigned int
-  ActorSpec::branchingId(void) const {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    assert(isBranching());
-    return static_cast<unsigned int>(-_args->queue-1);
-  }
-
-  ActorSpec::~ActorSpec(void) {
-    if (_args && --_args->r == 0)
-      delete _args;
-  }
-
-  void
-  ActorSpec::add(Arg* arg) {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    if (_args->n == _args->size)
-      resize();
-    _args->a[_args->n] = arg;
-    _args->n++;
-  }
-
-  void
-  ActorSpec::queue(int q) {
-    if (_args == NULL)
-      throw ReflectionException("Empty ActorSpec");
-    _args->queue = q;
-  }
-
-  /*
-   * Branch specification
-   *
-   */
-   
-  /// Implementation of a BranchingSpec
-  class BranchingSpec::Arguments {
-  public:
-    /// The number of alternatives of this branch
-    unsigned int   n;
-    /// The arguments of this branch
-    Arg** a;
-    /// The id of the corresponding branching
-    unsigned int id;
-    /// Reference counter
-    int r;
-    /// Construct arguments for \a id with \a a alternatives
-    Arguments(unsigned int id, unsigned int a);
-    /// Destructor
-    ~Arguments(void);
-  };
-
-  inline
-  BranchingSpec::Arguments::Arguments(unsigned int id0, unsigned int n0)
-   : n(n0), id(id0), r(1) {
-     a = static_cast<Arg**>(Memory::malloc(sizeof(Arg*)*n));
-     for (unsigned int i=n; i--;)
-       a[i] = NULL;
-  }
-
-  inline
-  BranchingSpec::Arguments::~Arguments(void) {
-    for (unsigned int i=n; i--;)
-      delete a[i];
-    Memory::free(a);
-  }
-  
-  BranchingSpec::BranchingSpec(void) : _args(NULL) {}
-  
-  BranchingSpec::BranchingSpec(const BranchingDesc* d) {
-    _args = new Arguments(d->id(), d->alternatives());
-  }
-
-  BranchingSpec::BranchingSpec(const BranchingSpec& s) : _args(s._args) {
-    if (_args)
-      _args->r++;
-  }
-  
-  const BranchingSpec&
-  BranchingSpec::operator=(const BranchingSpec& s) {
-    if (this != &s) {
-      if (_args && --_args->r == 0)
-        delete _args;
-      _args = s._args;
-      if (_args)
-        _args->r++;
-    }
-    return *this;
-  }
-
-  Arg*
-  BranchingSpec::operator[](int i) const {
-    if (_args == NULL || i < 0 || static_cast<unsigned int>(i) >= _args->n)
-      throw ReflectionException("Array index out of range");
-    return _args->a[i];
-  }
-
-  Arg*&
-  BranchingSpec::operator[](int i) {
-    if (_args == NULL || i < 0 || static_cast<unsigned int>(i) >= _args->n)
-      throw ReflectionException("Array index out of range");
-    return _args->a[i];
-  }
-
-  BranchingSpec::~BranchingSpec(void) {
-    if (_args && --_args->r == 0)
-      delete _args;
-  }
-  
-  bool
-  BranchingSpec::createdBy(const ActorSpec& b) const {
-    if (!b.isBranching())
-      throw ReflectionException("ActorSpec does not belong to a Branching");
-    return _args != NULL && _args->id == b.branchingId();
-  }
-
-  unsigned int
-  BranchingSpec::alternatives(void) const {
-    return _args == NULL ? 0 : _args->n;
-  }
-  
-
-  /*
-   * Specification iterator
-   *
-   */
-   
-  bool
-  ActorSpecIter::operator()(void) const {
-    return cur != &s->a_actors;
-  }
-
-  void
-  ActorSpecIter::operator++(void) {
-    cur = cur->next();
-    while (active > &s->pc.p.queue[0] && (cur == active)) {
-      active--;
-      cur = active;
-      cur = cur->next();
-    }
-    if (active == &s->pc.p.queue[0] && cur == active) {
-      active--;
-      cur = s->a_actors.next();
-    }
-    if (cur == s->b_commit)
-      isBranching = true;
-  }
-
-  ActorSpecIter::ActorSpecIter(const Space* s0, VarMap& m0)
-  : m(&m0), s(s0),
-    active(s0->pc.p.active == NULL ?
-           &s->pc.p.queue[PC_MAX] : s0->pc.p.active),
-    cur(active),
-    isBranching(false) {
-    if (s->stable() && !s->failed())
-      cur = &s->a_actors;
-    ++(*this);
-  }
-
-  ActorSpec
-  ActorSpecIter::actor(void) const {
-    ActorSpec spec = static_cast<const Actor*>(cur)->spec(s,*m);
-    if (isBranching)
-      spec.queue(-1-static_cast<const Branching*>(cur)->id);
-    else
-      spec.queue( (active - &s->pc.p.queue[0]) + 1);
-    return spec;
-  }
-
-  Unreflector::Unreflector(Space* home0, Reflection::VarMap& m0)
-    : home(home0), m(m0) {}
-
-  Unreflector::~Unreflector(void) {}
-    
-  Reflection::VarMap&
-  Unreflector::varMap(void) const {
-    return m;
-  }
-
-  void
-  Unreflector::var(Reflection::VarSpec& spec) {
-    VarImpBase* vb = NULL;
-    if (!spec.name().empty() &&
-        (vb = m.varImpBase(spec.name())) != NULL) {
-      // TODO: assert that spec and original var are compatible,
-      // constrain domain of var to spec
-      Reflection::registry().constrainVar(home, vb, spec);
-    } else {
-      vb = Reflection::registry().createVar(home, spec);
-    }
-    (void) m.put(vb, new Reflection::VarSpec(spec));
-  }
-
-  void
-  Unreflector::post(Reflection::ActorSpec& spec) {
-    Reflection::registry().post(home, m, spec);
-  }
-
-  /* Generic variable */
-  
-  void
-  Var::update(Space* home, bool share, Var& v) {
-    new (&_vti) Support::Symbol(v._vti);
-    _var = registry().updateVariable(home, share, v._var, v._vti);
-  }
-
-  std::ostream&
-  Var::print(std::ostream& os) const {
-    return registry().printVariable(os, _var, _vti);
-  }
-  
-  Arg*
-  Var::spec(const Space* home, VarMap& vm) const {
-    return registry().spec(home, vm, _var, _vti);
-  }
-
-}}
-
-std::ostream&
-operator<<(std::ostream& os, const Gecode::Reflection::Var& v) {
-  return v.print(os);
-}
-
-
-// STATISTICS: kernel-other