00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #include <cstring>
00040
00041 namespace Gecode {
00042
00043 namespace Driver {
00044
00045
00046
00047
00048 inline
00049 StringValueOption::StringValueOption(const char* o, const char* e,
00050 const char* v)
00051 : BaseOption(o,e), cur(strdup(v)) {}
00052 inline void
00053 StringValueOption::value(const char* v) {
00054 strdel(cur);
00055 cur = strdup(v);
00056 }
00057 inline const char*
00058 StringValueOption::value(void) const {
00059 return cur;
00060 }
00061
00062
00063
00064
00065
00066 inline
00067 StringOption::StringOption(const char* o, const char* e, int v)
00068 : BaseOption(o,e), cur(v), fst(NULL), lst(NULL) {}
00069 inline void
00070 StringOption::value(int v) {
00071 cur = v;
00072 }
00073 inline int
00074 StringOption::value(void) const {
00075 return cur;
00076 }
00077
00078
00079
00080
00081
00082 inline
00083 IntOption::IntOption(const char* o, const char* e, int v)
00084 : BaseOption(o,e), cur(v) {}
00085 inline void
00086 IntOption::value(int v) {
00087 cur = v;
00088 }
00089 inline int
00090 IntOption::value(void) const {
00091 return cur;
00092 }
00093
00094
00095
00096
00097
00098 inline
00099 UnsignedIntOption::UnsignedIntOption(const char* o, const char* e,
00100 unsigned int v)
00101 : BaseOption(o,e), cur(v) {}
00102 inline void
00103 UnsignedIntOption::value(unsigned int v) {
00104 cur = v;
00105 }
00106 inline unsigned int
00107 UnsignedIntOption::value(void) const {
00108 return cur;
00109 }
00110
00111
00112
00113
00114
00115 inline
00116 DoubleOption::DoubleOption(const char* o, const char* e,
00117 unsigned int v)
00118 : BaseOption(o,e), cur(v) {}
00119 inline void
00120 DoubleOption::value(double v) {
00121 cur = v;
00122 }
00123 inline double
00124 DoubleOption::value(void) const {
00125 return cur;
00126 }
00127
00128
00129
00130
00131
00132 inline
00133 BoolOption::BoolOption(const char* o, const char* e)
00134 : BaseOption(o,e), cur(false) {}
00135 inline void
00136 BoolOption::value(bool v) {
00137 cur = v;
00138 }
00139 inline bool
00140 BoolOption::value(void) const {
00141 return cur;
00142 }
00143
00144
00145 }
00146
00147
00148
00149
00150
00151 inline void
00152 BaseOptions::add(Driver::BaseOption& o) {
00153 o.next = NULL;
00154 if (fst == NULL) {
00155 fst=&o;
00156 } else {
00157 lst->next=&o;
00158 }
00159 lst=&o;
00160 }
00161 inline const char*
00162 BaseOptions::name(void) const {
00163 return _name;
00164 }
00165
00166
00167
00168
00169
00170
00171
00172 inline void
00173 Options::model(int v) {
00174 _model.value(v);
00175 }
00176 inline void
00177 Options::model(int v, const char* o, const char* h) {
00178 _model.add(v,o,h);
00179 }
00180 inline int
00181 Options::model(void) const {
00182 return _model.value();
00183 }
00184
00185 inline void
00186 Options::symmetry(int v) {
00187 _symmetry.value(v);
00188 }
00189 inline void
00190 Options::symmetry(int v, const char* o, const char* h) {
00191 _symmetry.add(v,o,h);
00192 }
00193 inline int
00194 Options::symmetry(void) const {
00195 return _symmetry.value();
00196 }
00197
00198 inline void
00199 Options::propagation(int v) {
00200 _propagation.value(v);
00201 }
00202 inline void
00203 Options::propagation(int v, const char* o, const char* h) {
00204 _propagation.add(v,o,h);
00205 }
00206 inline int
00207 Options::propagation(void) const {
00208 return _propagation.value();
00209 }
00210
00211 inline void
00212 Options::icl(IntConLevel i) {
00213 _icl.value(i);
00214 }
00215 inline IntConLevel
00216 Options::icl(void) const {
00217 return static_cast<IntConLevel>(_icl.value());
00218 }
00219
00220 inline void
00221 Options::branching(int v) {
00222 _branching.value(v);
00223 }
00224 inline void
00225 Options::branching(int v, const char* o, const char* h) {
00226 _branching.add(v,o,h);
00227 }
00228 inline int
00229 Options::branching(void) const {
00230 return _branching.value();
00231 }
00232
00233
00234
00235
00236
00237 inline void
00238 Options::search(int v) {
00239 _search.value(v);
00240 }
00241 inline void
00242 Options::search(int v, const char* o, const char* h) {
00243 _search.add(v,o,h);
00244 }
00245 inline int
00246 Options::search(void) const {
00247 return _search.value();
00248 }
00249
00250 inline void
00251 Options::solutions(unsigned int n) {
00252 _solutions.value(n);
00253 }
00254 inline unsigned int
00255 Options::solutions(void) const {
00256 return _solutions.value();
00257 }
00258
00259 inline void
00260 Options::threads(double n) {
00261 _threads.value(n);
00262 }
00263 inline double
00264 Options::threads(void) const {
00265 return _threads.value();
00266 }
00267
00268 inline void
00269 Options::c_d(unsigned int d) {
00270 _c_d.value(d);
00271 }
00272 inline unsigned int
00273 Options::c_d(void) const {
00274 return _c_d.value();
00275 }
00276
00277 inline void
00278 Options::a_d(unsigned int d) {
00279 _a_d.value(d);
00280 }
00281 inline unsigned int
00282 Options::a_d(void) const {
00283 return _a_d.value();
00284 }
00285
00286 inline void
00287 Options::node(unsigned int n) {
00288 _node.value(n);
00289 }
00290 inline unsigned int
00291 Options::node(void) const {
00292 return _node.value();
00293 }
00294
00295 inline void
00296 Options::fail(unsigned int n) {
00297 _fail.value(n);
00298 }
00299 inline unsigned int
00300 Options::fail(void) const {
00301 return _fail.value();
00302 }
00303
00304 inline void
00305 Options::time(unsigned int t) {
00306 _time.value(t);
00307 }
00308 inline unsigned int
00309 Options::time(void) const {
00310 return _time.value();
00311 }
00312
00313
00314
00315
00316
00317
00318
00319 inline void
00320 Options::mode(ScriptMode sm) {
00321 _mode.value(sm);
00322 }
00323 inline ScriptMode
00324 Options::mode(void) const {
00325 return static_cast<ScriptMode>(_mode.value());
00326 }
00327
00328 inline void
00329 Options::iterations(unsigned int i) {
00330 _iterations.value(i);
00331 }
00332 inline unsigned int
00333 Options::iterations(void) const {
00334 return _iterations.value();
00335 }
00336
00337 inline void
00338 Options::samples(unsigned int s) {
00339 _samples.value(s);
00340 }
00341 inline unsigned int
00342 Options::samples(void) const {
00343 return _samples.value();
00344 }
00345
00346 #ifdef GECODE_HAS_GIST
00347 forceinline
00348 Options::_I::_I(void) : _click(heap,1), n_click(0),
00349 _solution(heap,1), n_solution(0), _move(heap,1), n_move(0),
00350 _compare(heap,1), n_compare(0) {}
00351
00352 forceinline void
00353 Options::_I::click(Gist::Inspector* i) {
00354 _click[n_click++] = i;
00355 }
00356 forceinline void
00357 Options::_I::solution(Gist::Inspector* i) {
00358 _solution[n_solution++] = i;
00359 }
00360 forceinline void
00361 Options::_I::move(Gist::Inspector* i) {
00362 _move[n_move++] = i;
00363 }
00364 forceinline void
00365 Options::_I::compare(Gist::Comparator* i) {
00366 _compare[n_compare++] = i;
00367 }
00368 forceinline Gist::Inspector*
00369 Options::_I::click(unsigned int i) const {
00370 return (i < n_click) ? _click[i] : NULL;
00371 }
00372 forceinline Gist::Inspector*
00373 Options::_I::solution(unsigned int i) const {
00374 return (i < n_solution) ? _solution[i] : NULL;
00375 }
00376 forceinline Gist::Inspector*
00377 Options::_I::move(unsigned int i) const {
00378 return (i < n_move) ? _move[i] : NULL;
00379 }
00380 forceinline Gist::Comparator*
00381 Options::_I::compare(unsigned int i) const {
00382 return (i < n_compare) ? _compare[i] : NULL;
00383 }
00384 #endif
00385
00386
00387
00388
00389
00390 inline void
00391 SizeOptions::size(unsigned int s) {
00392 _size = s;
00393 }
00394 inline unsigned int
00395 SizeOptions::size(void) const {
00396 return _size;
00397 }
00398
00399 }
00400
00401