gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/gecode/iter.hh

@@ -1,90 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2005
- *
- *  Last modified:
- *     $Date: 2007-09-18 14:58:14 +0200 (Tue, 18 Sep 2007) $ by $Author: schulte $
- *     $Revision: 5045 $
- *
- *  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.
- *
- */
-
-#ifndef __GECODE_ITER_HH__
-#define __GECODE_ITER_HH__
-
-namespace Gecode {
-  /// Range and value iterators
-  namespace Iter {
-     /// Range iterators
-     namespace Ranges {
-       /// Range iterators with virtual member functions
-       namespace Virt {}
-     }
-     /// Value iterators
-     namespace Values {}
-  }
-}
-
-#include "gecode/iter/ranges-operations.icc"
-#include "gecode/iter/ranges-minmax.icc"
-
-#include "gecode/iter/ranges-append.icc"
-#include "gecode/iter/ranges-array.icc"
-#include "gecode/iter/ranges-cache.icc"
-#include "gecode/iter/ranges-compl.icc"
-#include "gecode/iter/ranges-diff.icc"
-#include "gecode/iter/ranges-empty.icc"
-#include "gecode/iter/ranges-inter.icc"
-#include "gecode/iter/ranges-minus.icc"
-#include "gecode/iter/ranges-offset.icc"
-#include "gecode/iter/ranges-scale.icc"
-#include "gecode/iter/ranges-singleton.icc"
-#include "gecode/iter/ranges-union.icc"
-#include "gecode/iter/ranges-values.icc"
-#include "gecode/iter/ranges-add.icc"
-#include "gecode/iter/ranges-singleton-append.icc"
-
-#include "gecode/iter/values-array.icc"
-#include "gecode/iter/values-minus.icc"
-#include "gecode/iter/values-offset.icc"
-#include "gecode/iter/values-ranges.icc"
-#include "gecode/iter/values-singleton.icc"
-#include "gecode/iter/values-unique.icc"
-
-#include "gecode/iter/ranges-size.icc"
-
-#include "gecode/iter/virtual-ranges.icc"
-#include "gecode/iter/virtual-ranges-union.icc"
-#include "gecode/iter/virtual-ranges-inter.icc"
-#include "gecode/iter/virtual-ranges-compl.icc"
-
-#endif
-
-// STATISTICS: iter-any
-

data/ext/gecode-2.1.1/gecode/iter/values-minus.icc

@@ -1,130 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2007
- *
- *  Last modified:
- *     $Date: 2007-09-11 15:58:22 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
- *     $Revision: 4973 $
- *
- *  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.
- *
- */
-
-namespace Gecode { namespace Iter { namespace Values {
-
-  /**
-   * \brief Range iterator for pointwise minus of a value iterator
-   *
-   * This iterator in effect changes the order of how values
-   * are iterated: the first values of the input iterator defines
-   * the last value of the Minus iterator. Upon initialization
-   * all values of the input iterator are stored in an array
-   * which later allows iteration in inverse direction.
-   *
-   * \ingroup FuncIterValues
-   */
-
-  template <class I>
-  class Minus  {
-  private:
-    /// %Values stored
-    SharedArray<int> v;
-    /// Current value position
-    int c;
-  public:
-    /// \name Constructors and initialization
-    //@{
-    /// Default constructor
-    Minus(void);
-    /// Initialize with values from \a i
-    Minus(I& i);
-    /// Initialize with values from \a i
-    void init(I& i);
-    //@}
-
-    /// \name Iteration control
-    //@{
-    /// Test whether iterator is still at a value or done
-    bool operator()(void) const;
-    /// Move iterator to next value (if possible)
-    void operator++(void);
-    //@}
-
-    /// \name Value access
-    //@{
-    /// Return current value
-    int val(void) const;
-    //@}
-  };
-
-
-  template <class I>
-  forceinline
-  Minus<I>::Minus(void) {}
-
-  template <class I>
-  inline void
-  Minus<I>::init(I& i) {
-    Support::DynamicArray<int> d;
-    int n=0;
-    while (i()) {
-      d[n] = -i.val();
-      ++n; ++i;
-    }
-    v.init(n);
-    for (int j=n; j--; )
-      v[j]=d[j];
-    c = n-1;
-  }
-
-  template <class I>
-  forceinline
-  Minus<I>::Minus(I& i) {
-    init(i);
-  }
-
-  template <class I>
-  forceinline void
-  Minus<I>::operator++(void) {
-    c--;
-  }
-  template <class I>
-  forceinline bool
-  Minus<I>::operator()(void) const {
-    return c >= 0;
-  }
-
-  template <class I>
-  forceinline int
-  Minus<I>::val(void) const {
-    return v[c];
-  }
-
-}}}
-
-// STATISTICS: iter-any

