1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /*                                                                           */
3 /*                  This file is part of the program and library             */
4 /*         SCIP --- Solving Constraint Integer Programs                      */
5 /*                                                                           */
6 /*    Copyright (C) 2002-2021 Konrad-Zuse-Zentrum                            */
7 /*                            fuer Informationstechnik Berlin                */
8 /*                                                                           */
9 /*  SCIP is distributed under the terms of the ZIB Academic License.         */
10 /*                                                                           */
11 /*  You should have received a copy of the ZIB Academic License.             */
12 /*  along with SCIP; see the file COPYING. If not visit scipopt.org.         */
13 /*                                                                           */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file   objconshdlr.cpp
17  * @brief  C++ wrapper for constraint handlers
18  * @author Tobias Achterberg
19  */
20 
21 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
22 
23 #include <cassert>
24 
25 #include "objconshdlr.h"
26 
27 
28 
29 
30 /*
31  * Data structures
32  */
33 
34 /** constraint handler data */
35 struct SCIP_ConshdlrData
36 {
37    scip::ObjConshdlr*    objconshdlr;        /**< constraint handler object */
38    SCIP_Bool             deleteobject;       /**< should the constraint handler object be deleted when conshdlr is freed? */
39 };
40 
41 
42 
43 
44 /*
45  * Callback methods of constraint handler
46  */
47 
48 extern "C"
49 {
50 
51 /** copy method for constraint handler plugins (called when SCIP copies plugins) */
52 static
SCIP_DECL_CONSHDLRCOPY(conshdlrCopyObj)53 SCIP_DECL_CONSHDLRCOPY(conshdlrCopyObj)
54 {  /*lint --e{715}*/
55    SCIP_CONSHDLRDATA* conshdlrdata;
56 
57    assert(scip != NULL);
58 
59    conshdlrdata = SCIPconshdlrGetData(conshdlr);
60    assert(conshdlrdata != NULL);
61    assert(conshdlrdata->objconshdlr != NULL);
62    assert(conshdlrdata->objconshdlr->scip_ != scip);
63 
64    if( conshdlrdata->objconshdlr->iscloneable() )
65    {
66       scip::ObjConshdlr* newobjconshdlr;
67       newobjconshdlr = dynamic_cast<scip::ObjConshdlr*> (conshdlrdata->objconshdlr->clone(scip, valid));
68 
69       /* call include method of constraint handler object */
70       SCIP_CALL( SCIPincludeObjConshdlr(scip, newobjconshdlr, TRUE) );
71    }
72 
73    return SCIP_OKAY;
74 }
75 
76 /** destructor of constraint handler to free user data (called when SCIP is exiting) */
77 static
SCIP_DECL_CONSFREE(consFreeObj)78 SCIP_DECL_CONSFREE(consFreeObj)
79 {  /*lint --e{715}*/
80    SCIP_CONSHDLRDATA* conshdlrdata;
81 
82    conshdlrdata = SCIPconshdlrGetData(conshdlr);
83    assert(conshdlrdata != NULL);
84    assert(conshdlrdata->objconshdlr != NULL);
85    assert(conshdlrdata->objconshdlr->scip_ == scip);
86 
87    /* call virtual method of conshdlr object */
88    SCIP_CALL( conshdlrdata->objconshdlr->scip_free(scip, conshdlr) );
89 
90    /* free conshdlr object */
91    if( conshdlrdata->deleteobject )
92       delete conshdlrdata->objconshdlr;
93 
94    /* free conshdlr data */
95    delete conshdlrdata;
96    SCIPconshdlrSetData(conshdlr, NULL); /*lint !e64*/
97 
98    return SCIP_OKAY;
99 }
100 
101 
102 /** initialization method of constraint handler (called after problem was transformed) */
103 static
SCIP_DECL_CONSINIT(consInitObj)104 SCIP_DECL_CONSINIT(consInitObj)
105 {  /*lint --e{715}*/
106    SCIP_CONSHDLRDATA* conshdlrdata;
107 
108    conshdlrdata = SCIPconshdlrGetData(conshdlr);
109    assert(conshdlrdata != NULL);
110    assert(conshdlrdata->objconshdlr != NULL);
111    assert(conshdlrdata->objconshdlr->scip_ == scip);
112 
113    /* call virtual method of conshdlr object */
114    SCIP_CALL( conshdlrdata->objconshdlr->scip_init(scip, conshdlr, conss, nconss) );
115 
116    return SCIP_OKAY;
117 }
118 
119 
120 /** deinitialization method of constraint handler (called before transformed problem is freed) */
121 static
SCIP_DECL_CONSEXIT(consExitObj)122 SCIP_DECL_CONSEXIT(consExitObj)
123 {  /*lint --e{715}*/
124    SCIP_CONSHDLRDATA* conshdlrdata;
125 
126    conshdlrdata = SCIPconshdlrGetData(conshdlr);
127    assert(conshdlrdata != NULL);
128    assert(conshdlrdata->objconshdlr != NULL);
129 
130    /* call virtual method of conshdlr object */
131    SCIP_CALL( conshdlrdata->objconshdlr->scip_exit(scip, conshdlr, conss, nconss) );
132 
133    return SCIP_OKAY;
134 }
135 
136 
137 /** presolving initialization method of constraint handler (called when presolving is about to begin) */
138 static
SCIP_DECL_CONSINITPRE(consInitpreObj)139 SCIP_DECL_CONSINITPRE(consInitpreObj)
140 {  /*lint --e{715}*/
141    SCIP_CONSHDLRDATA* conshdlrdata;
142 
143    conshdlrdata = SCIPconshdlrGetData(conshdlr);
144    assert(conshdlrdata != NULL);
145    assert(conshdlrdata->objconshdlr != NULL);
146 
147    /* call virtual method of conshdlr object */
148    SCIP_CALL( conshdlrdata->objconshdlr->scip_initpre(scip, conshdlr, conss, nconss) );
149 
150    return SCIP_OKAY;
151 }
152 
153 
154 /** presolving deinitialization method of constraint handler (called after presolving has been finished) */
155 static
SCIP_DECL_CONSEXITPRE(consExitpreObj)156 SCIP_DECL_CONSEXITPRE(consExitpreObj)
157 {  /*lint --e{715}*/
158    SCIP_CONSHDLRDATA* conshdlrdata;
159 
160    conshdlrdata = SCIPconshdlrGetData(conshdlr);
161    assert(conshdlrdata != NULL);
162    assert(conshdlrdata->objconshdlr != NULL);
163 
164    /* call virtual method of conshdlr object */
165    SCIP_CALL( conshdlrdata->objconshdlr->scip_exitpre(scip, conshdlr, conss, nconss) );
166 
167    return SCIP_OKAY;
168 }
169 
170 
171 /** solving process initialization method of constraint handler (called when branch and bound process is about to begin) */
172 static
SCIP_DECL_CONSINITSOL(consInitsolObj)173 SCIP_DECL_CONSINITSOL(consInitsolObj)
174 {  /*lint --e{715}*/
175    SCIP_CONSHDLRDATA* conshdlrdata;
176 
177    conshdlrdata = SCIPconshdlrGetData(conshdlr);
178    assert(conshdlrdata != NULL);
179    assert(conshdlrdata->objconshdlr != NULL);
180 
181    /* call virtual method of conshdlr object */
182    SCIP_CALL( conshdlrdata->objconshdlr->scip_initsol(scip, conshdlr, conss, nconss) );
183 
184    return SCIP_OKAY;
185 }
186 
187 
188 /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) */
189 static
SCIP_DECL_CONSEXITSOL(consExitsolObj)190 SCIP_DECL_CONSEXITSOL(consExitsolObj)
191 {  /*lint --e{715}*/
192    SCIP_CONSHDLRDATA* conshdlrdata;
193 
194    conshdlrdata = SCIPconshdlrGetData(conshdlr);
195    assert(conshdlrdata != NULL);
196    assert(conshdlrdata->objconshdlr != NULL);
197 
198    /* call virtual method of conshdlr object */
199    SCIP_CALL( conshdlrdata->objconshdlr->scip_exitsol(scip, conshdlr, conss, nconss, restart) );
200 
201    return SCIP_OKAY;
202 }
203 
204 
205 /** frees specific constraint data */
206 static
SCIP_DECL_CONSDELETE(consDeleteObj)207 SCIP_DECL_CONSDELETE(consDeleteObj)
208 {  /*lint --e{715}*/
209    SCIP_CONSHDLRDATA* conshdlrdata;
210 
211    conshdlrdata = SCIPconshdlrGetData(conshdlr);
212    assert(conshdlrdata != NULL);
213    assert(conshdlrdata->objconshdlr != NULL);
214 
215    /* call virtual method of conshdlr object */
216    SCIP_CALL( conshdlrdata->objconshdlr->scip_delete(scip, conshdlr, cons, consdata) );
217 
218    return SCIP_OKAY;
219 }
220 
221 
222 /** transforms constraint data into data belonging to the transformed problem */
223 static
SCIP_DECL_CONSTRANS(consTransObj)224 SCIP_DECL_CONSTRANS(consTransObj)
225 {  /*lint --e{715}*/
226    SCIP_CONSHDLRDATA* conshdlrdata;
227 
228    conshdlrdata = SCIPconshdlrGetData(conshdlr);
229    assert(conshdlrdata != NULL);
230    assert(conshdlrdata->objconshdlr != NULL);
231 
232    /* call virtual method of conshdlr object */
233    SCIP_CALL( conshdlrdata->objconshdlr->scip_trans(scip, conshdlr, sourcecons, targetcons) );
234 
235    return SCIP_OKAY;
236 }
237 
238 
239 /** LP initialization method of constraint handler */
240 static
SCIP_DECL_CONSINITLP(consInitlpObj)241 SCIP_DECL_CONSINITLP(consInitlpObj)
242 {  /*lint --e{715}*/
243    SCIP_CONSHDLRDATA* conshdlrdata;
244 
245    conshdlrdata = SCIPconshdlrGetData(conshdlr);
246    assert(conshdlrdata != NULL);
247    assert(conshdlrdata->objconshdlr != NULL);
248 
249    /* call virtual method of conshdlr object */
250    SCIP_CALL( conshdlrdata->objconshdlr->scip_initlp(scip, conshdlr, conss, nconss, infeasible) );
251 
252    return SCIP_OKAY;
253 }
254 
255 
256 /** separation method of constraint handler for LP solutions */
257 static
SCIP_DECL_CONSSEPALP(consSepalpObj)258 SCIP_DECL_CONSSEPALP(consSepalpObj)
259 {  /*lint --e{715}*/
260    SCIP_CONSHDLRDATA* conshdlrdata;
261 
262    conshdlrdata = SCIPconshdlrGetData(conshdlr);
263    assert(conshdlrdata != NULL);
264    assert(conshdlrdata->objconshdlr != NULL);
265 
266    /* call virtual method of conshdlr object */
267    SCIP_CALL( conshdlrdata->objconshdlr->scip_sepalp(scip, conshdlr, conss, nconss, nusefulconss, result) );
268 
269    return SCIP_OKAY;
270 }
271 
272 
273 /** separation method of constraint handler for arbitrary primal solutions */
274 static
SCIP_DECL_CONSSEPASOL(consSepasolObj)275 SCIP_DECL_CONSSEPASOL(consSepasolObj)
276 {  /*lint --e{715}*/
277    SCIP_CONSHDLRDATA* conshdlrdata;
278 
279    conshdlrdata = SCIPconshdlrGetData(conshdlr);
280    assert(conshdlrdata != NULL);
281    assert(conshdlrdata->objconshdlr != NULL);
282 
283    /* call virtual method of conshdlr object */
284    SCIP_CALL( conshdlrdata->objconshdlr->scip_sepasol(scip, conshdlr, conss, nconss, nusefulconss, sol, result) );
285 
286    return SCIP_OKAY;
287 }
288 
289 
290 /** constraint enforcing method of constraint handler for LP solutions */
291 static
SCIP_DECL_CONSENFOLP(consEnfolpObj)292 SCIP_DECL_CONSENFOLP(consEnfolpObj)
293 {  /*lint --e{715}*/
294    SCIP_CONSHDLRDATA* conshdlrdata;
295 
296    conshdlrdata = SCIPconshdlrGetData(conshdlr);
297    assert(conshdlrdata != NULL);
298    assert(conshdlrdata->objconshdlr != NULL);
299 
300    /* call virtual method of conshdlr object */
301    SCIP_CALL( conshdlrdata->objconshdlr->scip_enfolp(scip, conshdlr, conss, nconss, nusefulconss, solinfeasible, result) );
302 
303    return SCIP_OKAY;
304 }
305 
306 
307 /** constraint enforcing method of constraint handler for relaxation solutions */
308 static
SCIP_DECL_CONSENFORELAX(consEnforelaxObj)309 SCIP_DECL_CONSENFORELAX(consEnforelaxObj)
310 {  /*lint --e{715}*/
311    SCIP_CONSHDLRDATA* conshdlrdata;
312 
313    conshdlrdata = SCIPconshdlrGetData(conshdlr);
314    assert(conshdlrdata != NULL);
315    assert(conshdlrdata->objconshdlr != NULL);
316 
317    /* call virtual method of conshdlr object */
318    SCIP_CALL( conshdlrdata->objconshdlr->scip_enforelax(scip, sol, conshdlr, conss, nconss, nusefulconss, solinfeasible, result) );
319 
320    return SCIP_OKAY;
321 }
322 
323 
324 /** constraint enforcing method of constraint handler for pseudo solutions */
325 static
SCIP_DECL_CONSENFOPS(consEnfopsObj)326 SCIP_DECL_CONSENFOPS(consEnfopsObj)
327 {  /*lint --e{715}*/
328    SCIP_CONSHDLRDATA* conshdlrdata;
329 
330    conshdlrdata = SCIPconshdlrGetData(conshdlr);
331    assert(conshdlrdata != NULL);
332    assert(conshdlrdata->objconshdlr != NULL);
333 
334    /* call virtual method of conshdlr object */
335    SCIP_CALL( conshdlrdata->objconshdlr->scip_enfops(scip, conshdlr, conss, nconss, nusefulconss,
336          solinfeasible, objinfeasible, result) );
337 
338    return SCIP_OKAY;
339 }
340 
341 
342 /** feasibility check method of constraint handler for primal solutions */
343 static
SCIP_DECL_CONSCHECK(consCheckObj)344 SCIP_DECL_CONSCHECK(consCheckObj)
345 {  /*lint --e{715}*/
346    SCIP_CONSHDLRDATA* conshdlrdata;
347 
348    conshdlrdata = SCIPconshdlrGetData(conshdlr);
349    assert(conshdlrdata != NULL);
350    assert(conshdlrdata->objconshdlr != NULL);
351 
352    /* call virtual method of conshdlr object */
353    SCIP_CALL( conshdlrdata->objconshdlr->scip_check(scip, conshdlr, conss, nconss, sol,
354          checkintegrality, checklprows, printreason, completely, result) );
355 
356    return SCIP_OKAY;
357 }
358 
359 
360 /** domain propagation method of constraint handler */
361 static
SCIP_DECL_CONSPROP(consPropObj)362 SCIP_DECL_CONSPROP(consPropObj)
363 {  /*lint --e{715}*/
364    SCIP_CONSHDLRDATA* conshdlrdata;
365 
366    conshdlrdata = SCIPconshdlrGetData(conshdlr);
367    assert(conshdlrdata != NULL);
368    assert(conshdlrdata->objconshdlr != NULL);
369 
370    /* call virtual method of conshdlr object */
371    SCIP_CALL( conshdlrdata->objconshdlr->scip_prop(scip, conshdlr, conss, nconss, nusefulconss, nmarkedconss, proptiming, result) );
372 
373    return SCIP_OKAY;
374 }
375 
376 
377 /** presolving method of constraint handler */
378 static
SCIP_DECL_CONSPRESOL(consPresolObj)379 SCIP_DECL_CONSPRESOL(consPresolObj)
380 {  /*lint --e{715}*/
381    SCIP_CONSHDLRDATA* conshdlrdata;
382 
383    conshdlrdata = SCIPconshdlrGetData(conshdlr);
384    assert(conshdlrdata != NULL);
385    assert(conshdlrdata->objconshdlr != NULL);
386 
387    /* call virtual method of conshdlr object */
388    SCIP_CALL( conshdlrdata->objconshdlr->scip_presol(scip, conshdlr, conss, nconss, nrounds, presoltiming,
389          nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
390          nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides,
391          nfixedvars, naggrvars, nchgvartypes, nchgbds, naddholes,
392          ndelconss, naddconss, nupgdconss, nchgcoefs, nchgsides, result) );
393 
394    return SCIP_OKAY;
395 }
396 
397 
398 /** propagation conflict resolving method of constraint handler */
399 static
SCIP_DECL_CONSRESPROP(consRespropObj)400 SCIP_DECL_CONSRESPROP(consRespropObj)
401 {  /*lint --e{715}*/
402    SCIP_CONSHDLRDATA* conshdlrdata;
403 
404    conshdlrdata = SCIPconshdlrGetData(conshdlr);
405    assert(conshdlrdata != NULL);
406    assert(conshdlrdata->objconshdlr != NULL);
407 
408    /* call virtual method of conshdlr object */
409    SCIP_CALL( conshdlrdata->objconshdlr->scip_resprop(scip, conshdlr, cons, infervar, inferinfo, boundtype, bdchgidx,
410          relaxedbd, result) );
411 
412    return SCIP_OKAY;
413 }
414 
415 
416 /** variable rounding lock method of constraint handler */
417 static
SCIP_DECL_CONSLOCK(consLockObj)418 SCIP_DECL_CONSLOCK(consLockObj)
419 {  /*lint --e{715}*/
420    SCIP_CONSHDLRDATA* conshdlrdata;
421 
422    conshdlrdata = SCIPconshdlrGetData(conshdlr);
423    assert(conshdlrdata != NULL);
424    assert(conshdlrdata->objconshdlr != NULL);
425 
426    /* call virtual method of conshdlr object */
427    SCIP_CALL( conshdlrdata->objconshdlr->scip_lock(scip, conshdlr, cons, locktype, nlockspos, nlocksneg) );
428 
429    return SCIP_OKAY;
430 }
431 
432 
433 /** constraint activation notification method of constraint handler */
434 static
SCIP_DECL_CONSACTIVE(consActiveObj)435 SCIP_DECL_CONSACTIVE(consActiveObj)
436 {  /*lint --e{715}*/
437    SCIP_CONSHDLRDATA* conshdlrdata;
438 
439    conshdlrdata = SCIPconshdlrGetData(conshdlr);
440    assert(conshdlrdata != NULL);
441    assert(conshdlrdata->objconshdlr != NULL);
442 
443    /* call virtual method of conshdlr object */
444    SCIP_CALL( conshdlrdata->objconshdlr->scip_active(scip, conshdlr, cons) );
445 
446    return SCIP_OKAY;
447 }
448 
449 
450 /** constraint deactivation notification method of constraint handler */
451 static
SCIP_DECL_CONSDEACTIVE(consDeactiveObj)452 SCIP_DECL_CONSDEACTIVE(consDeactiveObj)
453 {  /*lint --e{715}*/
454    SCIP_CONSHDLRDATA* conshdlrdata;
455 
456    conshdlrdata = SCIPconshdlrGetData(conshdlr);
457    assert(conshdlrdata != NULL);
458    assert(conshdlrdata->objconshdlr != NULL);
459 
460    /* call virtual method of conshdlr object */
461    SCIP_CALL( conshdlrdata->objconshdlr->scip_deactive(scip, conshdlr, cons) );
462 
463    return SCIP_OKAY;
464 }
465 
466 
467 /** constraint enabling notification method of constraint handler */
468 static
SCIP_DECL_CONSENABLE(consEnableObj)469 SCIP_DECL_CONSENABLE(consEnableObj)
470 {  /*lint --e{715}*/
471    SCIP_CONSHDLRDATA* conshdlrdata;
472 
473    conshdlrdata = SCIPconshdlrGetData(conshdlr);
474    assert(conshdlrdata != NULL);
475    assert(conshdlrdata->objconshdlr != NULL);
476 
477    /* call virtual method of conshdlr object */
478    SCIP_CALL( conshdlrdata->objconshdlr->scip_enable(scip, conshdlr, cons) );
479 
480    return SCIP_OKAY;
481 }
482 
483 
484 /** constraint disabling notification method of constraint handler */
485 static
SCIP_DECL_CONSDISABLE(consDisableObj)486 SCIP_DECL_CONSDISABLE(consDisableObj)
487 {  /*lint --e{715}*/
488    SCIP_CONSHDLRDATA* conshdlrdata;
489 
490    conshdlrdata = SCIPconshdlrGetData(conshdlr);
491    assert(conshdlrdata != NULL);
492    assert(conshdlrdata->objconshdlr != NULL);
493 
494    /* call virtual method of conshdlr object */
495    SCIP_CALL( conshdlrdata->objconshdlr->scip_disable(scip, conshdlr, cons) );
496 
497    return SCIP_OKAY;
498 }
499 
500 /** variable deletion method of constraint handler */
501 static
SCIP_DECL_CONSDELVARS(consDelVarsObj)502 SCIP_DECL_CONSDELVARS(consDelVarsObj)
503 {  /*lint --e{715}*/
504    SCIP_CONSHDLRDATA* conshdlrdata;
505 
506    conshdlrdata = SCIPconshdlrGetData(conshdlr);
507    assert(conshdlrdata != NULL);
508    assert(conshdlrdata->objconshdlr != NULL);
509 
510    /* call virtual method of conshdlr object */
511    SCIP_CALL( conshdlrdata->objconshdlr->scip_delvars(scip, conshdlr, conss, nconss) );
512 
513    return SCIP_OKAY;
514 }
515 
516 /** constraint display method of constraint handler */
517 static
SCIP_DECL_CONSPRINT(consPrintObj)518 SCIP_DECL_CONSPRINT(consPrintObj)
519 {  /*lint --e{715}*/
520    SCIP_CONSHDLRDATA* conshdlrdata;
521 
522    conshdlrdata = SCIPconshdlrGetData(conshdlr);
523    assert(conshdlrdata != NULL);
524    assert(conshdlrdata->objconshdlr != NULL);
525 
526    /* call virtual method of conshdlr object */
527    SCIP_CALL( conshdlrdata->objconshdlr->scip_print(scip, conshdlr, cons, file) );
528 
529    return SCIP_OKAY;
530 }
531 
532 /** constraint copying method of constraint handler */
533 static
SCIP_DECL_CONSCOPY(consCopyObj)534 SCIP_DECL_CONSCOPY(consCopyObj)
535 {  /*lint --e{715}*/
536    SCIP_CONSHDLRDATA* sourceconshdlrdata;
537 
538    sourceconshdlrdata = SCIPconshdlrGetData(sourceconshdlr);
539    assert(sourceconshdlrdata != NULL);
540    assert(sourceconshdlrdata->objconshdlr != NULL);
541 
542    /* call virtual method of conshdlr object */
543    SCIP_CALL( sourceconshdlrdata->objconshdlr->scip_copy(scip, cons, name, sourcescip, sourceconshdlr, sourcecons, varmap, consmap,
544          initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, valid) );
545 
546    return SCIP_OKAY;
547 }
548 
549 /** constraint parsing method of constraint handler */
550 static
SCIP_DECL_CONSPARSE(consParseObj)551 SCIP_DECL_CONSPARSE(consParseObj)
552 {  /*lint --e{715}*/
553    SCIP_CONSHDLRDATA* conshdlrdata;
554 
555    conshdlrdata = SCIPconshdlrGetData(conshdlr);
556    assert(conshdlrdata != NULL);
557    assert(conshdlrdata->objconshdlr != NULL);
558 
559    /* call virtual method of conshdlr object */
560    SCIP_CALL( conshdlrdata->objconshdlr->scip_parse(scip, conshdlr, cons, name, str,
561          initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, success) );
562 
563    return SCIP_OKAY;
564 }
565 
566 /** constraint method of constraint handler which returns the variables (if possible) */
567 static
SCIP_DECL_CONSGETVARS(consGetVarsObj)568 SCIP_DECL_CONSGETVARS(consGetVarsObj)
569 {  /*lint --e{715}*/
570    SCIP_CONSHDLRDATA* conshdlrdata;
571 
572    conshdlrdata = SCIPconshdlrGetData(conshdlr);
573    assert(conshdlrdata != NULL);
574    assert(conshdlrdata->objconshdlr != NULL);
575 
576    /* call virtual method of conshdlr object */
577    SCIP_CALL( conshdlrdata->objconshdlr->scip_getvars(scip, conshdlr, cons, vars, varssize, success) );
578 
579    return SCIP_OKAY;
580 }
581 
582 /** constraint method of constraint handler which returns the number of variables (if possible) */
583 static
SCIP_DECL_CONSGETNVARS(consGetNVarsObj)584 SCIP_DECL_CONSGETNVARS(consGetNVarsObj)
585 {  /*lint --e{715}*/
586    SCIP_CONSHDLRDATA* conshdlrdata;
587 
588    conshdlrdata = SCIPconshdlrGetData(conshdlr);
589    assert(conshdlrdata != NULL);
590    assert(conshdlrdata->objconshdlr != NULL);
591 
592    /* call virtual method of conshdlr object */
593    SCIP_CALL( conshdlrdata->objconshdlr->scip_getnvars(scip, conshdlr, cons, nvars, success) );
594 
595    return SCIP_OKAY;
596 }
597 
598 /** constraint handler method to suggest dive bound changes during the generic diving algorithm */
599 static
SCIP_DECL_CONSGETDIVEBDCHGS(consGetDiveBdChgsObj)600 SCIP_DECL_CONSGETDIVEBDCHGS(consGetDiveBdChgsObj)
601 {  /*lint --e{715}*/
602    SCIP_CONSHDLRDATA* conshdlrdata;
603 
604    conshdlrdata = SCIPconshdlrGetData(conshdlr);
605    assert(conshdlrdata != NULL);
606    assert(conshdlrdata->objconshdlr != NULL);
607 
608    /* call virtual method of conshdlr object */
609    SCIP_CALL( conshdlrdata->objconshdlr->scip_getdivebdchgs(scip, conshdlr, diveset, sol, success, infeasible) );
610 
611    return SCIP_OKAY;
612 }
613 }
614 
615 
616 /*
617  * constraint handler specific interface methods
618  */
619 
620 /** creates the constraint handler for the given constraint handler object and includes it in SCIP */
SCIPincludeObjConshdlr(SCIP * scip,scip::ObjConshdlr * objconshdlr,SCIP_Bool deleteobject)621 SCIP_RETCODE SCIPincludeObjConshdlr(
622    SCIP*                 scip,               /**< SCIP data structure */
623    scip::ObjConshdlr*    objconshdlr,        /**< constraint handler object */
624    SCIP_Bool             deleteobject        /**< should the constraint handler object be deleted when conshdlr is freed? */
625    )
626 {
627    SCIP_CONSHDLRDATA* conshdlrdata;
628 
629    assert(scip != NULL);
630    assert(objconshdlr != NULL);
631    assert(objconshdlr->scip_ == scip);
632 
633    /* create obj constraint handler data */
634    conshdlrdata = new SCIP_CONSHDLRDATA;
635    conshdlrdata->objconshdlr = objconshdlr;
636    conshdlrdata->deleteobject = deleteobject;
637 
638    /* include constraint handler */
639    SCIP_CALL( SCIPincludeConshdlr(scip, objconshdlr->scip_name_, objconshdlr->scip_desc_,
640          objconshdlr->scip_sepapriority_, objconshdlr->scip_enfopriority_, objconshdlr->scip_checkpriority_,
641          objconshdlr->scip_sepafreq_, objconshdlr->scip_propfreq_, objconshdlr->scip_eagerfreq_,
642          objconshdlr->scip_maxprerounds_,
643          objconshdlr->scip_delaysepa_, objconshdlr->scip_delayprop_,
644          objconshdlr->scip_needscons_, objconshdlr->scip_proptiming_, objconshdlr->scip_presoltiming_,
645          conshdlrCopyObj,
646          consFreeObj, consInitObj, consExitObj,
647          consInitpreObj, consExitpreObj, consInitsolObj, consExitsolObj,
648          consDeleteObj, consTransObj, consInitlpObj,
649          consSepalpObj, consSepasolObj, consEnfolpObj, consEnforelaxObj, consEnfopsObj, consCheckObj,
650          consPropObj, consPresolObj, consRespropObj, consLockObj,
651          consActiveObj, consDeactiveObj,
652          consEnableObj, consDisableObj, consDelVarsObj,
653          consPrintObj, consCopyObj, consParseObj,
654          consGetVarsObj, consGetNVarsObj, consGetDiveBdChgsObj, conshdlrdata) ); /*lint !e429*/
655 
656    return SCIP_OKAY; /*lint !e429*/
657 }
658 
659 /** returns the conshdlr object of the given name, or 0 if not existing */
SCIPfindObjConshdlr(SCIP * scip,const char * name)660 scip::ObjConshdlr* SCIPfindObjConshdlr(
661    SCIP*                 scip,               /**< SCIP data structure */
662    const char*           name                /**< name of constraint handler */
663    )
664 {
665    SCIP_CONSHDLR* conshdlr;
666    SCIP_CONSHDLRDATA* conshdlrdata;
667 
668    conshdlr = SCIPfindConshdlr(scip, name);
669    if( conshdlr == NULL )
670       return 0;
671 
672    conshdlrdata = SCIPconshdlrGetData(conshdlr);
673    assert(conshdlrdata != NULL);
674 
675    return conshdlrdata->objconshdlr;
676 }
677 
678 /** returns the conshdlr object for the given constraint handler */
SCIPgetObjConshdlr(SCIP * scip,SCIP_CONSHDLR * conshdlr)679 scip::ObjConshdlr* SCIPgetObjConshdlr(
680    SCIP*                 scip,               /**< SCIP data structure */
681    SCIP_CONSHDLR*        conshdlr            /**< constraint handler */
682    )
683 {
684    SCIP_CONSHDLRDATA* conshdlrdata;
685 
686    assert(scip != NULL);
687    conshdlrdata = SCIPconshdlrGetData(conshdlr);
688    assert(conshdlrdata != NULL);
689 
690    return conshdlrdata->objconshdlr;
691 }
692