dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/visualnode.hh

@@ -0,0 +1,237 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-09-03 19:25:49 +1000 (Fri, 03 Sep 2010) $ by $Author: tack $
+ *     $Revision: 11387 $
+ *
+ *  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_GIST_VISUALNODE_HH
+#define GECODE_GIST_VISUALNODE_HH
+
+#include <gecode/gist/spacenode.hh>
+#include <gecode/kernel.hh>
+#include <string>
+
+namespace Gecode { namespace Gist {
+
+  /// \brief %Layout parameters
+  class Layout {
+  public:
+    static const int dist_y = 38;
+    static const int extent = 20;
+    static const int minimalSeparation = 10;
+  };
+
+  /// \brief Bounding box
+  class BoundingBox {
+  public:
+    /// Left coordinate
+    int left;
+    /// Right coordinate
+    int right;
+    /// Default constructor
+    BoundingBox(void) {}
+  };
+
+  /// \brief %Extent representing shape of a tree at one depth level
+  class Extent {
+  public:
+    /// Left extent
+    int l;
+    /// Right extent
+    int r;
+    /// Default constructor
+    Extent(void);
+    /// Construct with \a l0 and \a r0
+    Extent(int l0, int r0);
+    /// Construct with width \a width
+    Extent(int width);
+
+    /// Extend extent by \a deltaL and \a deltaR
+    void extend(int deltaL, int deltaR);
+    /// Move extent by \a delta
+    void move(int delta);
+  };
+
+  /// \brief The shape of a subtree
+  class Shape {
+  private:
+    /// The depth of this shape
+    int _depth;
+    /// The bounding box of this shape
+    BoundingBox bb;
+    /// The shape is an array of extents, one for each depth level
+    Extent shape[1];
+    /// Copy construtor
+    Shape(const Shape&);
+    /// Assignment operator
+    Shape& operator =(const Shape&);
+    /// Constructor
+    Shape(void);
+  public:
+    /// Construct shape of depth \a d
+    static Shape* allocate(int d);
+    // Destruct
+    static void deallocate(Shape*);
+
+    /// Static shape for leaf nodes
+    static Shape* leaf;
+    /// Static shape for hidden nodes
+    static Shape* hidden;
+
+    /// Return depth of the shape
+    int depth(void) const;
+    /// Set depth of the shape to \a d (must be smaller than original depth)
+    void setDepth(int d);
+    /// Compute bounding box
+    void computeBoundingBox(void);
+    /// Return extent at depth \a i
+    const Extent& operator [](int i) const;
+    /// Return extent at depth \a i
+    Extent& operator [](int i);
+    /// Return if extent exists at \a depth, if yes return it in \a extent
+    bool getExtentAtDepth(int depth, Extent& extent);
+    /// Return bounding box
+    const BoundingBox& getBoundingBox(void) const;
+  };
+
+  /// \brief %Node class that supports visual layout
+  class VisualNode : public SpaceNode {
+  protected:
+    /// Flags for VisualNodes
+    enum VisualNodeFlags {
+      DIRTY = SpaceNode::LASTBIT+1,
+      CHILDRENLAYOUTDONE,
+      HIDDEN,
+      MARKED,
+      ONPATH,
+      BOOKMARKED
+    };
+
+    /// Relative offset from the parent node
+    int offset;
+    /// Shape of this node
+    Shape* shape;
+
+    /// Check if the \a x at depth \a depth lies in this subtree
+    bool containsCoordinateAtDepth(int x, int depth);
+  public:
+    /// Construct with parent \a p
+    VisualNode(int p);
+    /// Constructor for root node from \a root and \a b
+    VisualNode(Space* root);
+
+    /// Return if node is hidden
+    bool isHidden(void);
+    /// Set hidden state to \a h
+    void setHidden(bool h);
+    /// Set stop state to \a h
+    void setStop(bool h);
+    /// Mark all nodes up the path to the parent as dirty
+    void dirtyUp(const NodeAllocator& na);
+    /// Compute layout for the subtree of this node
+    void layout(const NodeAllocator& na);
+    /// Return offset off this node from its parent
+    int getOffset(void);
+    /// Set offset of this node, relative to its parent
+    void setOffset(int n);
+    /// Return whether node is marked as dirty
+    bool isDirty(void);
+    /// Mark node as dirty
+    void setDirty(bool d);
+    /// Return whether the layout of the node's children has been completed
+    bool childrenLayoutIsDone(void);
+    /// Mark node whether the layout of the node's children has been completed
+    void setChildrenLayoutDone(bool d);
+    /// Return whether node is marked
+    bool isMarked(void);
+    /// Set mark of this node
+    void setMarked(bool m);
+    /// Return whether node is bookmarked
+    bool isBookmarked(void);
+    /// Set bookmark of this node
+    void setBookmarked(bool m);
+    /// Set all nodes from the node to the root to be on the path
+    void pathUp(const NodeAllocator& na);
+    /// Set all nodes from the node to the root not to be on the path
+    void unPathUp(const NodeAllocator& na);
+    /// Return whether node is on the path
+    bool isOnPath(void);
+    /// Return the alternative of the child that is on the path (-1 if none)
+    int getPathAlternative(const NodeAllocator& na);
+    /// Set whether node is on the path
+    void setOnPath(bool onPath0);
+
+    /// Toggle whether this node is hidden
+    void toggleHidden(const NodeAllocator& na);
+    /// Hide all failed subtrees of this node
+    void hideFailed(const NodeAllocator& na, bool onlyDirty=false);
+    /// Unhide all nodes in the subtree of this node
+    void unhideAll(const NodeAllocator& na);
+    /// Do not stop at this node
+    void toggleStop(const NodeAllocator& na);
+    /// Do not stop at any stop node in the subtree of this node
+    void unstopAll(const NodeAllocator& na);
+
+    /// Return the shape of this node
+    Shape* getShape(void);
+    /// Set the shape of this node
+    void setShape(Shape* s);
+    /// Compute the shape according to the shapes of the children
+    void computeShape(const NodeAllocator& na, VisualNode* root);
+    /// Return the bounding box
+    BoundingBox getBoundingBox(void);
+    /// Signal that the status has changed
+    void changedStatus(const NodeAllocator& na);
+    /// Find a node in this subtree at coordinates \a x, \a y
+    VisualNode* findNode(const NodeAllocator& na, int x, int y);
+
+    /// Return string that is used as a tool tip
+    std::string toolTip(BestNode* curBest, int c_d, int a_d);
+
+    /// Return size information
+    size_t size(void) const;
+    
+    /// Free allocated memory
+    void dispose(void);
+  };
+
+}}
+
+#include <gecode/gist/node.hpp>
+#include <gecode/gist/spacenode.hpp>
+#include <gecode/gist/visualnode.hpp>
+
+#endif
+
+// STATISTICS: gist-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/visualnode.hpp

