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 mecanism to wire them together.
Definition at line 38 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 > |
void | 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(contraint_args, &model);
- model.Add(ConstraintCreationFunction(contraint_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(contraint_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 81 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 106 of file model.h.