aGrUM  0.14.2
errors.cpp
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright (C) 2005 by Pierre-Henri WUILLEMIN et Christophe GONZALES *
3  * {prenom.nom}_at_lip6.fr *
4  * *
5  * This program is free software; you can redistribute it and/or modify *
6  * it under the terms of the GNU General Public License as published by *
7  * the Free Software Foundation; either version 2 of the License, or *
8  * (at your option) any later version. *
9  * *
10  * This program is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public License *
16  * along with this program; if not, write to the *
17  * Free Software Foundation, Inc., *
18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19  ***************************************************************************/
20 
29 #include <agrum/PRM/o3prm/errors.h>
30 
31 #ifndef DOXYGEN_SHOULD_SKIP_THIS
32 
33 namespace gum {
34  namespace prm {
35  namespace o3prm {
36 
37  void O3PRM_TYPE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
38  auto pos = val.position();
39  std::stringstream msg;
40  msg << "Error : "
41  << "Unknown type " << val.label();
42  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
43  }
44 
45  void O3PRM_TYPE_AMBIGUOUS(const O3Label& val,
46  const std::vector< std::string >& matches,
47  ErrorsContainer& errors) {
48  const auto& pos = val.position();
49  std::stringstream msg;
50  msg << "Error : "
51  << "Ambiguous name " << val.label()
52  << ", found more than one elligible types: ";
53  for (std::size_t i = 0; i < matches.size() - 1; ++i) {
54  msg << matches[i] << ", ";
55  }
56  msg << matches.back();
57  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
58  }
59 
60  void O3PRM_TYPE_RESERVED(const O3Label& val, ErrorsContainer& errors) {
61  const auto& pos = val.position();
62  std::stringstream msg;
63  msg << "Error : "
64  << "Type name " << val.label() << " is reserved";
65  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
66  }
67 
68  void O3PRM_TYPE_DUPPLICATE(const O3Label& val, ErrorsContainer& errors) {
69  const auto& pos = val.position();
70  std::stringstream msg;
71  msg << "Error : "
72  << "Type " << val.label() << " exists already";
73  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
74  }
75 
76  void O3PRM_TYPE_CYCLIC_INHERITANCE(const O3Label& sub_type,
77  const O3Label& super_type,
78  ErrorsContainer& errors) {
79  const auto& pos = sub_type.position();
80  std::stringstream msg;
81  msg << "Error : "
82  << "Cyclic inheritance between type " << sub_type.label()
83  << " and type " << super_type.label();
84  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
85  }
86 
87  void O3PRM_TYPE_UNKNOWN_LABEL(const O3Label& type,
88  const O3Label& l,
89  ErrorsContainer& errors) {
90  const auto& pos = l.position();
91  std::stringstream msg;
92  msg << "Error : "
93  << "Unknown label " << l.label() << " in " << type.label();
94  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
95  }
96 
97  void O3PRM_TYPE_INVALID_RANGE(const O3IntType& val,
98  ErrorsContainer& errors) {
99  const auto& pos = val.position();
100  std::stringstream msg;
101  msg << "Error : "
102  << "Invalid range " << val.start().value() << " -> "
103  << val.end().value();
104  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
105  }
106 
107  void O3PRM_TYPE_INVALID_RANGE(const O3RealType& val,
108  ErrorsContainer& errors) {
109  const auto& pos = val.position();
110  std::stringstream msg;
111  msg << "Error : "
112  << "Found " << val.values().size()
113  << " values in range expected at least 3";
114  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
115  }
116 
117  void O3PRM_CLASS_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
118  const auto& pos = val.position();
119  std::stringstream msg;
120  msg << "Error : "
121  << "Unknown class " << val.label();
122  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
123  GUM_ERROR(FatalError, msg.str());
124  }
125 
126  void O3PRM_CLASS_AMBIGUOUS(const O3Label& val,
127  const std::vector< std::string >& matches,
128  ErrorsContainer& errors) {
129  const auto& pos = val.position();
130  std::stringstream msg;
131  msg << "Error : "
132  << "Name " << val.label() << " is ambiguous: ";
133  for (std::size_t i = 0; i < matches.size() - 1; ++i) {
134  msg << matches[i] << ", ";
135  }
136  msg << matches.back();
137  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
138  }
139 
140  void O3PRM_CLASS_DUPLICATE(const O3Label& val, ErrorsContainer& errors) {
141  // Raised if duplicate type names
142  const auto& pos = val.position();
143  std::stringstream msg;
144  msg << "Error : "
145  << "Class name " << val.label() << " exists already";
146  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
147  }
148 
149  void O3PRM_CLASS_CYLIC_INHERITANCE(const O3Label& sub,
150  const O3Label& super,
151  ErrorsContainer& errors) {
152  // Cyclic inheritance
153  const auto& pos = sub.position();
154  std::stringstream msg;
155  msg << "Error : "
156  << "Cyclic inheritance between class " << sub.label() << " and class "
157  << super.label();
158  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
159  }
160 
161 
162  void O3PRM_CLASS_ATTR_IMPLEMENTATION(const O3Label& c,
163  const O3Label& i,
164  const O3Label& attr,
165  ErrorsContainer& errors) {
166  const auto& pos = attr.position();
167  std::stringstream msg;
168  msg << "Error : "
169  << "Class " << c.label() << " attribute " << attr.label()
170  << " does not respect interface " << i.label();
171  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
172  }
173 
174  void O3PRM_CLASS_AGG_IMPLEMENTATION(const O3Label& c,
175  const O3Label& i,
176  const O3Label& attr,
177  ErrorsContainer& errors) {
178  const auto& pos = attr.position();
179  std::stringstream msg;
180  msg << "Error : "
181  << "Class " << c.label() << " aggregate " << attr.label()
182  << " does not respect interface " << i.label();
183  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
184  }
185 
186  void O3PRM_CLASS_REF_IMPLEMENTATION(const O3Label& c,
187  const O3Label& i,
188  const O3Label& ref,
189  ErrorsContainer& errors) {
190  const auto& pos = ref.position();
191  std::stringstream msg;
192  msg << "Error : "
193  << "Class " << c.label() << " reference " << ref.label()
194  << " does not respect interface " << i.label();
195  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
196  }
197 
198 
199  void O3PRM_CLASS_MISSING_ATTRIBUTES(const O3Label& c,
200  const O3Label& i,
201  ErrorsContainer& errors) {
202  const auto& pos = c.position();
203  std::stringstream msg;
204  msg << "Error : "
205  << "Class " << c.label() << " does not implement all of interface "
206  << i.label() << " attributes";
207  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
208  }
209 
210  void O3PRM_CLASS_DUPLICATE_REFERENCE(const O3Label& ref,
211  ErrorsContainer& errors) {
212  const auto& pos = ref.position();
213  std::stringstream msg;
214  msg << "Error : "
215  << "Reference Slot name " << ref.label() << " exists already";
216  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
217  }
218 
219  void O3PRM_CLASS_SELF_REFERENCE(const O3Label& c,
220  const O3Label& ref,
221  ErrorsContainer& errors) {
222  const auto& pos = ref.position();
223  std::stringstream msg;
224  msg << "Error : "
225  << "Class " << c.label() << " cannot reference itself";
226  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
227  }
228 
229  void O3PRM_CLASS_ILLEGAL_SUB_REFERENCE(const O3Label& c,
230  const O3Label& sub,
231  ErrorsContainer& errors) {
232  const auto& pos = sub.position();
233  std::stringstream msg;
234  msg << "Error : "
235  << "Class " << c.label() << " cannot reference subclass "
236  << sub.label();
237  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
238  }
239 
240  void O3PRM_CLASS_PARENT_NOT_FOUND(const O3Label& parent,
241  ErrorsContainer& errors) {
242  const auto& pos = parent.position();
243  std::stringstream msg;
244  msg << "Error : "
245  << "Parent " << parent.label() << " not found";
246  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
247  }
248 
249  void O3PRM_CLASS_ILLEGAL_PARENT(const O3Label& parent,
250  ErrorsContainer& errors) {
251  const auto& pos = parent.position();
252  std::stringstream msg;
253  msg << "Error : "
254  << "Illegal parent " << parent.label();
255  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
256  }
257 
258  void O3PRM_CLASS_LINK_NOT_FOUND(const O3Label& chain,
259  const std::string& s,
260  ErrorsContainer& errors) {
261  const auto& pos = chain.position();
262  std::stringstream msg;
263  msg << "Error : "
264  << "Link " << s << " in chain " << chain.label() << " not found";
265  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
266  }
267 
268  void O3PRM_CLASS_ILLEGAL_CPT_SIZE(const std::string& c,
269  const O3Label& attr,
270  Size found,
271  Size expected,
272  ErrorsContainer& errors) {
273  const auto& pos = attr.position();
274  std::stringstream msg;
275  msg << "Error : "
276  << "Illegal CPT size, expected " << expected << " found " << found
277  << " for attribute " << c << "." << attr.label();
278  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
279  }
280 
281  void O3PRM_CLASS_ILLEGAL_CPT_VALUE(const std::string& c,
282  const O3Label& attr,
283  const O3Formula& f,
284  ErrorsContainer& errors) {
285  const auto& pos = f.position();
286  std::stringstream msg;
287  msg << "Error : "
288  << "Illegal CPT value \"" << f.formula().formula()
289  << "\" in attribute " << c << "." << attr.label();
290  try {
291  auto result = f.formula().result();
292  msg << ", formula resolve to " << result;
293  } catch (...) {
294  msg << ", could not resolve the following formula: "
295  << "\"" << f.formula().formula() << "\"";
296  }
297  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
298  }
299 
300  void O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1(const std::string& c,
301  const O3Label& attr,
302  float f,
303  ErrorsContainer& errors) {
304  const auto& pos = attr.position();
305  std::stringstream msg;
306  msg << "Error : "
307  << "PRMAttribute " << c << "." << attr.label()
308  << " CPT does not sum to 1, found " << f;
309  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
310  }
311 
312  void O3PRM_CLASS_CPT_DOES_NOT_SUM_TO_1_WARNING(const std::string& c,
313  const O3Label& attr,
314  float f,
315  ErrorsContainer& errors) {
316  const auto& pos = attr.position();
317  std::stringstream msg;
318  msg << "Warning : "
319  << "PRMAttribute " << c << "." << attr.label()
320  << " CPT does not sum to 1, found " << f;
321  errors.addWarning(msg.str(), pos.file(), pos.line(), pos.column());
322  }
323 
324  void O3PRM_CLASS_ILLEGAL_RULE_SIZE(const O3RuleCPT::O3Rule& rule,
325  size_t found,
326  size_t expected,
327  ErrorsContainer& errors) {
328  const auto& pos = rule.first.front().position();
329  std::stringstream msg;
330  msg << "Error : "
331  << "Expected " << expected << " value(s), found " << found;
332  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
333  }
334 
335  void O3PRM_CLASS_ILLEGAL_RULE_LABEL(const O3RuleCPT::O3Rule& rule,
336  const O3Label& label,
337  const O3Label& parent,
338  ErrorsContainer& errors) {
339  const auto& pos = label.position();
340  std::stringstream msg;
341  msg << "Error : "
342  << "Label " << label << " is not part of " << parent << " domain";
343  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
344  }
345 
346  void O3PRM_CLASS_WRONG_PARENT(const O3Label& prnt, ErrorsContainer& errors) {
347  const auto& pos = prnt.position();
348  std::stringstream msg;
349  msg << "Error : "
350  << "Illegal parent " << prnt;
351  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
352  }
353 
354  void O3PRM_CLASS_WRONG_PARENT_TYPE(const O3Label& prnt,
355  const std::string& expected,
356  const std::string& found,
357  ErrorsContainer& errors) {
358  const auto& pos = prnt.position();
359  std::stringstream msg;
360  msg << "Error : "
361  << "Expected type " << expected << " for parent " << prnt.label()
362  << ", found " << found;
363  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
364  }
365 
366  void O3PRM_CLASS_ILLEGAL_OVERLOAD(const O3Label& elt,
367  const O3Label& c,
368  ErrorsContainer& errors) {
369  const auto& pos = elt.position();
370  std::stringstream msg;
371  msg << "Error : "
372  << "Illegal overload of element " << elt.label() << " from class "
373  << c.label();
374  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
375  }
376 
377  void O3PRM_CLASS_AGG_PARAMETERS(const O3Label& agg,
378  Size expected,
379  Size found,
380  ErrorsContainer& errors) {
381  const auto& pos = agg.position();
382  std::stringstream msg;
383  msg << "Error : "
384  << "Expected " << expected << " parameters "
385  << ", found " << found;
386  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
387  }
388 
389  void O3PRM_CLASS_AGG_PARAMETER_NOT_FOUND(const O3Label& agg,
390  const O3Label& param,
391  ErrorsContainer& errors) {
392  const auto& pos = param.position();
393  std::stringstream msg;
394  msg << "Error : "
395  << "Parameter " << param.label() << " in aggregate " << agg.label()
396  << " does not match any expected values";
397  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
398  }
399 
400  void O3PRM_INTERFACE_ILLEGAL_ARRAY(const O3Label& val,
401  ErrorsContainer& errors) {
402  const auto& pos = val.position();
403  std::stringstream msg;
404  msg << "Error : "
405  << "PRMAttribute " << val.label() << " can not be an array";
406  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
407  }
408 
409  void O3PRM_INTERFACE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
410  const auto& pos = val.position();
411  std::stringstream msg;
412  msg << "Error : "
413  << "Interface " << val.label() << " not found";
414  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
415  }
416 
417  void O3PRM_INTERFACE_AMBIGUOUS(const O3Label& val,
418  const std::vector< std::string >& matches,
419  ErrorsContainer& errors) {
420  const auto& pos = val.position();
421  std::stringstream msg;
422  msg << "Error : "
423  << "Name " << val.label() << " is ambiguous: ";
424  for (std::size_t i = 0; i < matches.size() - 1; ++i) {
425  msg << matches[i] << ", ";
426  }
427  msg << matches.back();
428  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
429  }
430 
431  void O3PRM_INTERFACE_DUPLICATE(const O3Label& val, ErrorsContainer& errors) {
432  const auto& pos = val.position();
433  std::stringstream msg;
434  msg << "Error : "
435  << "Interface name " << val.label() << " exists already";
436  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
437  }
438 
439  void O3PRM_INTERFACE_DUPLICATE_ELEMENT(const O3InterfaceElement& elt,
440  ErrorsContainer& errors) {
441  const auto& pos = elt.type().position();
442  std::stringstream msg;
443  msg << "Error : "
444  << "Element " << elt.name().label() << " already exists";
445  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
446  }
447 
448  void O3PRM_INTERFACE_CYCLIC_INHERITANCE(const O3Label& sub,
449  const O3Label& super,
450  ErrorsContainer& errors) {
451  const auto& pos = super.position();
452  std::stringstream msg;
453  msg << "Error : "
454  << "Cyclic inheritance between interface " << sub.label()
455  << " and interface " << super.label();
456  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
457  }
458 
459  void O3PRM_INTERFACE_SELF_REFERENCE(const O3Interface& i,
460  const O3InterfaceElement& r,
461  ErrorsContainer& errors) {
462  const auto& pos = r.type().position();
463  std::stringstream msg;
464  msg << "Error : "
465  << "Interface " << i.name().label() << " cannot reference itself";
466  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
467  }
468 
469  void O3PRM_INTERFACE_ILLEGAL_SUB_REFERENCE(const O3Interface& i,
470  const O3InterfaceElement& ref,
471  ErrorsContainer& errors) {
472  const auto& pos = ref.type().position();
473  std::stringstream msg;
474  msg << "Error : "
475  << "Interface " << i.name().label()
476  << " cannot reference subinterface " << ref.type().label();
477  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
478  }
479 
480  void O3PRM_INTERFACE_ILLEGAL_OVERLOAD(const O3InterfaceElement& elt,
481  ErrorsContainer& errors) {
482  const auto& pos = elt.type().position();
483  std::stringstream msg;
484  msg << "Error : "
485  << "Illegal overload of element " << elt.name().label();
486  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
487  }
488 
489  void O3PRM_REFERENCE_NOT_FOUND(const O3Label& val, ErrorsContainer& errors) {
490  const auto& pos = val.position();
491  std::stringstream msg;
492  msg << "Error : "
493  << "Reference Slot type " << val.label() << " not found";
494  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
495  }
496 
497  void O3PRM_REFERENCE_AMBIGUOUS(const O3Label& val,
498  const std::vector< std::string >& matches,
499  ErrorsContainer& errors) {
500  const auto& pos = val.position();
501  std::stringstream msg;
502  msg << "Error : "
503  << "Name " << val.label() << " is ambiguous: ";
504  for (std::size_t i = 0; i < matches.size() - 1; ++i) {
505  msg << matches[i] << ", ";
506  }
507  msg << matches.back();
508  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
509  }
510 
511  void O3PRM_SYSTEM_INSTANTIATION_FAILED(const O3System& sys,
512  ErrorsContainer& errors) {
513  const auto& pos = sys.name().position();
514  std::stringstream msg;
515  msg << "Error : "
516  << "Could not instantiate the system, some reference slots must be "
517  "unassigned";
518  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
519  }
520 
521  void O3PRM_SYSTEM_NOT_A_CLASS(const O3Instance& i, ErrorsContainer& errors) {
522  const auto& pos = i.type().position();
523  std::stringstream msg;
524  msg << "Error : " << i.type().label() << " is not a class";
525  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
526  }
527 
528  void O3PRM_SYSTEM_DUPLICATE_INSTANCE(const O3Instance& i,
529  ErrorsContainer& errors) {
530  const auto& pos = i.type().position();
531  std::stringstream msg;
532  msg << "Error : "
533  << "Instance " << i.name().label() << " already exists";
534  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
535  }
536 
537  void O3PRM_SYSTEM_NOT_A_PARAMETER(const O3InstanceParameter& param,
538  ErrorsContainer& errors) {
539  const auto& pos = param.name().position();
540  std::stringstream msg;
541  msg << "Instance error : " << param.name().label()
542  << " is not a parameter";
543  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
544  }
545 
546  void O3PRM_SYSTEM_PARAMETER_NOT_FOUND(const O3InstanceParameter& param,
547  ErrorsContainer& errors) {
548  const auto& pos = param.name().position();
549  std::stringstream msg;
550  msg << "Error : "
551  << "Parameter " << param.name().label() << " not found";
552  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
553  }
554 
555  void O3PRM_SYSTEM_PARAMETER_NOT_INT(const O3InstanceParameter& param,
556  ErrorsContainer& errors) {
557  const auto& pos = param.value().position();
558  std::stringstream msg;
559  msg << "Error : "
560  << "Parameter " << param.name().label() << " is an integer";
561  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
562  }
563 
564  void O3PRM_SYSTEM_PARAMETER_NOT_FLOAT(const O3InstanceParameter& param,
565  ErrorsContainer& errors) {
566  const auto& pos = param.value().position();
567  std::stringstream msg;
568  msg << "Error : "
569  << "Parameter " << param.name().label() << " is a float";
570  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
571  }
572 
573  void O3PRM_SYSTEM_INVALID_LEFT_VALUE(const O3Label& val,
574  ErrorsContainer& errors) {
575  const auto& pos = val.position();
576  std::stringstream msg;
577  msg << "Error : "
578  << "Invalid left expression " << val.label();
579  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
580  }
581 
582  void O3PRM_SYSTEM_INSTANCE_NOT_FOUND(const O3Label& i,
583  ErrorsContainer& errors) {
584  const auto& pos = i.position();
585  std::stringstream msg;
586  msg << "Error : "
587  << "Instance " << i.label() << " not found";
588  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
589  }
590 
591  void O3PRM_SYSTEM_REFERENCE_NOT_FOUND(const O3Label& ref,
592  const std::string& type,
593  ErrorsContainer& errors) {
594  const auto& pos = ref.position();
595  std::stringstream msg;
596  msg << "Error : "
597  << "Reference " << ref.label() << " not found in class " << type;
598  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
599  }
600 
601  void O3PRM_SYSTEM_NOT_AN_ARRAY(const O3Label& val, ErrorsContainer& errors) {
602  const auto& pos = val.position();
603  std::stringstream msg;
604  msg << "Error : " << val.label() << " is not an array";
605  errors.addError(msg.str(), pos.file(), pos.line(), pos.column());
606  }
607 
608  void O3PRM_DEPRECATED_TYPE_WARNING(const O3Label& val,
609  ErrorsContainer& errors) {
610  const auto& pos = val.position();
611  std::stringstream msg;
612  msg << "Warning : " << val.label()
613  << " is declared using a deprecated syntax.";
614  errors.addWarning(msg.str(), pos.file(), pos.line(), pos.column());
615  }
616 
617 
618  } // namespace o3prm
619  } // namespace prm
620 } // namespace gum
621 
622 #endif // DOXYGEN_SHOULD_SKIP_THIS
gum::prm::o3prm::O3RuleCPT::O3Rule
std::pair< O3LabelList, O3FormulaList > O3Rule
Definition: O3prm.h:544
errors.h
Functions for error messages.
gum
gum is the global namespace for all aGrUM entities
Definition: agrum.h:25
gum::Size
std::size_t Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:45
GUM_ERROR
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
aGrUM 0.14.2
Thu Feb 28 2019 14:11:17
© CG&PHW&others - LIP6 2005-2007-2012
DoXyGeN 1.8.13