main page modules namespaces classes files
Gecode home

search for 

array.icc

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2005
 *
 *  Last modified:
 *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
 *     $Revision: 3512 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

namespace Gecode {

  // Forward declaration.
  class BoolVarArray;


  typedef PrimArgArray<int>    IntArgs;
  typedef VarArgArray<IntVar>  IntVarArgs;
  class BoolVarArgs : public IntVarArgs {
  public:


    BoolVarArgs(int n);
    BoolVarArgs(const BoolVarArgs& a);
    explicit BoolVarArgs(const BoolVarArray& a);



    BoolVar& operator[](int i);
    const BoolVar& operator[](int i) const;
  };


  class IntVarArray : public VarArray<IntVar> {
  public:


    IntVarArray(void);
    IntVarArray(Space* home, int n);
    IntVarArray(const IntVarArray& a);
    GECODE_INT_EXPORT
    IntVarArray(Space* home, int n, int min, int max);
    GECODE_INT_EXPORT
    IntVarArray(Space* home, int n, const IntSet& s);
  };
  class BoolVarArray : public IntVarArray {
  public:


    BoolVarArray(void);
    BoolVarArray(Space* home, int n);
    BoolVarArray(const BoolVarArray& a);
    GECODE_INT_EXPORT
    BoolVarArray(Space* home, int n, int min, int max);



    BoolVar& operator[](int i);
    const BoolVar& operator[](int i) const;
  };

  template <>
  class ArrayTraits<IntVarArray> {
  public:
    typedef IntVarArgs   storage_type;
    typedef IntVar       value_type;
    typedef IntVarArgs   args_type;
  };
  template <>
  class ArrayTraits<IntVarArgs> {
  public:
    typedef IntVarArgs storage_type;
    typedef IntVar     value_type;
    typedef IntVarArgs args_type;
  };
  template <>
  class ArrayTraits<IntArgs> {
  public:
    typedef IntArgs storage_type;
    typedef int     value_type;
    typedef IntArgs args_type;
  };
  template <>
  class ArrayTraits<BoolVarArray> {
  public:
    typedef BoolVarArgs   storage_type;
    typedef BoolVar       value_type;
    typedef BoolVarArgs   args_type;
  };
  template <>
  class ArrayTraits<BoolVarArgs> {
  public:
    typedef BoolVarArgs storage_type;
    typedef BoolVar     value_type;
    typedef BoolVarArgs args_type;
  };

  /*
   * Implementation
   *
   */

  forceinline
  BoolVarArgs::BoolVarArgs(const BoolVarArgs& a)
    : IntVarArgs(a) {}

  forceinline
  BoolVarArgs::BoolVarArgs(const BoolVarArray& a)
    : IntVarArgs(a) {}

  forceinline
  BoolVarArgs::BoolVarArgs(int n)
    : IntVarArgs(n) {}


  forceinline BoolVar&
  BoolVarArgs::operator[](int i) {
    BoolVar* b = static_cast<BoolVar*>(&a[i]);
    return *b;
  }

  forceinline const BoolVar&
  BoolVarArgs::operator[](int i) const {
    const BoolVar* b = static_cast<BoolVar*>(&a[i]);
    return *b;
  }

  forceinline
  IntVarArray::IntVarArray(void) {}

  forceinline
  IntVarArray::IntVarArray(Space* home, int n)
    : VarArray<IntVar>(home,n) {}

  forceinline
  IntVarArray::IntVarArray(const IntVarArray& a)
    : VarArray<IntVar>(a) {}


  forceinline
  BoolVarArray::BoolVarArray(void) {}

  forceinline
  BoolVarArray::BoolVarArray(const BoolVarArray& a)
    : IntVarArray(a) {}

  forceinline
  BoolVarArray::BoolVarArray(Space* home, int n)
    : IntVarArray(home,n) {}


  forceinline BoolVar&
  BoolVarArray::operator[](int i) {
    BoolVar* b = static_cast<BoolVar*>(&x[i]);
    return *b;
  }

  forceinline const BoolVar&
  BoolVarArray::operator[](int i) const {
    const BoolVar* b = static_cast<BoolVar*>(&x[i]);
    return *b;
  }

}

// STATISTICS: int-other