data/ext/gecode-2.1.1/gecode/kernel.hh

@@ -1,182 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Contributing authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2004
- *     Guido Tack, 2004
- *
- *  Last modified:
- *     $Date: 2008-02-22 06:55:38 +0100 (Fri, 22 Feb 2008) $ by $Author: schulte $
- *     $Revision: 6274 $
- *
- *  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.
- *
- */
-
-#ifndef __GECODE_KERNEL_HH__
-#define __GECODE_KERNEL_HH__
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-
-#include "gecode/support.hh"
-
-/*
- * Configure linking
- *
- */
-#if !defined(GECODE_STATIC_LIBS) && \
-    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
-
-#ifdef GECODE_BUILD_KERNEL
-#define GECODE_KERNEL_EXPORT __declspec( dllexport )
-#else
-#define GECODE_KERNEL_EXPORT __declspec( dllimport )
-#endif
-
-#else
-
-#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
-#define GECODE_KERNEL_EXPORT __attribute__ ((visibility("default")))
-#else
-#define GECODE_KERNEL_EXPORT
-#endif
-
-#endif
-
-/**
- * \namespace Gecode
- * \brief Gecode toplevel namespace
- *
- * The Gecode namespace contains nested namespaces for
- * the various submodules (for example Int for the
- * definition of integer propagator classes). Functionality
- * that is used for interfacing (search engines, variables,
- * and so on) or belongs to the %Gecode %Kernel is contained
- * directly in the Gecode namespace.
- *
- */
-
-/*
- * General exceptions and kernel exceptions
- *
- */
-
-#include "gecode/kernel/exception.icc"
-
-
-
-/*
- * Basic kernel services
- *
- */
-
-#include "gecode/kernel/memory-manager.icc"
-
-
-/*
- * Macros for checking failure
- *
- */
-
-
-#include "gecode/kernel/macros.icc"
-
-/*
- * Gecode kernel
- *
- */
-
-#include "gecode/kernel/core.icc"
-#include "gecode/kernel/modevent.icc"
-
-/*
- * Traits linking variables, views, and variable implementations
- *
- */
-
-#include "gecode/kernel/var-traits.icc"
-
-/*
- * Access to the constraint graph
- *
- */
-
-#include "gecode/kernel/reflection.icc"
-
-/*
- * Variables, views and testing for shared variables
- *
- */
-
-#include "gecode/kernel/view.icc"
-#include "gecode/kernel/var.icc"
-
-/*
- * Variable and argument arrays
- *
- */
-
-#include "gecode/kernel/array.icc"
-
-/*
- * Access to the constraint graph
- *
- */
-
-#include "gecode/kernel/var-map.icc"
-
-/*
- * Shared arrays
- *
- */
-
-#include "gecode/kernel/shared-array.icc"
-
-/*
- * Common propagator and branching patterns
- *
- */
-
-#include "gecode/kernel/propagator.icc"
-#include "gecode/kernel/advisor.icc"
-#include "gecode/kernel/branching.icc"
-
-/*
- * Automatically generated variable implementations
- *
- */
-
-#include "gecode/kernel/var-imp.icc"
-
-#endif
-
-// STATISTICS: kernel-other

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

