dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/bitset.hpp

@@ -0,0 +1,81 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2010-07-15 01:46:18 +1000 (Thu, 15 Jul 2010) $ by $Author: schulte $
+ *     $Revision: 11192 $
+ *
+ *  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 <climits>
+#include <cmath>
+
+namespace Gecode { namespace Support {
+
+  /// Simple bitsets
+  template<class A>
+  class BitSet : public BitSetBase {
+  protected:
+    /// Allocator
+    A& a;
+  public:
+    /// Bit set with space for \a s bits
+    BitSet(A& a, unsigned int s);
+    /// Copy bit set \a bs
+    BitSet(A& a, const BitSet& bs);
+    /// Destructor
+    ~BitSet(void);
+  };
+
+  template<class A>
+  forceinline
+  BitSet<A>::BitSet(A& a0, unsigned int s)
+    : BitSetBase(a0,s), a(a0) {}
+
+  template<class A>
+  forceinline
+  BitSet<A>::BitSet(A& a0, const BitSet<A>& bs)
+    : BitSetBase(a0,bs), a(a0) {}
+
+  template<class A>
+  forceinline
+  BitSet<A>::~BitSet(void) {
+    dispose(a);
+  }
+
+}}
+
+// STATISTICS: support-any
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/block-allocator.hpp

