Class that owns everything related to a particular optimization model.
This class is actually a fully generic wrapper that can hold any type of constraints, watchers, solvers and provide a mechanism to wire them together.
Definition at line 42 of file model.h.
|
| | Model () |
| |
| | ~Model () |
| |
| | Model (std::string name) |
| | When there is more than one model in an application, it makes sense to name them for debugging or logging. More...
|
| |
| template<typename T > |
| T | Add (std::function< T(Model *)> f) |
| | This makes it possible to have a nicer API on the client side, and it allows both of these forms: More...
|
| |
| template<typename T > |
| T | Get (std::function< T(const Model &)> f) const |
| | Similar to Add() but this is const. More...
|
| |
| template<typename T > |
| T * | GetOrCreate () |
| | Returns an object of type T that is unique to this model (like a "local" singleton). More...
|
| |
| template<typename T > |
| const T * | Get () const |
| | Likes GetOrCreate() but do not create the object if it is non-existing. More...
|
| |
| template<typename T > |
| T * | Mutable () const |
| | Same as Get(), but returns a mutable version of the object. More...
|
| |
| template<typename T > |
| T * | TakeOwnership (T *t) |
| | Gives ownership of a pointer to this model. More...
|
| |
| template<typename T > |
| T * | Create () |
| | This returns a non-singleton object owned by the model and created with the T(Model* model) constructor if it exist or the T() constructor otherwise. More...
|
| |
| template<typename T > |
| void | Register (T *non_owned_class) |
| | Register a non-owned class that will be "singleton" in the model. More...
|
| |
| const std::string & | Name () const |
| |
| T Add |
( |
std::function< T(Model *)> |
f | ) |
|
|
inline |
This makes it possible to have a nicer API on the client side, and it allows both of these forms:
- ConstraintCreationFunction(constraint_args, &model);
- model.Add(ConstraintCreationFunction(constraint_args));
The second form is a bit nicer for the client and it also allows to store constraints and add them later. However, the function creating the constraint is slighly more involved.
std::function<void(
Model*)> ConstraintCreationFunction(constraint_args) {
return [=] (
Model* model) {
... the same code ...
};
}
We also have a templated return value for the functions that need it like
const BooleanVariable b = model.Add(NewBooleanVariable());
const IntegerVariable i = model.Add(NewWeightedSum(weights, variables));
Definition at line 85 of file model.h.
Returns an object of type T that is unique to this model (like a "local" singleton).
This returns an already created instance or create a new one if needed using the T(Model* model) constructor if it exist or T() otherwise.
This works a bit like in a dependency injection framework and allows to really easily wire all the classes that make up a solver together. For instance a constraint can depends on the LiteralTrail, or the IntegerTrail or both, it can depend on a Watcher class to register itself in order to be called when needed and so on.
IMPORTANT: the Model* constructor functions shouldn't form a cycle between each other, otherwise this will crash the program.
Definition at line 110 of file model.h.