dekker.one
fork
Configure Feed
Select the types of activity you want to include in your feed.
this repo has no description
fork
Configure Feed
Select the types of activity you want to include in your feed.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Guido Tack <tack@gecode.org>
5 *
6 * Copyright:
7 * Guido Tack, 2006
8 *
9 * This file is part of Gecode, the generic constraint
10 * development environment:
11 * http://www.gecode.org
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining
14 * a copy of this software and associated documentation files (the
15 * "Software"), to deal in the Software without restriction, including
16 * without limitation the rights to use, copy, modify, merge, publish,
17 * distribute, sublicense, and/or sell copies of the Software, and to
18 * permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be
22 * included in all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 *
32 */
33
34namespace Gecode { namespace Gist {
35
36 forceinline void
37 SpaceNode::setFlag(int flag, bool value) {
38 if (value)
39 nstatus |= 1<<(flag-1);
40 else
41 nstatus &= ~(1<<(flag-1));
42 }
43
44 forceinline bool
45 SpaceNode::getFlag(int flag) const {
46 return (nstatus & (1<<(flag-1))) != 0;
47 }
48
49 forceinline void
50 SpaceNode::setHasOpenChildren(bool b) {
51 setFlag(HASOPENCHILDREN, b);
52 }
53
54 forceinline void
55 SpaceNode::setHasFailedChildren(bool b) {
56 setFlag(HASFAILEDCHILDREN, b);
57 }
58
59 forceinline void
60 SpaceNode::setHasSolvedChildren(bool b) {
61 setFlag(HASSOLVEDCHILDREN, b);
62 }
63
64 forceinline void
65 SpaceNode::setStatus(NodeStatus s) {
66 nstatus &= ~( STATUSMASK );
67 nstatus |= s << 20;
68 }
69
70 forceinline NodeStatus
71 SpaceNode::getStatus(void) const {
72 return static_cast<NodeStatus>((nstatus & STATUSMASK) >> 20);
73 }
74
75 forceinline void
76 SpaceNode::setDistance(unsigned int d) {
77 if (d > MAXDISTANCE)
78 d = MAXDISTANCE;
79 nstatus &= ~( DISTANCEMASK );
80 nstatus |= d;
81 }
82
83 forceinline unsigned int
84 SpaceNode::getDistance(void) const {
85 return nstatus & DISTANCEMASK;
86 }
87
88 forceinline
89 SpaceNode::SpaceNode(int p)
90 : Node(p), copy(nullptr), nstatus(0) {
91 choice = nullptr;
92 setStatus(UNDETERMINED);
93 setHasSolvedChildren(false);
94 setHasFailedChildren(false);
95 }
96
97 forceinline Space*
98 SpaceNode::getSpace(NodeAllocator& na,
99 BestNode* curBest, int c_d, int a_d) {
100 acquireSpace(na,curBest,c_d,a_d);
101 Space* ret;
102 if (Support::marked(copy)) {
103 ret = static_cast<Space*>(Support::unmark(copy));
104 copy = nullptr;
105 } else {
106 ret = copy->clone();
107 }
108 return ret;
109 }
110
111 forceinline const Space*
112 SpaceNode::getWorkingSpace(void) const {
113 assert(copy != nullptr);
114 if (Support::marked(copy))
115 return static_cast<Space*>(Support::unmark(copy));
116 return copy;
117 }
118
119 forceinline void
120 SpaceNode::purge(const NodeAllocator& na) {
121 if (!isRoot() && (getStatus() != SOLVED || !na.bab())) {
122 // only delete copies from solutions if we are not in BAB
123 if (Support::marked(copy))
124 delete static_cast<Space*>(Support::unmark(copy));
125 else
126 delete copy;
127 copy = nullptr;
128 }
129 }
130
131
132 forceinline bool
133 SpaceNode::isCurrentBest(BestNode* curBest) {
134 return curBest != nullptr && curBest->s == this;
135 }
136
137 forceinline bool
138 SpaceNode::isOpen(void) {
139 return ((getStatus() == UNDETERMINED) ||
140 getFlag(HASOPENCHILDREN));
141 }
142
143 forceinline bool
144 SpaceNode::hasFailedChildren(void) {
145 return getFlag(HASFAILEDCHILDREN);
146 }
147
148 forceinline bool
149 SpaceNode::hasSolvedChildren(void) {
150 return getFlag(HASSOLVEDCHILDREN);
151 }
152
153 forceinline bool
154 SpaceNode::hasOpenChildren(void) {
155 return getFlag(HASOPENCHILDREN);
156 }
157
158 forceinline bool
159 SpaceNode::hasCopy(void) {
160 return copy != nullptr;
161 }
162
163 forceinline bool
164 SpaceNode::hasWorkingSpace(void) {
165 return copy != nullptr && Support::marked(copy);
166 }
167
168 forceinline int
169 SpaceNode::getAlternative(const NodeAllocator& na) const {
170 SpaceNode* p = getParent(na);
171 if (p == nullptr)
172 return -1;
173 for (int i=static_cast<int>(p->getNumberOfChildren()); i--;)
174 if (p->getChild(na,i) == this)
175 return i;
176 GECODE_NEVER;
177 return -1;
178 }
179
180 forceinline const Choice*
181 SpaceNode::getChoice(void) {
182 return choice;
183 }
184
185}}
186
187// STATISTICS: gist-any