gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/support/block-allocator.icc

@@ -0,0 +1,159 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:32:29 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7337 $
+ *
+ *  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, int blocksize = 512>
+  class BlockAllocator {
+  private:
+    /// 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(void);
+    /// Free all allocated blocks
+    ~BlockAllocator(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, int blocksize = 512>
+  class BlockClient {
+  public:
+    /// Allocate memory from block allocator \a ba
+    static void* operator new(size_t s, BlockAllocator<T,blocksize>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*, BlockAllocator<T,blocksize>& ba);
+    /// Noop (memory freed only when block allocator deleted)
+    static void  operator delete(void*);
+  };
+
+
+
+  template <class T, int blocksize>
+  forceinline
+  BlockAllocator<T,blocksize>::BlockAllocator(void) {
+    b = static_cast<Block*>(Memory::malloc(sizeof(Block)));
+    b->next = NULL;
+    n       = &b->b[blocksize];
+    _size = sizeof(Block);
+  }
+
+  template <class T, int blocksize>
+  forceinline
+  BlockAllocator<T,blocksize>::~BlockAllocator(void) {
+    while (b != NULL) {
+      Block* f = b; b = b->next;
+      Memory::free(f);
+    }
+  }
+
+  template <class T, int blocksize>
+  forceinline T*
+  BlockAllocator<T,blocksize>::operator()(void) {
+    T* t = --n;
+    if (t == &b->b[0])
+      allocate();
+    return t;
+  }
+
+  template <class T, int blocksize>
+  void
+  BlockAllocator<T,blocksize>::allocate(void) {
+    // Allocate another block
+    Block* nb = static_cast<Block*>(Memory::malloc(sizeof(Block)));
+    nb->next = b; b = nb;
+    n = &nb->b[blocksize];
+    _size += sizeof(Block);
+  }
+
+  template <class T, int blocksize>
+  forceinline size_t
+  BlockAllocator<T,blocksize>::size(void) const {
+    return _size;
+  }
+
+
+
+  template <class T, int blocksize>
+  forceinline void
+  BlockClient<T,blocksize>::operator delete(void*,
+                                            BlockAllocator<T,blocksize>&) {
+  }
+  template <class T, int blocksize>
+  forceinline void
+  BlockClient<T,blocksize>::operator delete(void*) {
+  }
+  template <class T, int blocksize>
+  forceinline void*
+  BlockClient<T,blocksize>::operator new(size_t,
+                                         BlockAllocator<T,blocksize>& ba) {
+    return ba();
+  }
+
+}}
+
+// STATISTICS: support-any

data/ext/gecode-2.2.0/gecode/support/config.icc.in

@@ -0,0 +1,83 @@
+/*
+ *  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-07-11 10:10:11 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7310 $
+ *
+ *  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.
+ *
+ */
+
+/* How to tell the compiler to really, really inline */
+#undef forceinline
+
+/* Heap memory alignment */
+#undef GECODE_MEMORY_ALIGNMENT
+
+/* Whether integer variables are built */
+#undef GECODE_HAS_INT_VARS
+
+/* Whether set variables are built */
+#undef GECODE_HAS_SET_VARS
+
+/* Whether bdd variables are built */
+#undef GECODE_HAS_CPLTSET_VARS
+
+/* Whether we are compiling static libraries */
+#undef GECODE_STATIC_LIBS
+
+/* Whether we have mtrace for memory leak debugging*/
+#undef GECODE_HAS_MTRACE
+
+/* Whether gcc understands visibility attributes */
+#undef GECODE_GCC_HAS_CLASS_VISIBILITY
+
+/* Whether to include audit code */
+#undef GECODE_AUDIT
+
+/* Whether serialization support is built */
+#undef GECODE_HAS_SERIALIZATION
+
+/* Whether dds support is built */
+#undef GECODE_HAS_DDS
+
+/* Whether to compile boost dependent parts */
+#undef GECODE_HAS_BOOST
+
+/* Whether Qt is available */
+#undef GECODE_HAS_QT
+
+/* Whether Gist is available */
+#undef GECODE_HAS_GIST
+
+// STATISTICS: support-any

data/ext/gecode-2.2.0/gecode/support/sentinel-stack.icc

@@ -0,0 +1,138 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 11:13:44 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7358 $
+ *
+ *  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 A simple stack that uses a sentinel element
+   *
+   * The sentinel element is used to mark the bottom of the stack
+   * and must be given at compile time.
+   *
+   * Note that the stack does not provide memory management. As it
+   * is so simple it is ment to be used with automatically allocated
+   * memory.
+   *
+   * \ingroup FuncSupport
+   */
+  template<class T>
+  class SentinelStack {
+  private:
+#ifndef NDEBUG
+    unsigned int size;
+    T* bos;
+#endif
+    const T sentinel;
+    T* tos;
+  public:
+    /// Create stack that uses the memory area \a p of size \a n and sentinel \a s
+    SentinelStack(T* p, T s, int n);
+    /// Check whether stack is empty
+    bool empty(void) const;
+    /// Return topmost element
+    T top(void) const;
+    /// Return element that has just been popped
+    T last(void) const;
+    /// Return topmost element and pop it
+    T pop(void);
+    /// Push element
+    void push(T x);
+  };
+
+  template<class T>
+  forceinline
+  SentinelStack<T>::SentinelStack(T* p, T s, int n) 
+    : 
+#ifndef NDEBUG
+    size(n), bos(p),
+#endif
+    sentinel(s), tos(p) {
+    (void) n;
+    *(tos++) = sentinel;
+  }
+  template<class T>
+  forceinline bool
+  SentinelStack<T>::empty(void) const {
+    return *(tos-1) == sentinel;
+  }
+  template<class T>
+  forceinline T
+  SentinelStack<T>::top(void) const {
+    assert(*(tos-1) != sentinel);
+    return *(tos-1);
+  }
+  template<class T>
+  forceinline T
+  SentinelStack<T>::last(void) const {
+    return *tos;
+  }
+  template<class T>
+  forceinline T
+  SentinelStack<T>::pop(void) {
+#ifndef NDEBUG
+    assert(tos-bos > 1);
+#endif
+    return *(--tos);
+  }
+  template<class T>
+  forceinline void
+  SentinelStack<T>::push(T x) {
+    assert(x != sentinel);
+#ifndef NDEBUG
+    assert(tos-bos < size+1);
+#endif
+    *(tos++) = x;
+  }
+
+}}
+
+/**
+ * \def GECODE_AUTOSTACK(T,S,X,N)
+ * \brief Simple sentinel stack using automatic memory
+ *
+ * Allocates automatic memory for a sentinel stack \a X with 
+ * \a N objects of type \a T with sentinel \a S.
+ *
+ * As soon as the current scope is left, the memory is freed.
+ *
+ */
+
+#define GECODE_AUTOSTACK(T,S,X,N)                                     \
+  int __GECODE__AS__ ## X ## __LINE__ ## n = (N); \
+  GECODE_AUTOARRAY(T,__GECODE__AS__ ## X ## __LINE__,(__GECODE__AS__ ## X ## __LINE__ ## n) + 1);               \
+  Gecode::Support::SentinelStack<T> X(__GECODE__AS__ ## X ## __LINE__,(S),__GECODE__AS__ ## X ## __LINE__ ## n);
+// STATISTICS: support-any