reflection.icc

Go to the documentation of this file.

/* -*- 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:39:08 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
 *     $Revision: 7297 $
 *
 *  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 { namespace Reflection {
  

  class GECODE_VTABLE_EXPORT ReflectionException : public Exception {
  public:
    ReflectionException(const char* what) : Exception("Reflection", what) {}
  };

  class GECODE_VTABLE_EXPORT NoReflectionDefinedException
  : public ReflectionException {
  public:
    NoReflectionDefinedException(void)
    : ReflectionException("No reflection defined") {}
  };

  
  class ArrayArg;
  class IntArrayArg;
  
  class GECODE_KERNEL_EXPORT Arg {
  protected:
    enum argtype {
      INT_ARG,           
      VAR_ARG,           
      ARRAY_ARG,         
      INT_ARRAY_ARG,     
      STRING_ARG,        
      PAIR_ARG,          
      SHARED_OBJECT_ARG, 
      SHARED_REF_ARG     
    };

    argtype t;
    
    union {
      int i;
      char* s;
      Arg* first;
    } arg1;

    union {
      Arg* second;
      Arg** aa;
      int* ia;
    } arg2;
    Arg(argtype t);
    
  public:
    bool         isInt(void) const;
    int          toInt(void) const;
    static Arg*  newInt(int i);
    void         initInt(int i);
    
    bool         isVar(void) const;
    int          toVar(void) const;
    static Arg*  newVar(int i);
    void         initVar(int i);
    
    bool             isArray(void) const;
    ArrayArg*        toArray(void);
    const ArrayArg*  toArray(void) const;
    static ArrayArg* newArray(int n);
    void         initArray(int n);
    
    bool                isIntArray(void) const;
    IntArrayArg*        toIntArray(void);
    const IntArrayArg*  toIntArray(void) const;
    static IntArrayArg* newIntArray(int n);
    template <class A>
    static IntArrayArg* newIntArray(const A& a);
    void         initIntArray(int n);

    bool         isString(void) const;
    const char*  toString(void) const;
    static Arg*  newString(const char* s);
    void         initString(const char* s);
    
    bool         isPair(void) const;
    Arg*         first(void);
    const Arg*   first(void) const;
    Arg*         second(void);
    const Arg*   second(void) const;
    static Arg*  newPair(Arg* a, Arg* b);
    void         initPair(Arg* a, Arg* b);
    
    bool         isSharedObject(void) const;
    Arg*         toSharedObject(void);
    const Arg*   toSharedObject(void) const;
    static Arg*  newSharedObject(Arg* a);
    void         initSharedObject(Arg* a);
    
    bool         isSharedReference(void) const;
    int          toSharedReference(void) const;
    static Arg*  newSharedReference(int ref);
    void         initSharedReference(int ref);
    
    GECODE_MSC_VIRTUAL ~Arg(void);
  };
  

  class GECODE_KERNEL_EXPORT ArrayArg : public Arg {
  private:
    ArrayArg(void);
  public:
    const Arg* operator[](int i) const;
    Arg*& operator[](int i);
    int size(void) const;
  };

  class GECODE_KERNEL_EXPORT IntArrayArg : public Arg {
  private:
    IntArrayArg(void);
  public:
    const int& operator[](int i) const;
    int& operator[](int i);
    int size(void) const;
  };

  class GECODE_KERNEL_EXPORT IntArrayArgRanges {
  private:
    Reflection::IntArrayArg* a;
    int n;
  public:
    IntArrayArgRanges(Reflection::IntArrayArg* a0);
    bool operator()(void);
    void operator++(void);
    int min(void) const;
    int max(void) const;
    unsigned int width(void) const;
  };
  
  class GECODE_KERNEL_EXPORT VarSpec {
  private:
    class Domain;
    Domain* _dom;
  public:
    VarSpec(void);
    VarSpec(Support::Symbol vti, Arg* domain, bool assigned=false);
    VarSpec(const VarSpec& s);
    const VarSpec& operator=(const VarSpec& s);
    GECODE_MSC_VIRTUAL ~VarSpec(void);
    void name(const Support::Symbol& n0);
    Support::Symbol name(void) const;
    bool hasName(void) const;
    Arg* dom(void) const;
    bool assigned(void) const;
    // Get the variable type identifier for this variable
    Support::Symbol vti(void) const;
  };
  
  class GECODE_KERNEL_EXPORT ActorSpec {
    friend class BranchingSpec;
  private:
    class Arguments;
    Arguments* _args;
    void resize(void);
    friend class ActorSpecIter;
    void queue(int q);
    unsigned int branchingId(void) const;
  public:
    ActorSpec(void);
    ActorSpec(const Support::Symbol& name);
    ActorSpec(const ActorSpec& s);
    const ActorSpec& operator=(const ActorSpec& s);
    GECODE_MSC_VIRTUAL ~ActorSpec(void);
    


    Support::Symbol ati(void) const;
    int noOfArgs(void) const;
    void checkArity(int n) const;
    Arg* operator[](int i) const;

    bool isBranching(void) const;
    int queue(void) const;
    


    void add(Arg* arg);
  };

}}

Gecode::Reflection::ActorSpec
operator<<(Gecode::Reflection::ActorSpec s, Gecode::Reflection::Arg* arg);


Gecode::Reflection::ActorSpec
operator<<(Gecode::Reflection::ActorSpec s, int i);

Gecode::Reflection::ActorSpec
operator<<(Gecode::Reflection::ActorSpec s, unsigned int i);

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 {

  class GECODE_KERNEL_EXPORT BranchingSpec {
  private:
    class Arguments;
    Arguments* _args;
  public:
    BranchingSpec(void);
    BranchingSpec(const BranchingDesc* d);
    BranchingSpec(const BranchingSpec& s);
    const BranchingSpec& operator=(const BranchingSpec& s);
    GECODE_MSC_VIRTUAL ~BranchingSpec(void);
    


    bool createdBy(const ActorSpec& b) const;
    unsigned int alternatives(void) const;
    Arg* operator[](int i) const;
    
    Arg*& operator[](int i);
  };
  
  class VarMap;

  class GECODE_KERNEL_EXPORT ActorSpecIter {
  private:
    VarMap*      m;
    const Space* s;
    const ActorLink *active;
    const ActorLink *cur;
    bool       isBranching;
  public:
    ActorSpecIter(const Space*, VarMap&);
    bool operator()(void) const;
    void operator++(void);
    ActorSpec actor(void) const;
  };

  class Registry {
  private:
    class RegistryObject;
    RegistryObject* ro;
  public:
    typedef void (*poster) (Space*, VarMap&, const ActorSpec&);
    typedef VarImpBase* (*varCreator) (Space*, VarSpec&);
    typedef void (*varConstrainer) (Space*, VarImpBase*, VarSpec&);
    typedef VarImpBase* (*varUpdater) (Space*, bool, VarImpBase*);
    typedef std::ostream& (*varPrinter) (std::ostream&, VarImpBase*);
    typedef Arg* (*varSpec) (const Space* home, VarMap& m, VarImpBase*);

    GECODE_KERNEL_EXPORT Registry(void);
    GECODE_KERNEL_EXPORT GECODE_MSC_VIRTUAL ~Registry(void);

    GECODE_KERNEL_EXPORT VarImpBase*
    createVar(Space* home, VarSpec& spec) const;

    GECODE_KERNEL_EXPORT void
    constrainVar(Space* home, VarImpBase* v, VarSpec& spec) const;

    GECODE_KERNEL_EXPORT VarImpBase*
    updateVariable(Space* home, bool share, VarImpBase* v,
                   const Support::Symbol& vti) const;

    GECODE_KERNEL_EXPORT std::ostream&
    printVariable(std::ostream& os, VarImpBase* v,
                  const Support::Symbol& vti) const;

    GECODE_KERNEL_EXPORT Arg*
    spec(const Space* home, VarMap& vm,
         VarImpBase* v, const Support::Symbol& vti) const;

    GECODE_KERNEL_EXPORT void
    post(Space* home, VarMap& vm, const ActorSpec& spec) const;

    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varCreator vc);
    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varConstrainer vc);
    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varUpdater vu);
    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varPrinter vp);
    GECODE_KERNEL_EXPORT void add(Support::Symbol vti, varSpec vp);
    GECODE_KERNEL_EXPORT void add(const Support::Symbol& ati, poster p);
    GECODE_KERNEL_EXPORT void print(std::ostream& out);
  private:
    Registry(const Registry&);
    Registry& operator=(const Registry&);
  };
  
  GECODE_KERNEL_EXPORT Registry& registry(void);

  template <class P>
  class ActorRegistrar {
  public:
    ActorRegistrar(void);
  };

  template <class P>
  ActorRegistrar<P>::ActorRegistrar(void) {
    registry().add(P::ati(), &P::post);
  }

  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:
    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);
  }

  class Var {
  private:
    VarImpBase* _var;
    Support::Symbol _vti;
  public:
    Var(void);
    template <class VarImp> explicit Var(const VarBase<VarImp>& v);
    Var(const Var& v);
    Var(VarImpBase* var, const Support::Symbol& vti);
    GECODE_KERNEL_EXPORT void update(Space* home, bool share, Var& v);
    GECODE_KERNEL_EXPORT std::ostream& print(std::ostream& os) const;
    GECODE_KERNEL_EXPORT Arg* spec(const Space* home, VarMap& vm) const;
    VarImpBase* varImpBase(void) const;
    template <class VarImp>
    VarImp* var(void) const;
  };

  class GECODE_KERNEL_EXPORT Unreflector {
  private:
    Space* home;
    Reflection::VarMap& m;
    
  public:
    Unreflector(Space* home0, Reflection::VarMap& m0);

    GECODE_MSC_VIRTUAL ~Unreflector(void);
    
    Reflection::VarMap& varMap(void) const;
    
    void var(Reflection::VarSpec& spec);

    void post(Reflection::ActorSpec& spec);
  };

  forceinline
  Var::Var(void) {}
    
  template <class VarImp>
  forceinline
  Var::Var(const VarBase<VarImp>& v) {
    _var = v.var();
    _vti = v.var()->vti;
  }

  forceinline
  Var::Var(const Var& v) : _var(v._var), _vti(v._vti) {}
  
  forceinline
  Var::Var(VarImpBase* var, const Support::Symbol& vti)
    : _var(var), _vti(vti) {}

  forceinline VarImpBase*
  Var::varImpBase(void) const {
    return static_cast<VarImpBase*>(_var);    
  }

  template <class VarImp>
  inline VarImp*
  Var::var(void) const {
    if (! (VarImp::vti == _vti))
      throw ReflectionException("VTI mismatch");
    return static_cast<VarImp*>(_var);
  }


#define GECODE_REGISTER1(P) \
  ::Gecode::Reflection::ActorRegistrar< P > GECODE_FRESH(r)
#define GECODE_REGISTER2(P1,P2) \
  ::Gecode::Reflection::ActorRegistrar< P1,P2 > GECODE_FRESH(r)
#define GECODE_REGISTER3(P1,P2,P3) \
  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3 > GECODE_FRESH(r)
#define GECODE_REGISTER4(P1,P2,P3,P4) \
  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3,P4 > GECODE_FRESH(r)
#define GECODE_REGISTER5(P1,P2,P3,P4,P5) \
  ::Gecode::Reflection::ActorRegistrar< P1,P2,P3,P4,P5 > GECODE_FRESH(r)
#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;
  }
  
  template <class View>
  class TypeOf {
  public:
    static Support::Symbol t(void) { return View::type(); }
  };
  
  template <>
  class TypeOf<bool> {
  public:
    static Support::Symbol t(void) { return Support::Symbol("bool"); }
  };

  template <>
  class TypeOf<int> {
  public:
    static Support::Symbol t(void) { return Support::Symbol("int"); }
  };

  template <>
  class TypeOf<double> {
  public:
    static Support::Symbol t(void) { return Support::Symbol("double"); }
  };


}
  class IntSet;
namespace Reflection {

  template <>
  class TypeOf<const IntSet> {
  public:
    static Support::Symbol t(void) { return Support::Symbol("IntSet"); }    
  };

  template <class View0>
  Support::Symbol
  mangle(const Support::Symbol& ati) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ">";
    return mangled;
  }
  template <class View0>
  Support::Symbol
  mangle(const Support::Symbol& ati, bool b) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += Support::Symbol(b);
    mangled += ">";
    return mangled;
  }
  template <class View0>
  Support::Symbol
  mangle(const Support::Symbol& ati, int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  template <class View0>
  Support::Symbol
  mangle(const Support::Symbol& ati, unsigned int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  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;
  }
  template <class View0, class View1>
  Support::Symbol
  mangle(const Support::Symbol& ati, bool b) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += Support::Symbol(b);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1>
  Support::Symbol
  mangle(const Support::Symbol& ati, int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1>
  Support::Symbol
  mangle(const Support::Symbol& ati, unsigned int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  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;
  }
  template <class View0, class View1, class View2>
  Support::Symbol
  mangle(const Support::Symbol& ati, bool b) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += TypeOf<View2>::t();
    mangled += ",";
    mangled += Support::Symbol(b);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2>
  Support::Symbol
  mangle(const Support::Symbol& ati, int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += TypeOf<View2>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2>
  Support::Symbol
  mangle(const Support::Symbol& ati, unsigned int i) {
    Support::Symbol mangled = ati.copy();
    mangled += "<";
    mangled += TypeOf<View0>::t();
    mangled += ",";
    mangled += TypeOf<View1>::t();
    mangled += ",";
    mangled += TypeOf<View2>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  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;
  }
  template <class View0, class View1, class View2, class View3>
  Support::Symbol
  mangle(const Support::Symbol& ati, bool b) {
    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 += Support::Symbol(b);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2, class View3>
  Support::Symbol
  mangle(const Support::Symbol& ati, int i) {
    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 += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2, class View3>
  Support::Symbol
  mangle(const Support::Symbol& ati, unsigned int i) {
    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 += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  
  template <class View0, class View1, class View2, class View3, class View4>
  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 += TypeOf<View4>::t();
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2, class View3, class View4>
  Support::Symbol
  mangle(const Support::Symbol& ati, bool b) {
    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 += TypeOf<View4>::t();
    mangled += ",";
    mangled += Support::Symbol(b);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2, class View3, class View4>
  Support::Symbol
  mangle(const Support::Symbol& ati, int i) {
    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 += TypeOf<View4>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }
  template <class View0, class View1, class View2, class View3, class View4>
  Support::Symbol
  mangle(const Support::Symbol& ati, unsigned int i) {
    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 += TypeOf<View4>::t();
    mangled += ",";
    mangled += Support::Symbol(i);
    mangled += ">";
    return mangled;
  }

}}

GECODE_KERNEL_EXPORT std::ostream&
operator<<(std::ostream& os, const Gecode::Reflection::Var& v);

// STATISTICS: kernel-other