Scippy

SCIP

Solving Constraint Integer Programs

objeventhdlr.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2022 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 objeventhdlr.h
17  * @brief C++ wrapper for event handlers
18  * @author Tobias Achterberg
19  */
20 
21 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
22 
23 #ifndef __SCIP_OBJEVENTHDLR_H__
24 #define __SCIP_OBJEVENTHDLR_H__
25 
26 #include <cstring>
27 
28 #include "scip/scip.h"
29 #include "objscip/objcloneable.h"
30 
31 namespace scip
32 {
33 
34 /** @brief C++ wrapper for event handlers
35  *
36  * This class defines the interface for eventt handlers implemented in C++. Note that there is a pure virtual function
37  * (this function has to be implemented). This function is: scip_exec().
38  *
39  * - \ref EVENT "Instructions for implementing an event handler"
40  * - \ref type_event.h "Corresponding C interface"
41  */
42 class ObjEventhdlr : public ObjCloneable
43 {
44 public:
45  /*lint --e{1540}*/
46 
47  /** SCIP data structure */
49 
50  /** name of the event handler */
51  char* scip_name_;
52 
53  /** description of the event handler */
54  char* scip_desc_;
55 
56  /** default constructor */
58  SCIP* scip, /**< SCIP data structure */
59  const char* name, /**< name of event handler */
60  const char* desc /**< description of event handler */
61  )
62  : scip_(scip),
63  scip_name_(0),
64  scip_desc_(0)
65  {
66  /* the macro SCIPduplicateMemoryArray does not need the first argument: */
67  SCIP_CALL_ABORT( SCIPduplicateMemoryArray(scip_, &scip_name_, name, std::strlen(name)+1) );
68  SCIP_CALL_ABORT( SCIPduplicateMemoryArray(scip_, &scip_desc_, desc, std::strlen(desc)+1) );
69  }
70 
71  /** destructor */
72  virtual ~ObjEventhdlr()
73  {
74  /* the macro SCIPfreeMemoryArray does not need the first argument: */
75  /*lint --e{64}*/
76  SCIPfreeMemoryArray(scip_, &scip_name_);
77  SCIPfreeMemoryArray(scip_, &scip_desc_);
78  }
79 
80  /** destructor of event handler to free user data (called when SCIP is exiting)
81  *
82  * @see SCIP_DECL_EVENTFREE(x) in @ref type_event.h
83  */
84  virtual SCIP_DECL_EVENTFREE(scip_free)
85  { /*lint --e{715}*/
86  return SCIP_OKAY;
87  }
88 
89  /** initialization method of event handler (called after problem was transformed)
90  *
91  * @see SCIP_DECL_EVENTINIT(x) in @ref type_event.h
92  */
93  virtual SCIP_DECL_EVENTINIT(scip_init)
94  { /*lint --e{715}*/
95  return SCIP_OKAY;
96  }
97 
98  /** deinitialization method of event handler (called before transformed problem is freed)
99  *
100  * @see SCIP_DECL_EVENTEXIT(x) in @ref type_event.h
101  */
102  virtual SCIP_DECL_EVENTEXIT(scip_exit)
103  { /*lint --e{715}*/
104  return SCIP_OKAY;
105  }
106 
107  /** solving process initialization method of event handler (called when branch and bound process is about to begin)
108  *
109  * @see SCIP_DECL_EVENTINITSOL(x) in @ref type_event.h
110  */
111  virtual SCIP_DECL_EVENTINITSOL(scip_initsol)
112  { /*lint --e{715}*/
113  return SCIP_OKAY;
114  }
115 
116  /** solving process deinitialization method of event handler (called before branch and bound process data is freed)
117  *
118  * @see SCIP_DECL_EVENTEXITSOL(x) in @ref type_event.h
119  */
120  virtual SCIP_DECL_EVENTEXITSOL(scip_exitsol)
121  { /*lint --e{715}*/
122  return SCIP_OKAY;
123  }
124 
125  /** frees specific constraint data
126  *
127  * @see SCIP_DECL_EVENTDELETE(x) in @ref type_event.h
128  */
129  virtual SCIP_DECL_EVENTDELETE(scip_delete)
130  { /*lint --e{715}*/
131  return SCIP_OKAY;
132  }
133 
134  /** execution method of event handler
135  *
136  * @see SCIP_DECL_EVENTEXEC(x) in @ref type_event.h
137  */
138  virtual SCIP_DECL_EVENTEXEC(scip_exec) = 0;
139 };
140 
141 } /* namespace scip */
142 
143 
144 
145 /** creates the event handler for the given event handler object and includes it in SCIP
146  *
147  * The method should be called in one of the following ways:
148  *
149  * 1. The user is resposible of deleting the object:
150  * SCIP_CALL( SCIPcreate(&scip) );
151  * ...
152  * MyEventhdlr* myeventhdlr = new MyEventhdlr(...);
153  * SCIP_CALL( SCIPincludeObjEventhdlr(scip, &myeventhdlr, FALSE) );
154  * ...
155  * SCIP_CALL( SCIPfree(&scip) );
156  * delete myeventhdlr; // delete eventhdlr AFTER SCIPfree() !
157  *
158  * 2. The object pointer is passed to SCIP and deleted by SCIP in the SCIPfree() call:
159  * SCIP_CALL( SCIPcreate(&scip) );
160  * ...
161  * SCIP_CALL( SCIPincludeObjEventhdlr(scip, new MyEventhdlr(...), TRUE) );
162  * ...
163  * SCIP_CALL( SCIPfree(&scip) ); // destructor of MyEventhdlr is called here
164  */
165 SCIP_EXPORT
167  SCIP* scip, /**< SCIP data structure */
168  scip::ObjEventhdlr* objeventhdlr, /**< event handler object */
169  SCIP_Bool deleteobject /**< should the event handler object be deleted when eventhdlristic is freed? */
170  );
171 
172 /** returns the eventhdlr object of the given name, or 0 if not existing */
173 SCIP_EXPORT
175  SCIP* scip, /**< SCIP data structure */
176  const char* name /**< name of event handler */
177  );
178 
179 /** returns the eventhdlr object for the given event handler */
180 SCIP_EXPORT
182  SCIP* scip, /**< SCIP data structure */
183  SCIP_EVENTHDLR* eventhdlr /**< event handler */
184  );
185 
186 #endif
virtual SCIP_DECL_EVENTEXIT(scip_exit)
Definition: objeventhdlr.h:102
virtual SCIP_DECL_EVENTINITSOL(scip_initsol)
Definition: objeventhdlr.h:111
scip::ObjEventhdlr * SCIPgetObjEventhdlr(SCIP *scip, SCIP_EVENTHDLR *eventhdlr)
#define SCIPduplicateMemoryArray(scip, ptr, source, num)
Definition: scip_mem.h:67
#define SCIPfreeMemoryArray(scip, ptr)
Definition: scip_mem.h:71
virtual SCIP_DECL_EVENTDELETE(scip_delete)
Definition: objeventhdlr.h:129
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
scip::ObjEventhdlr * SCIPfindObjEventhdlr(SCIP *scip, const char *name)
virtual SCIP_DECL_EVENTEXEC(scip_exec)=0
definition of base class for all clonable classes
ObjEventhdlr(SCIP *scip, const char *name, const char *desc)
Definition: objeventhdlr.h:57
#define SCIP_Bool
Definition: def.h:84
virtual SCIP_DECL_EVENTINIT(scip_init)
Definition: objeventhdlr.h:93
C++ wrapper for event handlers.
Definition: objeventhdlr.h:42
SCIP_RETCODE SCIPincludeObjEventhdlr(SCIP *scip, scip::ObjEventhdlr *objeventhdlr, SCIP_Bool deleteobject)
Definition of base class for all clonable classes.
Definition: objcloneable.h:38
virtual SCIP_DECL_EVENTEXITSOL(scip_exitsol)
Definition: objeventhdlr.h:120
virtual ~ObjEventhdlr()
Definition: objeventhdlr.h:72
virtual SCIP_DECL_EVENTFREE(scip_free)
Definition: objeventhdlr.h:84
#define SCIP_CALL_ABORT(x)
Definition: def.h:363
SCIP callable library.