@@ -1,447 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2004
- *     Guido Tack, 2004
- *
- *  Last modified:
- *     $Date: 2008-02-16 10:42:26 +0100 (Sat, 16 Feb 2008) $ by $Author: tack $
- *     $Revision: 6185 $
- *
- *  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.
- *
- */
-
-namespace Gecode {
-
-  /**
-   * \defgroup TaskBranchViewVal Generic branching based on view and value selection
-   *
-   * Implements view-based branching for an array of views and value.
-   * \ingroup TaskActor
-   */
-
-  //@{
-  /// Status returned by member functions of view selection class
-  enum ViewSelStatus {
-    VSS_NONE,   ///< Current view is not better
-    VSS_SELECT, ///< Current view is better
-    VSS_COMMIT  ///< Current view is known to be a best one
-  };
-
-  /**
-   * \brief Generic branching
-   *
-   * Implements view-based branching for an array of views (of type
-   * \a View) and value (of type \a Val). The behaviour is defined by
-   * the class \a ViewSel (which view is selected for branching)
-   * and the class \a ValSel (which value is selected for branching).
-   *
-   * The class \a ViewSel must implement two member functions:
-   *  - Gecode::ViewSelStatus init(const Space* \a home, \a View \a x)
-   *    Initializes view selection with the \a View \a x. If \a x
-   *    is known to be a best one, VSS_COMMIT should be returned.
-   *    Otherwise, either VSS_NONE or VSS_SELECT should be returned.
-   *  - Gecode::ViewSelStatus select(const Space* \a home, \a View \a x)
-   *    If \a x is not better than the previously selected view,
-   *    return VSS_NONE. If it is better, return VSS_SELECT. If
-   *    it is a best view, return VSS_COMMIT.
-   *
-   * The class \a ValSel must implement two member functions:
-   *  - \a Val val(const Space* \a home, View \a x) const
-   *    returns the value (most likely determined by \a x) to branch with.
-   *  - Gecode::ModEvent tell(Space* \a home, unsigned int \a a, \a View \a x, \a Val \a n)
-   *    performs a tell for alternative \a a on \a x with value \a n.
-   *
-   * For examples, see \link int/branch.hh integer branchings \endlink.
-   */
-  template <class View, class Val, class ViewSel, class ValSel>
-  class ViewValBranching : public Branching {
-  protected:
-    ViewArray<View> x;  ///< Views to branch on
-    mutable int start;  ///< Unassigned views start at x[start]
-    /// Constructor for cloning \a b
-    ViewValBranching(Space* home, bool share, ViewValBranching& b);
-  public:
-    /// Constructor for creation
-    ViewValBranching(Space* home, ViewArray<View>& x);
-    /// Check status of branching, return true if alternatives left
-    virtual bool status(const Space* home) const;
-    /// Return branching description (of type Gecode::PosValDesc)
-    virtual const BranchingDesc* description(const Space* home) const;
-    /// Perform commit for branching description \a d and alternative \a a
-    virtual ExecStatus commit(Space* home, const BranchingDesc* d,
-                              unsigned int a);
-    /// Return specification for this branching given a variable map \a m
-    virtual Reflection::ActorSpec spec(const Space* home,
-                                       Reflection::VarMap& m) const;
-    /// Return specification for a branch
-    virtual Reflection::BranchingSpec
-    branchingSpec(const Space* home, 
-                  Reflection::VarMap& m,
-                  const BranchingDesc* d) const;
-    /// Actor type identifier of this branching
-    static Support::Symbol ati(void);
-    /// Post branching according to specification
-    static void post(Space* home, Reflection::VarMap& m,
-                     const Reflection::ActorSpec& spec);
-    /// Perform cloning
-    virtual Actor* copy(Space* home, bool share);
-  };
-
-  /**
-   * \brief Generic assignment
-   *
-   * Implements view-based assignment for an array of views (of type
-   * \a View) and value (of type \a Val). The behaviour is defined by
-   * the class \a ValSel (which value is selected for assignment).
-   *
-   * The class \a ValSel must implement two member functions:
-   *  - \a Val val(const Space* \a home, View \a x) const
-   *    returns the value (most likely determined by \a x) to branch with.
-   *  - Gecode::ModEvent tell(Space* \a home, unsigned int a, \a View \a x, \a Val \a n)
-   *    performs a tell on \a x with value \a n (the value for \a a is
-   *    always 0, it is present such that assignments can use the same
-   *    value selection as branchings).
-   *
-   * For examples, see \link int/branch.hh integer branchings \endlink.
-   */
-  template <class View, class Val, class ValSel>
-  class ViewValAssignment : public Branching {
-  protected:
-    ViewArray<View> x;  ///< Views to branch on
-    mutable int start;  ///< Unassigned views start at x[start]
-    /// Constructor for cloning \a b
-    ViewValAssignment(Space* home, bool share, ViewValAssignment& b);
-  public:
-    /// Constructor for creation
-    ViewValAssignment(Space* home, ViewArray<View>& x);
-    /// Check status of branching, return true if alternatives left
-    virtual bool status(const Space* home) const;
-    /// Return branching description (of type Gecode::PosValDesc)
-    virtual const BranchingDesc* description(const Space* home) const;
-    /// Perform commit for branching description \a d and alternative \a a
-    virtual ExecStatus commit(Space* home, const BranchingDesc* d,
-                              unsigned int a);
-    /// Return specification for this assignment given a variable map \a m
-    virtual Reflection::ActorSpec spec(const Space* home,
-                                        Reflection::VarMap& m) const;
-    /// Return specification for a branch
-    virtual Reflection::BranchingSpec
-    branchingSpec(const Space* home, 
-                  Reflection::VarMap& m,
-                  const BranchingDesc* d) const;
-    /// Actor type identifier of this assignment
-    static Support::Symbol ati(void);
-    /// Post assignment according to specification
-    static void post(Space* home, Reflection::VarMap& m,
-                     const Reflection::ActorSpec& spec);
-    /// Perform cloning
-    virtual Actor* copy(Space* home, bool share);
-  };
-
-  /**
-   * \brief %Branching descriptions storing position and value
-   *
-   * The maximal number of alternatives is defined by \a alt.
-   */
-  template <class Val, unsigned int alt>
-  class PosValDesc : public BranchingDesc {
-  protected:
-    /// Position of view
-    const int _pos;
-    /// Value to assign to
-    const Val _val;
-    /// Start position in view array
-    const int _start;
-  public:
-    /** \brief Initialize description for branching \a b, position \a p, value \a n, and start position \a s.
-      *
-      * The start position can be used in the commit function to eliminate 
-      * assigned variables from the array.
-      */
-    PosValDesc(const Branching* b, const int p, const Val& n, const int s=0);
-    /// Return position in array
-    int pos(void) const;
-    /// Return value to branch with
-    Val val(void) const;
-    /// Return the start index in the array
-    int start(void) const;
-    /// Report size occupied
-    virtual size_t size(void) const;
-  };
-
-  //@}
-
-
-
-
-
-
-  /*
-   * Branching descriptions with position and value
-   *
-   */
-
-  template <class Val, unsigned int alt>
-  forceinline
-  PosValDesc<Val,alt>::PosValDesc(const Branching* b, const int p,
-                                  const Val& n, const int s)
-    : BranchingDesc(b,alt), _pos(p), _val(n), _start(s) {}
-
-  template <class Val, unsigned int alt>
-  forceinline int
-  PosValDesc<Val,alt>::pos(void) const {
-    return _pos;
-  }
-
-  template <class Val, unsigned int alt>
-  forceinline Val
-  PosValDesc<Val,alt>::val(void) const {
-    return _val;
-  }
-
-  template <class Val, unsigned int alt>
-  forceinline int
-  PosValDesc<Val,alt>::start(void) const {
-    return _start;
-  }
-
-  template <class Val, unsigned int alt>
-  size_t
-  PosValDesc<Val,alt>::size(void) const {
-    return sizeof(PosValDesc<Val,alt>);
-  }
-
-
-  /*
-   * Generic branching based on variable/value selection
-   *
-   */
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  forceinline
-  ViewValBranching<View,Val,ViewSel,ValSel>
-  ::ViewValBranching(Space* home, ViewArray<View>& x0)
-    : Branching(home), x(x0), start(0) {}
-
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  forceinline
-  ViewValBranching<View,Val,ViewSel,ValSel>
-  ::ViewValBranching(Space* home, bool share, ViewValBranching& b)
-    : Branching(home,share,b), start(b.start) {
-    x.update(home,share,b.x);
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  Actor*
-  ViewValBranching<View,Val,ViewSel,ValSel>::copy(Space* home, bool share) {
-    return new (home)
-      ViewValBranching<View,Val,ViewSel,ValSel>(home,share,*this);
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  bool
-  ViewValBranching<View,Val,ViewSel,ValSel>
-  ::status(const Space*) const {
-    for (int i=start; i < x.size(); i++)
-      if (!x[i].assigned()) {
-        start = i;
-        return true;
-      }
-    return false;
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  const BranchingDesc*
-  ViewValBranching<View,Val,ViewSel,ValSel>
-  ::description(const Space* home) const {
-    assert(!x[start].assigned());
-    ViewSel vs; // For view selection
-    ValSel  vl; // For value selection
-    int i = start;
-    int b = i++;
-    if (vs.init(home,x[b]) != VSS_COMMIT)
-      for (; i < x.size(); i++)
-        if (!x[i].assigned())
-          switch (vs.select(home,x[i])) {
-          case VSS_SELECT: b=i; break;
-          case VSS_COMMIT: b=i; goto create;
-          case VSS_NONE:   break;
-          default:         GECODE_NEVER;
-          }
-  create:
-    return new PosValDesc<Val,2>(this,b-start,vl.val(home,x[b]),start);
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  ExecStatus
-  ViewValBranching<View,Val,ViewSel,ValSel>
-  ::commit(Space* home, const BranchingDesc* d, unsigned int a) {
-    const PosValDesc<Val,2>* pvd = static_cast<const PosValDesc<Val,2>*>(d);
-    // Eliminate views from x[0] ... x[d->start()-1]
-    x.drop_fst(pvd->start()); start = 0;
-    ValSel vs;
-    return me_failed(vs.tell(home,a,x[pvd->pos()],pvd->val()))
-      ? ES_FAILED : ES_OK;
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  Support::Symbol
-  ViewValBranching<View,Val,ViewSel,ValSel>::ati(void) {
-    return Reflection::mangle<View,Val,ViewSel,ValSel>("Gecode::ViewValBranching");
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  void
-  ViewValBranching<View,Val,ViewSel,ValSel>
-    ::post(Space* home, Reflection::VarMap& vars,
-           const Reflection::ActorSpec& spec) {
-    spec.checkArity(1);
-    ViewArray<View> x(home, vars, spec[0]);
-    (void) new (home) ViewValBranching<View,Val,ViewSel,ValSel>(home, x);
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  Reflection::ActorSpec
-  ViewValBranching<View,Val,ViewSel,ValSel>::spec(const Space* home,
-    Reflection::VarMap& m) const {
-    Reflection::ActorSpec s(ati());
-    return s << x.spec(home, m);
-  }
-
-  template <class View, class Val, class ViewSel, class ValSel>
-  Reflection::BranchingSpec
-  ViewValBranching<View,Val,ViewSel,ValSel>::branchingSpec(const Space* home, 
-    Reflection::VarMap& m, const BranchingDesc* d) const {
-    Reflection::BranchingSpec bs(d);
-    const PosValDesc<Val,2>* pvd = static_cast<const PosValDesc<Val,2>*>(d);
-    ValSel vs;
-    vs.branchingSpec(home, m, bs, 2, x[pvd->start()+pvd->pos()], pvd->val());
-    return bs;
-  }
-
-  /*
-   * Generic assignment based on value selection
-   *
-   */
-
-  template <class View, class Val, class ValSel>
-  forceinline
-  ViewValAssignment<View,Val,ValSel>
-  ::ViewValAssignment(Space* home, ViewArray<View>& x0)
-    : Branching(home), x(x0), start(0) {}
-
-
-  template <class View, class Val, class ValSel>
-  forceinline
-  ViewValAssignment<View,Val,ValSel>
-  ::ViewValAssignment(Space* home, bool share, ViewValAssignment& b)
-    : Branching(home,share,b), start(b.start) {
-    x.update(home,share,b.x);
-  }
-
-  template <class View, class Val, class ValSel>
-  Actor*
-  ViewValAssignment<View,Val,ValSel>::copy(Space* home, bool share) {
-    return new (home)
-      ViewValAssignment<View,Val,ValSel>(home,share,*this);
-  }
-
-  template <class View, class Val, class ValSel>
-  bool
-  ViewValAssignment<View,Val,ValSel>
-  ::status(const Space*) const {
-    for (int i=start; i < x.size(); i++)
-      if (!x[i].assigned()) {
-        start = i;
-        return true;
-      }
-    return false;
-  }
-
-  template <class View, class Val, class ValSel>
-  const BranchingDesc*
-  ViewValAssignment<View,Val,ValSel>
-  ::description(const Space* home) const {
-    assert(!x[start].assigned());
-    ValSel vl; // For value selection
-    return new PosValDesc<Val,1>(this,0,vl.val(home,x[start]),start);
-  }
-
-  template <class View, class Val, class ValSel>
-  ExecStatus
-  ViewValAssignment<View,Val,ValSel>
-  ::commit(Space* home, const BranchingDesc* d, unsigned int) {
-    const PosValDesc<Val,1>* pvd = static_cast<const PosValDesc<Val,1>*>(d);
-    // Eliminate views from x[0] ... x[d->start()-1]
-    x.drop_fst(pvd->start()); start = 0;
-    ValSel vs;
-    return me_failed(vs.tell(home,0,x[pvd->pos()],pvd->val()))
-      ? ES_FAILED : ES_OK;
-  }
-
-  template <class View, class Val, class ValSel>
-  Support::Symbol
-  ViewValAssignment<View,Val,ValSel>::ati(void) {
-    return Reflection::mangle<View,Val,ValSel>("Gecode::ViewValAssignment");
-  }
-
-  template <class View, class Val, class ValSel>
-  void
-  ViewValAssignment<View,Val,ValSel>
-    ::post(Space* home, Reflection::VarMap& vars,
-           const Reflection::ActorSpec& spec) {
-    spec.checkArity(1);
-    ViewArray<View> x(home, vars, spec[0]);
-    (void) new (home) ViewValAssignment<View,Val,ValSel>(home, x);
-  }
-
-  template <class View, class Val, class ValSel>
-  Reflection::ActorSpec
-  ViewValAssignment<View,Val,ValSel>::spec(const Space* home,
-    Reflection::VarMap& m) const {
-    Reflection::ActorSpec s(ati());
-    return s << x.spec(home, m);
-  }
-
-  template <class View, class Val, class ValSel>
-  Reflection::BranchingSpec
-  ViewValAssignment<View,Val,ValSel>::branchingSpec(const Space* home, 
-    Reflection::VarMap& m, const BranchingDesc* d) const {
-    Reflection::BranchingSpec bs(d);
-    const PosValDesc<Val,1>* pvd = static_cast<const PosValDesc<Val,1>*>(d);
-    ValSel vs;
-    vs.branchingSpec(home, m, bs, 1, x[pvd->start()+pvd->pos()], pvd->val());
-    return bs;
-  }
-
-}
-
-// STATISTICS: kernel-other