gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/kernel/var-imp.icc

@@ -0,0 +1,433 @@
+/*
+ *  CAUTION:
+ *    This file has been automatically generated. Do not edit,
+ *    edit the specification file "variable.vsl" and the following
+ *    files instead:
+ *     - gecode/int/var-imp/int.vis
+ *     - gecode/int/var-imp/bool.vis
+ *     - gecode/set/var-imp/set.vis
+ *     - gecode/cpltset/var-imp/cpltset.vis
+ *
+ *  This file contains generated code fragments which are
+ *  copyrighted as follows:
+ *
+ *  Main author:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  The generated code fragments are 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.
+ *
+ */
+
+#ifdef GECODE_HAS_INT_VARS
+namespace Gecode { namespace Int { 
+  /// Base-class for Int-variable implementations
+  class IntVarImpBase : public Gecode::VarImp<Gecode::Int::IntVarImpConf> {
+  protected:
+    /// Constructor for cloning \a x
+    IntVarImpBase(Gecode::Space* home, bool share, IntVarImpBase& x);
+  public:
+    /// Constructor for creating static instance of variable
+    IntVarImpBase(void);
+    /// Constructor for creating variable
+    IntVarImpBase(Gecode::Space* home);
+    /// \name Dependencies
+    //@{
+    /** \brief Subscribe propagator \a p with propagation condition \a pc
+     *
+     * In case \a schedule is false, the propagator is just subscribed but
+     * not scheduled for execution (this must be used when creating
+     * subscriptions during propagation).
+     *
+     * In case the variable is assigned (that is, \a assigned is
+     * true), the subscribing propagator is scheduled for execution.
+     * Otherwise, the propagator subscribes and is scheduled for execution
+     * with modification event \a me provided that \a pc is different
+     * from \a PC_INT_VAL.
+     */
+    void subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule);
+    /// Subscribe advisor \a a if \a assigned is false.
+    void subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned);
+    /// Notify that variable implementation has been modified with modification event \a me and delta information \a d
+    Gecode::ModEvent notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d);
+    //@}
+  };
+}}
+#endif
+#ifdef GECODE_HAS_INT_VARS
+namespace Gecode { namespace Int { 
+  /// Base-class for Bool-variable implementations
+  class BoolVarImpBase : public Gecode::VarImp<Gecode::Int::BoolVarImpConf> {
+  protected:
+    /// Constructor for cloning \a x
+    BoolVarImpBase(Gecode::Space* home, bool share, BoolVarImpBase& x);
+  public:
+    /// Constructor for creating static instance of variable
+    BoolVarImpBase(void);
+    /// Constructor for creating variable
+    BoolVarImpBase(Gecode::Space* home);
+    /// \name Dependencies
+    //@{
+    /** \brief Subscribe propagator \a p with propagation condition \a pc
+     *
+     * In case \a schedule is false, the propagator is just subscribed but
+     * not scheduled for execution (this must be used when creating
+     * subscriptions during propagation).
+     *
+     * In case the variable is assigned (that is, \a assigned is
+     * true), the subscribing propagator is scheduled for execution.
+     * Otherwise, the propagator subscribes and is scheduled for execution
+     * with modification event \a me provided that \a pc is different
+     * from \a PC_BOOL_VAL.
+     */
+    void subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule);
+    /// Subscribe advisor \a a if \a assigned is false.
+    void subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned);
+    /// Notify that variable implementation has been modified with modification event \a me and delta information \a d
+    Gecode::ModEvent notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d);
+    //@}
+  };
+}}
+#endif
+#ifdef GECODE_HAS_SET_VARS
+namespace Gecode { namespace Set { 
+  /// Base-class for Set-variable implementations
+  class SetVarImpBase : public Gecode::VarImp<Gecode::Set::SetVarImpConf> {
+  protected:
+    /// Constructor for cloning \a x
+    SetVarImpBase(Gecode::Space* home, bool share, SetVarImpBase& x);
+  public:
+    /// Constructor for creating static instance of variable
+    SetVarImpBase(void);
+    /// Constructor for creating variable
+    SetVarImpBase(Gecode::Space* home);
+    /// \name Dependencies
+    //@{
+    /** \brief Subscribe propagator \a p with propagation condition \a pc
+     *
+     * In case \a schedule is false, the propagator is just subscribed but
+     * not scheduled for execution (this must be used when creating
+     * subscriptions during propagation).
+     *
+     * In case the variable is assigned (that is, \a assigned is
+     * true), the subscribing propagator is scheduled for execution.
+     * Otherwise, the propagator subscribes and is scheduled for execution
+     * with modification event \a me provided that \a pc is different
+     * from \a PC_SET_VAL.
+     */
+    void subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule);
+    /// Subscribe advisor \a a if \a assigned is false.
+    void subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned);
+    /// Notify that variable implementation has been modified with modification event \a me and delta information \a d
+    Gecode::ModEvent notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d);
+    //@}
+  };
+}}
+#endif
+#ifdef GECODE_HAS_CPLTSET_VARS
+namespace Gecode { namespace CpltSet { 
+  /// Base-class for CpltSet-variable implementations
+  class CpltSetVarImpBase : public Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf> {
+  private:
+    /// Link to next variable, used for disposal
+    CpltSetVarImpBase* _next_d;
+  protected:
+    /// Constructor for cloning \a x
+    CpltSetVarImpBase(Gecode::Space* home, bool share, CpltSetVarImpBase& x);
+  public:
+    /// Constructor for creating static instance of variable
+    CpltSetVarImpBase(void);
+    /// Constructor for creating variable
+    CpltSetVarImpBase(Gecode::Space* home);
+    /// \name Dependencies
+    //@{
+    /** \brief Subscribe propagator \a p with propagation condition \a pc
+     *
+     * In case \a schedule is false, the propagator is just subscribed but
+     * not scheduled for execution (this must be used when creating
+     * subscriptions during propagation).
+     *
+     * In case the variable is assigned (that is, \a assigned is
+     * true), the subscribing propagator is scheduled for execution.
+     * Otherwise, the propagator subscribes and is scheduled for execution
+     * with modification event \a me provided that \a pc is different
+     * from \a PC_CPLTSET_VAL.
+     */
+    void subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule);
+    /// Subscribe advisor \a a if \a assigned is false.
+    void subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned);
+    /// Notify that variable implementation has been modified with modification event \a me and delta information \a d
+    Gecode::ModEvent notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d);
+    //@}
+    /// Return link to next variable to be disposed
+    CpltSetVarImpBase* next_d(void) const;
+  };
+}}
+#endif
+#ifdef GECODE_HAS_INT_VARS
+namespace Gecode { namespace Int { 
+
+  forceinline
+  IntVarImpBase::IntVarImpBase(void) {}
+
+  forceinline
+  IntVarImpBase::IntVarImpBase(Gecode::Space* home)
+    : Gecode::VarImp<Gecode::Int::IntVarImpConf>(home) {}
+
+  forceinline
+  IntVarImpBase::IntVarImpBase(Gecode::Space* home, bool share, IntVarImpBase& x)
+    : Gecode::VarImp<Gecode::Int::IntVarImpConf>(home,share,x) {}
+
+  forceinline void
+  IntVarImpBase::subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule) {
+    Gecode::VarImp<Gecode::Int::IntVarImpConf>::subscribe(home,p,pc,assigned,ME_INT_BND,schedule);
+  }
+  forceinline void
+  IntVarImpBase::subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned) {
+    Gecode::VarImp<Gecode::Int::IntVarImpConf>::subscribe(home,a,assigned);
+  }
+
+  forceinline Gecode::ModEvent
+  IntVarImpBase::notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d) {
+    switch (me) {
+    case ME_INT_VAL:
+      // Conditions: VAL, BND, DOM
+      schedule(home,PC_INT_VAL,PC_INT_DOM,ME_INT_VAL);
+      if (!Gecode::VarImp<Gecode::Int::IntVarImpConf>::advise(home,ME_INT_VAL,d))
+        return ME_INT_FAILED;
+      cancel(home);
+      break;
+    case ME_INT_BND:
+      // Conditions: BND, DOM
+      schedule(home,PC_INT_BND,PC_INT_DOM,ME_INT_BND);
+      if (!Gecode::VarImp<Gecode::Int::IntVarImpConf>::advise(home,ME_INT_BND,d))
+        return ME_INT_FAILED;
+      break;
+    case ME_INT_DOM:
+      // Conditions: DOM
+      schedule(home,PC_INT_DOM,PC_INT_DOM,ME_INT_DOM);
+      if (!Gecode::VarImp<Gecode::Int::IntVarImpConf>::advise(home,ME_INT_DOM,d))
+        return ME_INT_FAILED;
+      break;
+    default: GECODE_NEVER;
+    }
+    return me;
+  }
+
+}}
+#endif
+#ifdef GECODE_HAS_INT_VARS
+namespace Gecode { namespace Int { 
+
+  forceinline
+  BoolVarImpBase::BoolVarImpBase(void) {}
+
+  forceinline
+  BoolVarImpBase::BoolVarImpBase(Gecode::Space* home)
+    : Gecode::VarImp<Gecode::Int::BoolVarImpConf>(home) {}
+
+  forceinline
+  BoolVarImpBase::BoolVarImpBase(Gecode::Space* home, bool share, BoolVarImpBase& x)
+    : Gecode::VarImp<Gecode::Int::BoolVarImpConf>(home,share,x) {}
+
+  forceinline void
+  BoolVarImpBase::subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule) {
+    Gecode::VarImp<Gecode::Int::BoolVarImpConf>::subscribe(home,p,pc,assigned,ME_BOOL_VAL,schedule);
+  }
+  forceinline void
+  BoolVarImpBase::subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned) {
+    Gecode::VarImp<Gecode::Int::BoolVarImpConf>::subscribe(home,a,assigned);
+  }
+
+  forceinline Gecode::ModEvent
+  BoolVarImpBase::notify(Gecode::Space* home, Gecode::ModEvent, Gecode::Delta* d) {
+    schedule(home,PC_BOOL_VAL,PC_BOOL_VAL,ME_BOOL_VAL);
+    if (!Gecode::VarImp<Gecode::Int::BoolVarImpConf>::advise(home,ME_BOOL_VAL,d))
+      return ME_BOOL_FAILED;
+    cancel(home);
+    return ME_BOOL_VAL;
+  }
+
+}}
+#endif
+#ifdef GECODE_HAS_SET_VARS
+namespace Gecode { namespace Set { 
+
+  forceinline
+  SetVarImpBase::SetVarImpBase(void) {}
+
+  forceinline
+  SetVarImpBase::SetVarImpBase(Gecode::Space* home)
+    : Gecode::VarImp<Gecode::Set::SetVarImpConf>(home) {}
+
+  forceinline
+  SetVarImpBase::SetVarImpBase(Gecode::Space* home, bool share, SetVarImpBase& x)
+    : Gecode::VarImp<Gecode::Set::SetVarImpConf>(home,share,x) {}
+
+  forceinline void
+  SetVarImpBase::subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule) {
+    Gecode::VarImp<Gecode::Set::SetVarImpConf>::subscribe(home,p,pc,assigned,ME_SET_CBB,schedule);
+  }
+  forceinline void
+  SetVarImpBase::subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned) {
+    Gecode::VarImp<Gecode::Set::SetVarImpConf>::subscribe(home,a,assigned);
+  }
+
+  forceinline Gecode::ModEvent
+  SetVarImpBase::notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d) {
+    switch (me) {
+    case ME_SET_VAL:
+      // Conditions: VAL, CARD, CLUB, CGLB, ANY
+      schedule(home,PC_SET_VAL,PC_SET_ANY,ME_SET_VAL);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_VAL,d))
+        return ME_SET_FAILED;
+      cancel(home);
+      break;
+    case ME_SET_CARD:
+      // Conditions: CARD, CLUB, CGLB, ANY
+      schedule(home,PC_SET_CARD,PC_SET_ANY,ME_SET_CARD);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_CARD,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_LUB:
+      // Conditions: CLUB, ANY
+      schedule(home,PC_SET_CLUB,PC_SET_CLUB,ME_SET_LUB);
+      schedule(home,PC_SET_ANY,PC_SET_ANY,ME_SET_LUB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_LUB,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_GLB:
+      // Conditions: CGLB, ANY
+      schedule(home,PC_SET_CGLB,PC_SET_ANY,ME_SET_GLB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_GLB,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_BB:
+      // Conditions: CLUB, CGLB, ANY
+      schedule(home,PC_SET_CLUB,PC_SET_ANY,ME_SET_BB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_BB,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_CLUB:
+      // Conditions: CARD, CLUB, CGLB, ANY
+      schedule(home,PC_SET_CARD,PC_SET_ANY,ME_SET_CLUB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_CLUB,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_CGLB:
+      // Conditions: CARD, CLUB, CGLB, ANY
+      schedule(home,PC_SET_CARD,PC_SET_ANY,ME_SET_CGLB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_CGLB,d))
+        return ME_SET_FAILED;
+      break;
+    case ME_SET_CBB:
+      // Conditions: CARD, CLUB, CGLB, ANY
+      schedule(home,PC_SET_CARD,PC_SET_ANY,ME_SET_CBB);
+      if (!Gecode::VarImp<Gecode::Set::SetVarImpConf>::advise(home,ME_SET_CBB,d))
+        return ME_SET_FAILED;
+      break;
+    default: GECODE_NEVER;
+    }
+    return me;
+  }
+
+}}
+#endif
+#ifdef GECODE_HAS_CPLTSET_VARS
+namespace Gecode { namespace CpltSet { 
+
+  forceinline
+  CpltSetVarImpBase::CpltSetVarImpBase(void) {}
+
+  forceinline
+  CpltSetVarImpBase::CpltSetVarImpBase(Gecode::Space* home)
+    : Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>(home) {
+     _next_d = static_cast<CpltSetVarImpBase*>(vars_d(home)); vars_d(home,this);
+  }
+
+  forceinline
+  CpltSetVarImpBase::CpltSetVarImpBase(Gecode::Space* home, bool share, CpltSetVarImpBase& x)
+    : Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>(home,share,x) {
+     _next_d = static_cast<CpltSetVarImpBase*>(vars_d(home)); vars_d(home,this);
+  }
+
+  forceinline CpltSetVarImpBase*
+  CpltSetVarImpBase::next_d(void) const {
+    return _next_d;
+  }
+
+
+  forceinline void
+  CpltSetVarImpBase::subscribe(Gecode::Space* home, Gecode::Propagator* p, Gecode::PropCond pc, bool assigned, bool schedule) {
+    Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>::subscribe(home,p,pc,assigned,ME_CPLTSET_DOM,schedule);
+  }
+  forceinline void
+  CpltSetVarImpBase::subscribe(Gecode::Space* home, Gecode::Advisor* a, bool assigned) {
+    Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>::subscribe(home,a,assigned);
+  }
+
+  forceinline Gecode::ModEvent
+  CpltSetVarImpBase::notify(Gecode::Space* home, Gecode::ModEvent me, Gecode::Delta* d) {
+    switch (me) {
+    case ME_CPLTSET_VAL:
+      // Conditions: VAL, DOM
+      schedule(home,PC_CPLTSET_VAL,PC_CPLTSET_DOM,ME_CPLTSET_VAL);
+      if (!Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>::advise(home,ME_CPLTSET_VAL,d))
+        return ME_CPLTSET_FAILED;
+      cancel(home);
+      break;
+    case ME_CPLTSET_DOM:
+      // Conditions: DOM
+      schedule(home,PC_CPLTSET_DOM,PC_CPLTSET_DOM,ME_CPLTSET_DOM);
+      if (!Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>::advise(home,ME_CPLTSET_DOM,d))
+        return ME_CPLTSET_FAILED;
+      break;
+    default: GECODE_NEVER;
+    }
+    return me;
+  }
+
+}}
+#endif
+namespace Gecode {
+
+  forceinline void
+  Space::update(ActorLink** sub) {
+#ifdef GECODE_HAS_INT_VARS
+    Gecode::VarImp<Gecode::Int::IntVarImpConf>::update(this,sub);
+#endif
+#ifdef GECODE_HAS_INT_VARS
+    Gecode::VarImp<Gecode::Int::BoolVarImpConf>::update(this,sub);
+#endif
+#ifdef GECODE_HAS_SET_VARS
+    Gecode::VarImp<Gecode::Set::SetVarImpConf>::update(this,sub);
+#endif
+#ifdef GECODE_HAS_CPLTSET_VARS
+    Gecode::VarImp<Gecode::CpltSet::CpltSetVarImpConf>::update(this,sub);
+#endif
+  }
+}
+// STATISTICS: kernel-var

