OR-Tools  8.2
visitor.cc
Go to the documentation of this file.
1// Copyright 2010-2018 Google LLC
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
14#include <cstddef>
15#include <string>
16#include <vector>
17
18#include "absl/container/flat_hash_map.h"
19#include "absl/container/flat_hash_set.h"
22#include "ortools/base/macros.h"
27
28namespace operations_research {
29// ---------- ArgumentHolder ----------
30
31const std::string& ArgumentHolder::TypeName() const { return type_name_; }
32
33void ArgumentHolder::SetTypeName(const std::string& type_name) {
34 type_name_ = type_name;
35}
36
37void ArgumentHolder::SetIntegerArgument(const std::string& arg_name,
38 int64 value) {
39 integer_argument_[arg_name] = value;
40}
41
42void ArgumentHolder::SetIntegerArrayArgument(const std::string& arg_name,
43 const std::vector<int64>& values) {
44 integer_array_argument_[arg_name] = values;
45}
46
47void ArgumentHolder::SetIntegerMatrixArgument(const std::string& arg_name,
48 const IntTupleSet& values) {
49 std::pair<std::string, IntTupleSet> to_insert =
50 std::make_pair(arg_name, values);
51 matrix_argument_.insert(to_insert);
52}
53
54void ArgumentHolder::SetIntegerExpressionArgument(const std::string& arg_name,
55 IntExpr* const expr) {
56 integer_expression_argument_[arg_name] = expr;
57}
58
60 const std::string& arg_name, const std::vector<IntVar*>& vars) {
61 integer_variable_array_argument_[arg_name] = vars;
62}
63
64void ArgumentHolder::SetIntervalArgument(const std::string& arg_name,
65 IntervalVar* const var) {
66 interval_argument_[arg_name] = var;
67}
68
70 const std::string& arg_name, const std::vector<IntervalVar*>& vars) {
71 interval_array_argument_[arg_name] = vars;
72}
73
74void ArgumentHolder::SetSequenceArgument(const std::string& arg_name,
75 SequenceVar* const var) {
76 sequence_argument_[arg_name] = var;
77}
78
80 const std::string& arg_name, const std::vector<SequenceVar*>& vars) {
81 sequence_array_argument_[arg_name] = vars;
82}
83
85 const std::string& arg_name) const {
86 return gtl::ContainsKey(integer_expression_argument_, arg_name);
87}
88
90 const std::string& arg_name) const {
91 return gtl::ContainsKey(integer_variable_array_argument_, arg_name);
92}
93
95 const std::string& arg_name, int64 def) const {
96 return gtl::FindWithDefault(integer_argument_, arg_name, def);
97}
98
100 const std::string& arg_name) const {
101 return gtl::FindOrDie(integer_argument_, arg_name);
102}
103
105 const std::string& arg_name) const {
106 return gtl::FindOrDie(integer_array_argument_, arg_name);
107}
108
110 const std::string& arg_name) const {
111 return gtl::FindOrDie(integer_expression_argument_, arg_name);
112}
113
114const std::vector<IntVar*>&
116 const std::string& arg_name) const {
117 return gtl::FindOrDie(integer_variable_array_argument_, arg_name);
118}
119
121 const std::string& arg_name) const {
122 return gtl::FindOrDie(matrix_argument_, arg_name);
123}
124
125// ---------- ModelParser ---------
126
128
129ModelParser::~ModelParser() { CHECK(holders_.empty()); }
130
131void ModelParser::BeginVisitModel(const std::string& solver_name) {
133}
134
135void ModelParser::EndVisitModel(const std::string& solver_name) {
137}
138
139void ModelParser::BeginVisitConstraint(const std::string& type_name,
140 const Constraint* const constraint) {
142}
143
144void ModelParser::EndVisitConstraint(const std::string& type_name,
145 const Constraint* const constraint) {
146 // Constraint parsing is usually done here.
148}
149
150void ModelParser::BeginVisitIntegerExpression(const std::string& type_name,
151 const IntExpr* const expr) {
153}
154
155void ModelParser::EndVisitIntegerExpression(const std::string& type_name,
156 const IntExpr* const expr) {
157 // Expression parsing is usually done here.
159}
160
161void ModelParser::VisitIntegerVariable(const IntVar* const variable,
162 IntExpr* const delegate) {
163 // Usual place for parsing.
164}
165
166void ModelParser::VisitIntegerVariable(const IntVar* const variable,
167 const std::string& operation,
168 int64 value, IntVar* const delegate) {
169 delegate->Accept(this);
170 // Usual place for parsing.
171}
172
174 const std::string& operation,
175 int64 value,
176 IntervalVar* const delegate) {
177 if (delegate != nullptr) {
178 delegate->Accept(this);
179 }
180 // Usual place for parsing.
181}
182
184 // Usual place for parsing.
185}
186
187// Integer arguments
188void ModelParser::VisitIntegerArgument(const std::string& arg_name,
189 int64 value) {
190 Top()->SetIntegerArgument(arg_name, value);
191}
192
193void ModelParser::VisitIntegerArrayArgument(const std::string& arg_name,
194 const std::vector<int64>& values) {
195 Top()->SetIntegerArrayArgument(arg_name, values);
196}
197
198void ModelParser::VisitIntegerMatrixArgument(const std::string& arg_name,
199 const IntTupleSet& values) {
200 Top()->SetIntegerMatrixArgument(arg_name, values);
201}
202
203// Variables.
204void ModelParser::VisitIntegerExpressionArgument(const std::string& arg_name,
205 IntExpr* const argument) {
206 Top()->SetIntegerExpressionArgument(arg_name, argument);
207 argument->Accept(this);
208}
209
211 const std::string& arg_name, const std::vector<IntVar*>& arguments) {
212 Top()->SetIntegerVariableArrayArgument(arg_name, arguments);
213 for (int i = 0; i < arguments.size(); ++i) {
214 arguments[i]->Accept(this);
215 }
216}
217
218// Visit interval argument.
219void ModelParser::VisitIntervalArgument(const std::string& arg_name,
220 IntervalVar* const argument) {
221 Top()->SetIntervalArgument(arg_name, argument);
222 argument->Accept(this);
223}
224
226 const std::string& arg_name, const std::vector<IntervalVar*>& arguments) {
227 Top()->SetIntervalArrayArgument(arg_name, arguments);
228 for (int i = 0; i < arguments.size(); ++i) {
229 arguments[i]->Accept(this);
230 }
231}
232
233// Visit sequence argument.
234void ModelParser::VisitSequenceArgument(const std::string& arg_name,
235 SequenceVar* const argument) {
236 Top()->SetSequenceArgument(arg_name, argument);
237 argument->Accept(this);
238}
239
241 const std::string& arg_name, const std::vector<SequenceVar*>& arguments) {
242 Top()->SetSequenceArrayArgument(arg_name, arguments);
243 for (int i = 0; i < arguments.size(); ++i) {
244 arguments[i]->Accept(this);
245 }
246}
247
249 holders_.push_back(new ArgumentHolder);
250}
251
253 CHECK(!holders_.empty());
254 delete holders_.back();
255 holders_.pop_back();
256}
257
259 CHECK(!holders_.empty());
260 return holders_.back();
261}
262} // namespace operations_research
#define CHECK(condition)
Definition: base/logging.h:495
Argument Holder: useful when visiting a model.
const std::vector< IntVar * > & FindIntegerVariableArrayArgumentOrDie(const std::string &arg_name) const
Definition: visitor.cc:115
const IntTupleSet & FindIntegerMatrixArgumentOrDie(const std::string &arg_name) const
Definition: visitor.cc:120
bool HasIntegerVariableArrayArgument(const std::string &arg_name) const
Definition: visitor.cc:89
int64 FindIntegerArgumentWithDefault(const std::string &arg_name, int64 def) const
Getters.
Definition: visitor.cc:94
void SetSequenceArgument(const std::string &arg_name, SequenceVar *const var)
Definition: visitor.cc:74
void SetIntegerArrayArgument(const std::string &arg_name, const std::vector< int64 > &values)
Definition: visitor.cc:42
void SetIntegerExpressionArgument(const std::string &arg_name, IntExpr *const expr)
Definition: visitor.cc:54
void SetTypeName(const std::string &type_name)
Definition: visitor.cc:33
const std::string & TypeName() const
Type of the argument.
Definition: visitor.cc:31
void SetIntegerVariableArrayArgument(const std::string &arg_name, const std::vector< IntVar * > &vars)
Definition: visitor.cc:59
void SetSequenceArrayArgument(const std::string &arg_name, const std::vector< SequenceVar * > &vars)
Definition: visitor.cc:79
void SetIntervalArgument(const std::string &arg_name, IntervalVar *const var)
Definition: visitor.cc:64
void SetIntegerArgument(const std::string &arg_name, int64 value)
Setters.
Definition: visitor.cc:37
const std::vector< int64 > & FindIntegerArrayArgumentOrDie(const std::string &arg_name) const
Definition: visitor.cc:104
IntExpr * FindIntegerExpressionArgumentOrDie(const std::string &arg_name) const
Definition: visitor.cc:109
void SetIntegerMatrixArgument(const std::string &arg_name, const IntTupleSet &values)
Definition: visitor.cc:47
bool HasIntegerExpressionArgument(const std::string &arg_name) const
Checks if arguments exist.
Definition: visitor.cc:84
void SetIntervalArrayArgument(const std::string &arg_name, const std::vector< IntervalVar * > &vars)
Definition: visitor.cc:69
int64 FindIntegerArgumentOrDie(const std::string &arg_name) const
Definition: visitor.cc:99
A constraint is the main modeling object.
The class IntExpr is the base of all integer expressions in constraint programming.
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given visitor.
The class IntVar is a subset of IntExpr.
void Accept(ModelVisitor *const visitor) const override
Accepts the given visitor.
Interval variables are often used in scheduling.
virtual void Accept(ModelVisitor *const visitor) const =0
Accepts the given visitor.
void VisitIntervalVariable(const IntervalVar *const variable, const std::string &operation, int64 value, IntervalVar *const delegate) override
Definition: visitor.cc:173
void BeginVisitIntegerExpression(const std::string &type_name, const IntExpr *const expr) override
Definition: visitor.cc:150
void BeginVisitConstraint(const std::string &type_name, const Constraint *const constraint) override
Definition: visitor.cc:139
ArgumentHolder * Top() const
Definition: visitor.cc:258
void VisitIntegerExpressionArgument(const std::string &arg_name, IntExpr *const argument) override
Variables.
Definition: visitor.cc:204
void VisitSequenceVariable(const SequenceVar *const variable) override
Definition: visitor.cc:183
void VisitIntervalArgument(const std::string &arg_name, IntervalVar *const argument) override
Visit interval argument.
Definition: visitor.cc:219
void VisitSequenceArrayArgument(const std::string &arg_name, const std::vector< SequenceVar * > &arguments) override
Definition: visitor.cc:240
void EndVisitConstraint(const std::string &type_name, const Constraint *const constraint) override
Definition: visitor.cc:144
void EndVisitModel(const std::string &solver_name) override
Definition: visitor.cc:135
void VisitSequenceArgument(const std::string &arg_name, SequenceVar *const argument) override
Visit sequence argument.
Definition: visitor.cc:234
void VisitIntegerArrayArgument(const std::string &arg_name, const std::vector< int64 > &values) override
Definition: visitor.cc:193
void VisitIntegerVariableArrayArgument(const std::string &arg_name, const std::vector< IntVar * > &arguments) override
Definition: visitor.cc:210
void VisitIntegerVariable(const IntVar *const variable, IntExpr *const delegate) override
Definition: visitor.cc:161
void VisitIntegerMatrixArgument(const std::string &arg_name, const IntTupleSet &values) override
Definition: visitor.cc:198
void BeginVisitModel(const std::string &solver_name) override
Header/footers.
Definition: visitor.cc:131
void VisitIntegerArgument(const std::string &arg_name, int64 value) override
Integer arguments.
Definition: visitor.cc:188
void EndVisitIntegerExpression(const std::string &type_name, const IntExpr *const expr) override
Definition: visitor.cc:155
void VisitIntervalArrayArgument(const std::string &arg_name, const std::vector< IntervalVar * > &arguments) override
Definition: visitor.cc:225
A sequence variable is a variable whose domain is a set of possible orderings of the interval variabl...
virtual void Accept(ModelVisitor *const visitor) const
Accepts the given visitor.
Definition: sched_search.cc:71
int64 value
IntVar * var
Definition: expr_array.cc:1858
int64_t int64
const Collection::value_type::second_type & FindOrDie(const Collection &collection, const typename Collection::value_type::first_type &key)
Definition: map_util.h:176
bool ContainsKey(const Collection &collection, const Key &key)
Definition: map_util.h:170
const Collection::value_type::second_type & FindWithDefault(const Collection &collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
Definition: map_util.h:26
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...