@@ -0,0 +1,169 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2010-07-29 00:13:53 +1000 (Thu, 29 Jul 2010) $ by $Author: schulte $
+ *     $Revision: 11292 $
+ *
+ *  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 Support {
+
+  /**
+   * \brief Manage memory organized into block lists (allocator)
+   *
+   * The allocation policy is to free all memory allocated when
+   * the block allocator is deleted.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class T, class A, int blocksize = 512>
+  class BlockAllocator {
+  private:
+    /// Memory allocator
+    A& a;
+    /// One block of memory
+    class Block {
+    public:
+      T      b[blocksize];
+      Block* next;
+    };
+    /// Pointer to current block
+    Block* b;
+    /// Pointer to next part of block (decreasing)
+    T*     n;
+    /// Size of allocated blocks
+    size_t _size;
+    /// Allocate additional block
+    void allocate(void);
+  public:
+    /// Initialize
+    BlockAllocator(A& a);
+    /// Free all allocated blocks
+    ~BlockAllocator(void);
+    /// Return allocator used
+    A& allocator(void);
+    /// Return memory of size required by \a T
+    T* operator ()(void);
+    /// Return size of memory required by allocator
+    size_t size(void) const;
+  };
+
+  /**
+   * \brief Client for block allocator of type \a T
+   *
+   * Provides memory management for objects of type \a T.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class T, class A, int blocksize = 512>
+  class BlockClient {
+  public:
+    /// Allocate memory from block allocator \a ba
+    static void* operator new(size_t s, BlockAllocator<T,A,blocksize>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*, BlockAllocator<T,A,blocksize>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*);
+  };
+
+
+
+  template<class T, class A, int blocksize>
+  forceinline
+  BlockAllocator<T,A,blocksize>::BlockAllocator(A& a0) : a(a0) {
+    b = static_cast<Block*>(a.ralloc(sizeof(Block)));
+    b->next = NULL;
+    n       = &b->b[blocksize];
+    _size = sizeof(Block);
+  }
+
+  template<class T, class A, int blocksize>
+  forceinline
+  BlockAllocator<T,A,blocksize>::~BlockAllocator(void) {
+    while (b != NULL) {
+      Block* f = b; b = b->next;
+      a.rfree(f,sizeof(Block));
+    }
+  }
+
+  template<class T, class A, int blocksize>
+  forceinline A&
+  BlockAllocator<T,A,blocksize>::allocator(void) {
+    return a;
+  }
+
+  template<class T, class A, int blocksize>
+  forceinline T*
+  BlockAllocator<T,A,blocksize>::operator ()(void) {
+    T* t = --n;
+    if (t == &b->b[0])
+      allocate();
+    return t;
+  }
+
+  template<class T, class A, int blocksize>
+  void
+  BlockAllocator<T,A,blocksize>::allocate(void) {
+    // Allocate another block
+    Block* nb = static_cast<Block*>(a.ralloc(sizeof(Block)));
+    nb->next = b; b = nb;
+    n = &nb->b[blocksize];
+    _size += sizeof(Block);
+  }
+
+  template<class T, class A, int blocksize>
+  forceinline size_t
+  BlockAllocator<T,A,blocksize>::size(void) const {
+    return _size;
+  }
+
+
+
+  template<class T, class A, int blocksize>
+  forceinline void
+  BlockClient<T,A,blocksize>::operator 
+  delete(void*,BlockAllocator<T,A,blocksize>&) {
+  }
+  template<class T, class A, int blocksize>
+  forceinline void
+  BlockClient<T,A,blocksize>::operator delete(void*) {
+  }
+  template<class T, class A, int blocksize>
+  forceinline void*
+  BlockClient<T,A,blocksize>::operator new(size_t,
+                                           BlockAllocator<T,A,blocksize>& ba) {
+    return ba();
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/cast.hpp

@@ -0,0 +1,52 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2009-09-09 05:10:29 +1000 (Wed, 09 Sep 2009) $ by $Author: schulte $
+ *     $Revision: 9692 $
+ *
+ *  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 Support {
+
+  /// Cast \a p into pointer of type \a T
+  template<class T>
+  T ptr_cast(void* p);
+
+  template<class T>
+  forceinline T
+  ptr_cast(void* p) {
+    return static_cast<T>(p);
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/config.hpp.in

@@ -0,0 +1,109 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2008
+ *
+ *  Last modified:
+ *     $Date: 2012-02-22 16:04:20 +1100 (Wed, 22 Feb 2012) $ by $Author: tack $
+ *     $Revision: 12537 $
+ *
+ *  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.
+ *
+ */
+
+/* Whether to include audit code */
+#undef GECODE_AUDIT
+
+/* User-defined prefix of dll names */
+#undef GECODE_DLL_USERPREFIX
+
+/* User-defined suffix of dll names */
+#undef GECODE_DLL_USERSUFFIX
+
+/* Supported version of FlatZinc */
+#undef GECODE_FLATZINC_VERSION
+
+/* Whether gcc understands visibility attributes */
+#undef GECODE_GCC_HAS_CLASS_VISIBILITY
+
+/* Whether to compile boost dependent parts */
+#undef GECODE_HAS_BOOST
+
+/* whether __builtin_ffsl is available */
+#undef GECODE_HAS_BUILTIN_FFSL
+
+/* Whether Gist is available */
+#undef GECODE_HAS_GIST
+
+/* Whether GNU hash_map is available */
+#undef GECODE_HAS_GNU_HASH_MAP
+
+/* Whether to build INT variables */
+#undef GECODE_HAS_INT_VARS
+
+/* Whether we have mtrace for memory leak debugging */
+#undef GECODE_HAS_MTRACE
+
+/* Whether Qt is available */
+#undef GECODE_HAS_QT
+
+/* Whether to build SET variables */
+#undef GECODE_HAS_SET_VARS
+
+/* Whether unistd.h is available */
+#undef GECODE_HAS_UNISTD_H
+
+/* Gecode version */
+#undef GECODE_LIBRARY_VERSION
+
+/* Heap memory alignment */
+#undef GECODE_MEMORY_ALIGNMENT
+
+/* Whether we are compiling static libraries */
+#undef GECODE_STATIC_LIBS
+
+/* Whether we have posix threads */
+#undef GECODE_THREADS_PTHREADS
+
+/* Whether we have windows threads */
+#undef GECODE_THREADS_WINDOWS
+
+/* Use clock() for time-measurement */
+#undef GECODE_USE_CLOCK
+
+/* Use gettimeofday for time-measurement */
+#undef GECODE_USE_GETTIMEOFDAY
+
+/* Gecode version */
+#undef GECODE_VERSION
+
+/* Gecode version */
+#undef GECODE_VERSION_NUMBER
+
+/* How to tell the compiler to really, really inline */
+#undef forceinline
+
+// STATISTICS: support-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/support/dynamic-array.hpp

@@ -0,0 +1,140 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2009-09-09 05:10:29 +1000 (Wed, 09 Sep 2009) $ by $Author: schulte $
+ *     $Revision: 9692 $
+ *
+ *  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 <algorithm>
+
+namespace Gecode { namespace Support {
+
+  /**
+   * \brief Array with arbitrary number of elements
+   *
+   * \ingroup FuncSupport
+   */
+  template<class T, class A>
+  class DynamicArray {
+  private:
+    /// Memory allocator
+    A& a;
+    /// Size of array
+    int n;
+    /// Array elements
+    T*  x;
+    /// Resize to at least \a n + 1 elements
+    void resize(int n);
+  public:
+    /// Initialize with size \a n
+    DynamicArray(A& a0, int n = 32);
+    /// Copy elements from array \a da
+    DynamicArray(const DynamicArray<T,A>& da);
+    /// Release memory
+    ~DynamicArray(void);
+
+    /// Assign array (copy elements from \a a)
+    const DynamicArray<T,A>& operator =(const DynamicArray<T,A>& da);
+
+    /// Return element at position \a i (possibly resize)
+    T& operator [](int i);
+    /// Return element at position \a i
+    const T& operator [](int) const;
+
+    /// Cast in to pointer of type \a T
+    operator T*(void);
+  };
+
+
+  template<class T, class A>
+  forceinline
+  DynamicArray<T,A>::DynamicArray(A& a0, int n0)
+    : a(a0), n(n0), x(a.template alloc<T>(n)) {}
+
+  template<class T, class A>
+  forceinline
+  DynamicArray<T,A>::DynamicArray(const DynamicArray<T,A>& da)
+    : a(da.a), n(da.n), x(a.template alloc<T>(n)) {
+    (void) heap.copy<T>(x,da.x,n);
+  }
+
+  template<class T, class A>
+  forceinline
+  DynamicArray<T,A>::~DynamicArray(void) {
+    a.free(x,n);
+  }
+
+  template<class T, class A>
+  forceinline const DynamicArray<T,A>&
+  DynamicArray<T,A>::operator =(const DynamicArray<T,A>& da) {
+    if (this != &da) {
+      if (n < da.n) {
+        a.free(x,n); n = da.n; x = a.template alloc<T>(n);
+      }
+      (void) heap.copy(x,da.x,n);
+    }
+    return *this;
+  }
+
+  template<class T, class A>
+  void
+  DynamicArray<T,A>::resize(int i) {
+    int m = std::max(i+1, (3*n)/2);
+    x = a.realloc(x,n,m);
+    n = m;
+  }
+
+  template<class T, class A>
+  forceinline T&
+  DynamicArray<T,A>::operator [](int i) {
+    if (i >= n) resize(i);
+    assert(n > i);
+    return x[i];
+  }
+
+  template<class T, class A>
+  forceinline const T&
+  DynamicArray<T,A>::operator [](int i) const {
+    assert(n > i);
+    return x[i];
+  }
+
+  template<class T, class A>
+  forceinline
+  DynamicArray<T,A>::operator T*(void) {
+    return x;
+  }
+
+}}
+
+// STATISTICS: support-any