@@ -0,0 +1,220 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-09-03 19:25:49 +1000 (Fri, 03 Sep 2010) $ by $Author: tack $
+ *     $Revision: 11387 $
+ *
+ *  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 Gist {
+
+  forceinline
+  Extent::Extent(void) : l(-1), r(-1) {}
+
+  forceinline
+  Extent::Extent(int l0, int r0) : l(l0), r(r0) {}
+
+  inline
+  Extent::Extent(int width) {
+    int halfWidth = width / 2;
+    l = 0 - halfWidth;
+    r = 0 + halfWidth;
+  }
+
+  inline void
+  Extent::extend(int deltaL, int deltaR) {
+    l += deltaL; r += deltaR;
+  }
+
+  inline void
+  Extent::move(int delta) {
+    l += delta; r += delta;
+  }
+
+  forceinline int
+  Shape::depth(void) const { return _depth+1; }
+
+  forceinline void
+  Shape::setDepth(int d) {
+    assert(d <= _depth+1);
+    _depth = d-1;
+  }
+
+  forceinline const Extent&
+  Shape::operator [](int i) const {
+    assert(i < _depth+1);
+    return i == 0 ? leaf->shape[0] : shape[i-1];
+  }
+
+  forceinline Extent&
+  Shape::operator [](int i) {
+    assert(i < _depth+1);
+    return i == 0 ? leaf->shape[0] : shape[i-1];
+  }
+
+  inline Shape*
+  Shape::allocate(int d) {
+    Shape* ret;
+    if (d == 1) {
+      ret = static_cast<Shape*>(heap.ralloc(sizeof(Shape)));
+      ret->shape[0] = Extent(Layout::extent);      
+    } else {
+      ret = static_cast<Shape*>(heap.ralloc(sizeof(Shape) +
+                                            (d-2)*sizeof(Extent)));
+    }
+    ret->_depth = d-1;
+    return ret;
+  }
+
+  forceinline void
+  Shape::deallocate(Shape* shape) {
+    if (shape != hidden && shape != leaf)
+      heap.rfree(shape);
+  }
+
+  forceinline bool
+  Shape::getExtentAtDepth(int d, Extent& extent) {
+    if (d > depth())
+      return false;
+    extent = Extent(0,0);
+    for (int i=0; i <= d; i++) {
+      Extent currentExtent = (*this)[i];
+      extent.l += currentExtent.l;
+      extent.r += currentExtent.r;
+    }
+    return true;
+  }
+
+  forceinline void
+  Shape::computeBoundingBox(void) {
+    int lastLeft = 0;
+    int lastRight = 0;
+    bb.left = 0;
+    bb.right = 0;
+    for (int i=0; i<depth(); i++) {
+      lastLeft = lastLeft + (*this)[i].l;
+      lastRight = lastRight + (*this)[i].r;
+      bb.left = std::min(bb.left,lastLeft);
+      bb.right = std::max(bb.right,lastRight);
+    }
+  }
+
+  forceinline const BoundingBox&
+  Shape::getBoundingBox(void) const {
+    return bb;
+  }
+
+  forceinline bool
+  VisualNode::isHidden(void) {
+    return getFlag(HIDDEN);
+  }
+
+  forceinline void
+  VisualNode::setHidden(bool h) {
+    setFlag(HIDDEN, h);
+  }
+
+  forceinline void
+  VisualNode::setStop(bool h) {
+    if (getStatus() == BRANCH && h)
+      setStatus(STOP);
+    else if (getStatus() == STOP && !h)
+      setStatus(UNSTOP);
+  }
+
+  forceinline int
+  VisualNode::getOffset(void) { return offset; }
+
+  forceinline void
+  VisualNode::setOffset(int n) { offset = n; }
+
+  forceinline bool
+  VisualNode::isDirty(void) {
+    return getFlag(DIRTY);
+  }
+
+  forceinline void
+  VisualNode::setDirty(bool d) {
+    setFlag(DIRTY, d);
+  }
+
+  forceinline bool
+  VisualNode::childrenLayoutIsDone(void) {
+    return getFlag(CHILDRENLAYOUTDONE);
+  }
+
+  forceinline void
+  VisualNode::setChildrenLayoutDone(bool d) {
+    setFlag(CHILDRENLAYOUTDONE, d);
+  }
+
+  forceinline bool
+  VisualNode::isMarked(void) {
+    return getFlag(MARKED);
+  }
+
+  forceinline void
+  VisualNode::setMarked(bool m) {
+    setFlag(MARKED, m);
+  }
+
+  forceinline bool
+  VisualNode::isBookmarked(void) {
+    return getFlag(BOOKMARKED);
+  }
+
+  forceinline void
+  VisualNode::setBookmarked(bool m) {
+    setFlag(BOOKMARKED, m);
+  }
+
+  forceinline bool
+  VisualNode::isOnPath(void) {
+    return getFlag(ONPATH);
+  }
+
+  forceinline void
+  VisualNode::setOnPath(bool b) {
+    setFlag(ONPATH, b);
+  }
+
+  forceinline Shape*
+  VisualNode::getShape(void) {
+    return isHidden() ? Shape::hidden : shape;
+  }
+
+  forceinline BoundingBox
+  VisualNode::getBoundingBox(void) { return getShape()->getBoundingBox(); }
+
+}}
+
+// STATISTICS: gist-any