data/ext/gecode-2.2.0/gecode/kernel/var-map.cc

@@ -0,0 +1,269 @@
+/* -*- 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-07-11 09:38:30 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7296 $
+ *
+ *  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 {
+
+  /*
+   * Variable maps
+   *
+   */
+
+  /// Implementation of a VarMap
+  class VarMap::VarMapObj {
+  public:
+    VarMapObj(void);
+    /// Map variable names to variable implementations
+    Support::SymbolMap<VarImpBase*> nameToVar;
+    /// Map variable implementations to variable names
+    Support::PtrMap<VarImpBase,Support::Symbol> varToName;
+    /// Map variable implementations to indices
+    Support::PtrMap<VarImpBase,int> m;
+    /// Map shared objects to indices
+    Support::PtrMap<void,int>    sharedObjectMap;
+
+    /// Map indices to variable implementations
+    Support::DynamicArray<VarImpBase*>  vars;
+    /// Map indices to variable specifications
+    Support::DynamicArray<VarSpec*>  specs;
+    /// Map indices to shared objects
+    Support::DynamicArray<void*>     sharedObjects;
+
+    /// Number of variable indices in use
+    int n;
+    /// Number of shared object indices in use
+    int so;
+
+    /// Reference count
+    int r;
+  };
+
+  VarMap::VarMapObj::VarMapObj(void) : n(0), so(0), r(1) {}
+
+  VarMap::VarMap(void) : vo(new VarMapObj()) {}
+
+  VarMap::VarMap(const VarMap& v) : vo(v.vo) { vo->r++; }
+
+  VarMap&
+  VarMap::operator=(const VarMap& v) {
+    if (this != &v) {
+      if (--vo->r == 0) {
+        for (int i=vo->n; i--;)
+          delete vo->specs[i];
+        delete vo;        
+      }
+      vo = v.vo;
+      vo->r++;
+    }
+    return *this;
+  }
+
+  VarMap::~VarMap(void) {
+    if (--vo->r == 0) {
+      for (int i=vo->n; i--;)
+        delete vo->specs[i];
+      delete vo;
+    }
+  }
+
+  int
+  VarMap::size(void) const {
+    return vo->n;
+  }
+  
+  int
+  VarMap::index(const VarImpBase* cx) const {
+    int i;
+    VarImpBase* x = const_cast<VarImpBase*>(cx);
+    return vo->m.get(x,i) ? i : -1;
+  }
+
+  int
+  VarMap::index(const Support::Symbol& n) const {
+    VarImpBase* v;      
+    return vo->nameToVar.get(n, v) ? index(v) : -1;
+  }
+
+  bool
+  VarMap::nameIsKnown(const Support::Symbol& n) const {
+    VarImpBase* v;
+    return vo->nameToVar.get(n,v);
+  }
+
+  bool
+  VarMap::hasName(const VarImpBase* cx) const {
+    Support::Symbol s;
+    VarImpBase* x = const_cast<VarImpBase*>(cx);
+    return vo->varToName.get(x,s);
+  }
+
+  bool
+  VarMap::hasName(int i) const {
+    Support::Symbol s;
+    return vo->varToName.get(vo->vars[i], s);
+  }
+
+  Support::Symbol
+  VarMap::name(const VarImpBase* cx) const {
+    Support::Symbol s;
+    VarImpBase* x = const_cast<VarImpBase*>(cx);
+    vo->varToName.get(x,s);
+    return s;
+  }
+
+  Support::Symbol
+  VarMap::name(int i) const {
+    Support::Symbol s;
+    vo->varToName.get(vo->vars[i],s);
+    return s;
+  }
+
+  VarImpBase*
+  VarMap::varImpBase(const Support::Symbol& n) const {
+    VarImpBase* v;
+    return vo->nameToVar.get(n,v) ? v : NULL;
+  }
+
+  VarImpBase*
+  VarMap::varImpBase(int i) const {
+    if (i<0 || i>=vo->n)
+      throw ReflectionException("Variable not in VarMap");
+    return vo->vars[i];
+  }
+
+  VarSpec&
+  VarMap::spec(const VarImpBase* cx) const {
+    int i;
+    VarImpBase* x = const_cast<VarImpBase*>(cx);
+    if (!vo->m.get(x,i))
+      throw ReflectionException("Variable not in VarMap");
+    return *vo->specs[i];
+  }
+
+  VarSpec&
+  VarMap::spec(int i) const {
+    if (i<0 || i>=vo->n)
+      throw ReflectionException("Variable not in VarMap");
+    return *vo->specs[i];
+  }
+
+  VarSpec&
+  VarMap::spec(const Support::Symbol& n) const {
+    return spec(varImpBase(n));
+  }
+
+  void
+  VarMap::name(VarImpBase* x, const Support::Symbol& n) {
+    VarImpBase* y;
+    if (vo->nameToVar.get(n, y) && x != y)
+      throw
+        ReflectionException("Variable with the same name already in VarMap");
+    vo->nameToVar.put(n, x);
+    vo->varToName.put(x, n);
+  }
+
+  int
+  VarMap::put(const VarImpBase* cx, VarSpec* spec) {
+    VarImpBase* x = const_cast<VarImpBase*>(cx);
+    int newIndex = vo->n++;
+    vo->m.put(x, newIndex);
+    vo->specs[newIndex] = spec;
+    vo->vars[newIndex] = x;
+    if (hasName(x)) {
+      spec->name(name(x));
+    } else if (spec != NULL && spec->hasName()) {
+      vo->nameToVar.put(spec->name(), x);
+      vo->varToName.put(x, spec->name());
+    }
+    return newIndex;
+  }
+  
+  void
+  VarMap::putMasterObject(void* obj) {
+    vo->sharedObjectMap.put(obj, vo->so);
+    vo->sharedObjects[vo->so++] = obj;
+  }
+
+  int
+  VarMap::getSharedIndex(void* obj) const {
+    int idx;
+    if (vo->sharedObjectMap.get(obj, idx))
+      return idx;
+    return -1;
+  }
+  
+  void*
+  VarMap::getSharedObject(int i) const {
+    assert(i < vo->so);
+    return vo->sharedObjects[i];
+  }
+
+  Var
+  VarMap::var(const Support::Symbol& n) const {
+    return Var(varImpBase(n), spec(n).vti());
+  }
+
+  Var
+  VarMap::var(int i) const {
+    return Var(varImpBase(i), spec(i).vti());
+  }
+
+  /* Variable map iterator */
+
+  VarMapIter::VarMapIter(VarMap& m0) : m(&m0), i(0) {}
+
+  bool
+  VarMapIter::operator()(void) const { return i<m->vo->n; }
+
+  VarSpec&
+  VarMapIter::spec(void) const { return *m->vo->specs[i]; }
+
+  VarImpBase*
+  VarMapIter::varImpBase(void) const { return m->vo->vars[i]; }
+
+  void
+  VarMapIter::operator++(void) { i++; }  
+
+  Var
+  VarMapIter::var(void) const {
+    return Var(varImpBase(), spec().vti());
+  }
+
+}}
+
+// STATISTICS: kernel-other