OR-Tools  8.2
Model

Detailed Description

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 sat/model.h.

Public Member Functions

 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 >
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 >
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
 

Constructor & Destructor Documentation

◆ Model() [1/2]

Model ( )
inline

Definition at line 40 of file sat/model.h.

◆ ~Model()

~Model ( )
inline

Definition at line 42 of file sat/model.h.

◆ Model() [2/2]

Model ( std::string  name)
inlineexplicit

When there is more than one model in an application, it makes sense to name them for debugging or logging.

Definition at line 54 of file sat/model.h.

Member Function Documentation

◆ Add()

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 ...
};
}
Class that owns everything related to a particular optimization model.
Definition: sat/model.h:38
GRBmodel * model

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));
std::function< IntegerVariable(Model *)> NewWeightedSum(const VectorInt &coefficients, const std::vector< IntegerVariable > &vars)
Definition: integer_expr.h:641
std::function< BooleanVariable(Model *)> NewBooleanVariable()
Definition: integer.h:1412

Definition at line 81 of file sat/model.h.

◆ Create()

T * Create ( )
inline

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.

It is just a shortcut to new + TakeOwnership().

Definition at line 157 of file sat/model.h.

◆ Get() [1/2]

const T * Get ( ) const
inline

Likes GetOrCreate() but do not create the object if it is non-existing.

This returns a const version of the object.

Definition at line 127 of file sat/model.h.

◆ Get() [2/2]

T Get ( std::function< T(const Model &)>  f) const
inline

Similar to Add() but this is const.

Definition at line 87 of file sat/model.h.

◆ GetOrCreate()

T * GetOrCreate ( )
inline

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 sat/model.h.

◆ Mutable()

T * Mutable ( ) const
inline

Same as Get(), but returns a mutable version of the object.

Definition at line 136 of file sat/model.h.

◆ Name()

const std::string & Name ( ) const
inline

Definition at line 175 of file sat/model.h.

◆ Register()

void Register ( T *  non_owned_class)
inline

Register a non-owned class that will be "singleton" in the model.

It is an error to call this on an already registered class.

Definition at line 169 of file sat/model.h.

◆ TakeOwnership()

void TakeOwnership ( T *  t)
inline

Gives ownership of a pointer to this model.

It will be destroyed when the model is.

Definition at line 147 of file sat/model.h.


The documentation for this class was generated from the following file: