1    	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2    	/*                                                                           */
3    	/*                  This file is part of the program and library             */
4    	/*         SCIP --- Solving Constraint Integer Programs                      */
5    	/*                                                                           */
6    	/*  Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB)                      */
7    	/*                                                                           */
8    	/*  Licensed under the Apache License, Version 2.0 (the "License");          */
9    	/*  you may not use this file except in compliance with the License.         */
10   	/*  You may obtain a copy of the License at                                  */
11   	/*                                                                           */
12   	/*      http://www.apache.org/licenses/LICENSE-2.0                           */
13   	/*                                                                           */
14   	/*  Unless required by applicable law or agreed to in writing, software      */
15   	/*  distributed under the License is distributed on an "AS IS" BASIS,        */
16   	/*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17   	/*  See the License for the specific language governing permissions and      */
18   	/*  limitations under the License.                                           */
19   	/*                                                                           */
20   	/*  You should have received a copy of the Apache-2.0 license                */
21   	/*  along with SCIP; see the file LICENSE. If not visit scipopt.org.         */
22   	/*                                                                           */
23   	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24   	
25   	/**@file   objprobdata.h
26   	 * @brief  C++ wrapper for user problem data
27   	 * @author Tobias Achterberg
28   	 */
29   	
30   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
31   	
32   	#ifndef __SCIP_OBJPROBDATA_H__
33   	#define __SCIP_OBJPROBDATA_H__
34   	
35   	
36   	#include <cassert>
37   	
38   	#include "scip/scip.h"
39   	#include "objscip/objcloneable.h"
40   	
41   	namespace scip
42   	{
43   	
44   	/** @brief C++ wrapper for user problem data
45   	 *
46   	 *  This class defines the interface for user problem data implemented in C++. This class can be accessed at any time
47   	 *  using the methods SCIPgetObjProbData(). Therefore, it can be used to store data which has to be accessible within
48   	 *  several plugins.
49   	 *
50   	 *  - \ref type_prob.h "Corresponding C interface"
51   	 */
52   	class ObjProbData
53   	{
54   	public:
55   	   /** default constructor */
56   	   ObjProbData()
57   	   {
58   	   }
59   	
60   	   /** destructor */
61   	   virtual ~ObjProbData()
62   	   {
63   	   }
64   	
65   	   /** assignment of polymorphic classes causes slicing and is therefore disabled. */
66   	   ObjProbData& operator=(const ObjProbData& o) = delete;
67   	
68   	   /** assignment of polymorphic classes causes slicing and is therefore disabled. */
69   	   ObjProbData& operator=(ObjProbData&& o) = delete;
70   	
71   	   /** destructor of user problem data to free original user data (called when original problem is freed)
72   	    *
73   	    *  If the "deleteobject" flag in the SCIPcreateObjProb() method was set to TRUE, this method is not needed,
74   	    *  because all the work to delete the user problem data can be done in the destructor of the user problem
75   	    *  data object. If the "deleteobject" flag was set to FALSE, and the user problem data object stays alive
76   	    *  after the SCIP problem is freed, this method should delete all the problem specific data that is no
77   	    *  longer needed.
78   	    */ /*lint -e715*/
79   	   virtual SCIP_RETCODE scip_delorig(
80   	      SCIP*              scip                /**< SCIP data structure */
81   	      )
82   	   {  /*lint --e{715}*/
83   	      return SCIP_OKAY;
84   	   }
85   	
86   	   /** creates user data of transformed problem by transforming the original user problem data
87   	    *  (called after problem was transformed)
88   	    *
89   	    *  The user has two possibilities to implement this method:
90   	    *   1. Return the pointer to the original problem data object (this) as pointer to the transformed problem data
91   	    *      object. The user may modify some internal attributes, but he has to make sure, that these modifications are
92   	    *      reversed in the scip_deltrans() method, such that the original problem data is restored. In this case,
93   	    *      he should set *deleteobject to FALSE, because the problem data must not be destructed by SCIP after the
94   	    *      solving process is terminated.
95   	    *   2. Call the copy constructor of the problem data object and return the created copy as transformed problem
96   	    *      data object. In this case, he probably wants to set *deleteobject to TRUE, thus letting SCIP call the
97   	    *      destructor of the object if the transformed problem data is no longer needed.
98   	    */ /*lint -e715*/
99   	   virtual SCIP_RETCODE scip_trans(
100  	      SCIP*              scip,               /**< SCIP data structure */
101  	      ObjProbData**      objprobdata,        /**< pointer to store the transformed problem data object */
102  	      SCIP_Bool*         deleteobject        /**< pointer to store whether SCIP should delete the object after solving */
103  	      )
104  	   {  /*lint --e{715}*/
105  	      assert(objprobdata != NULL);
106  	      assert(deleteobject != NULL);
107  	
108  	      /* the default implementation just copies the pointer to the problem data object;
109  	       * SCIP must not destruct the transformed problem data object, because the original problem data must stay alive
110  	       */
111  	      *objprobdata = this;
112  	      *deleteobject = FALSE;
113  	
114  	      return SCIP_OKAY;
115  	   }      
116  	
117  	   /** destructor of user problem data to free transformed user data (called when transformed problem is freed)
118  	    *
119  	    *  If the "*deleteobject" flag in the scip_trans() method was set to TRUE, this method is not needed,
120  	    *  because all the work to delete the user problem data can be done in the destructor of the user problem
121  	    *  data object. If the "*deleteobject" flag was set to FALSE, and the user problem data object stays alive
122  	    *  after the SCIP problem is freed, this method should delete all the problem specific data that is no
123  	    *  longer needed.
124  	    */ /*lint -e715*/
125  	   virtual SCIP_RETCODE scip_deltrans(
126  	      SCIP*              scip                /**< SCIP data structure */
127  	      )
128  	   {  /*lint --e{715}*/
129  	      return SCIP_OKAY;
130  	   }
131  	
132  	   /** solving process initialization method of transformed data (called before the branch and bound process begins)
133  	    *
134  	    *  This method is called before the branch and bound process begins and can be used to initialize user problem
135  	    *  data that depends for example on the number of active problem variables, because these are now fixed.
136  	    */ /*lint -e715*/
137  	   virtual SCIP_RETCODE scip_initsol(
138  	      SCIP*              scip                /**< SCIP data structure */
139  	      )
140  	   {  /*lint --e{715}*/
141  	      return SCIP_OKAY;
142  	   }
143  	
144  	   /** solving process deinitialization method of transformed data (called before the branch and bound data is freed)
145  	    *
146  	    *  This method is called before the branch and bound data is freed and should be used to free all data that
147  	    *  was allocated in the solving process initialization method. The user has to make sure, that all LP rows associated
148  	    *  to the transformed user problem data are released.
149  	    */ /*lint -e715*/
150  	   virtual SCIP_RETCODE scip_exitsol(
151  	      SCIP*              scip,                /**< SCIP data structure */
152  	      SCIP_Bool          restart              /**< was this exit solve call triggered by a restart? */
153  	      )
154  	   {  /*lint --e{715}*/
155  	      return SCIP_OKAY;
156  	   }
157  	
158  	   /** copies user data of source SCIP for the target SCIP
159  	    *
160  	    *  This method should copy the problem data of the source SCIP and create a target problem data for (target)
161  	    *  SCIP. Implementing this callback is optional. If the copying process was successful the target SCIP gets this
162  	    *  problem data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target SCIP will have no problem data
163  	    *  at all.
164  	    *
165  	    *  The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(),
166  	    *  respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target
167  	    *  SCIP. You should be very carefully in using these two methods since they could lead to an infinite loop due to
168  	    *  recursion.
169  	    *
170  	    *  possible return values for *result:
171  	    *  - SCIP_DIDNOTRUN  : the copying process was not performed 
172  	    *  - SCIP_SUCCESS    : the copying process was successfully performed
173  	    */ /*lint -e715*/
174  	   virtual SCIP_RETCODE scip_copy(
175  	      SCIP*              scip,               /**< SCIP data structure */
176  	      SCIP*              sourcescip,         /**< source SCIP main data structure */
177  	      SCIP_HASHMAP*      varmap,             /**< a hashmap which stores the mapping of source variables to corresponding 
178  	                                              *   target variables */
179  	      SCIP_HASHMAP*      consmap,            /**< a hashmap which stores the mapping of source contraints to corresponding 
180  	                                              *   target constraints */
181  	      ObjProbData**      objprobdata,        /**< pointer to store the copied problem data object */
182  	      SCIP_Bool          global,             /**< create a global or a local copy? */
183  	      SCIP_RESULT*       result              /**< pointer to store the result of the call */
184  	      )
185  	   {  /*lint --e{715}*/
186  	      (*objprobdata) = 0;
187  	      (*result) = SCIP_DIDNOTRUN;
188  	      return SCIP_OKAY;
189  	   }
190  	};
191  	
192  	} /* namespace scip */
193  	
194  	
195  	
196  	/** creates empty problem, initializes all solving data structures, and sets the user problem data to point to the
197  	 *  given user data object
198  	 *
199  	 *  The method should be called in one of the following ways:
200  	 *
201  	 *   1. The user is resposible of deleting the object:
202  	 *       SCIP_CALL( SCIPcreate(&scip) );
203  	 *       ...
204  	 *       MyProbData* myprobdata = new MyProbData(...);
205  	 *       SCIP_CALL( SCIPcreateObjProb(scip, "probname", &myprobdata, FALSE) );
206  	 *       ... // solve the problem
207  	 *       SCIP_CALL( SCIPfreeProb(scip) );
208  	 *       delete myprobdata;    // delete probdata AFTER SCIPfreeProb() !
209  	 *       ...
210  	 *       SCIP_CALL( SCIPfree(&scip) );
211  	 *
212  	 *   2. The object pointer is passed to SCIP and deleted by SCIP in the SCIPfreeProb() call:
213  	 *       SCIP_CALL( SCIPcreate(&scip) );
214  	 *       ...
215  	 *       SCIP_CALL( SCIPcreateObjProb(scip, "probname", new MyProbData(...), TRUE) );
216  	 *       ...
217  	 *       SCIP_CALL( SCIPfree(&scip) );  // problem is freed and destructor of MyProbData is called here
218  	 */
219  	SCIP_EXPORT
220  	SCIP_RETCODE SCIPcreateObjProb(
221  	   SCIP*                 scip,               /**< SCIP data structure */
222  	   const char*           name,               /**< problem name */
223  	   scip::ObjProbData*    objprobdata,        /**< user problem data object */
224  	   SCIP_Bool             deleteobject        /**< should the user problem data object be deleted when problem is freed? */
225  	   );
226  	
227  	/** gets user problem data object
228  	 *  Warning! This method should only be called after a problem was created with SCIPcreateObjProb().
229  	 *  Otherwise, a segmentation fault may arise, or an undefined pointer is returned.
230  	 */
231  	SCIP_EXPORT
232  	scip::ObjProbData* SCIPgetObjProbData(
233  	   SCIP*                 scip                /**< SCIP data structure */
234  	   );
235  	
236  	#endif
237