aGrUM  0.13.2
O3prm.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/O3prm.h>
30 
31 namespace gum {
32  namespace prm {
33  namespace o3prm {
34 
35  O3Position::O3Position() : __file(""), __line(0), __column(0) {
36  GUM_CONSTRUCTOR(O3Position);
37  }
38 
39  O3Position::O3Position(const std::string& file, int line, int column) :
40  __file(file), __line(line), __column(column) {
41  GUM_CONSTRUCTOR(O3Position);
42  }
43 
45  __file(src.__file), __line(src.__line), __column(src.__column) {
46  GUM_CONS_CPY(O3Position);
47  }
48 
50  __file(std::move(src.__file)), __line(std::move(src.__line)),
51  __column(std::move(src.__column)) {
52  GUM_CONS_MOV(O3Position);
53  }
54 
55  O3Position::~O3Position() { GUM_DESTRUCTOR(O3Position); }
56 
58  if (this == &src) { return *this; }
59  __file = src.__file;
60  __line = src.__line;
61  __column = src.__column;
62  return *this;
63  }
64 
66  if (this == &src) { return *this; }
67  __file = std::move(src.__file);
68  __line = std::move(src.__line);
69  __column = std::move(src.__column);
70  return *this;
71  }
72 
73  std::string& O3Position::file() { return __file; }
74  const std::string& O3Position::file() const { return __file; }
75 
76  int& O3Position::line() { return __line; }
77  int O3Position::line() const { return __line; }
78 
79  int& O3Position::column() { return __column; }
80  int O3Position::column() const { return __column; }
81 
82  O3Integer::O3Integer() : __pos(), __value(0) { GUM_CONSTRUCTOR(O3Integer); }
83 
85  __pos(pos), __value(value) {
86  GUM_CONSTRUCTOR(O3Integer);
87  }
88 
90  __pos(src.__pos), __value(src.__value) {
91  GUM_CONS_CPY(O3Integer);
92  }
93 
95  __pos(std::move(src.__pos)), __value(std::move(src.__value)) {
96  GUM_CONS_MOV(O3Integer);
97  }
98 
99  O3Integer::~O3Integer() { GUM_DESTRUCTOR(O3Integer); }
100 
102  if (this == &src) { return *this; }
103  __pos = src.__pos;
104  __value = src.__value;
105  return *this;
106  }
107 
109  if (this == &src) { return *this; }
110  __pos = std::move(src.__pos);
111  __value = std::move(src.__value);
112  return *this;
113  }
114 
115  const O3Position& O3Integer::position() const { return __pos; }
117 
118  int O3Integer::value() const { return __value; }
119  int& O3Integer::value() { return __value; }
120 
121  O3Float::O3Float() { GUM_CONSTRUCTOR(O3Float); }
122 
123  O3Float::O3Float(const O3Position& pos, float value) :
124  __pos(pos), __value(value) {
125  GUM_CONSTRUCTOR(O3Float);
126  }
127 
128  O3Float::O3Float(const O3Float& src) :
129  __pos(src.__pos), __value(src.__value) {
130  GUM_CONS_CPY(O3Float);
131  }
132 
134  __pos(std::move(src.__pos)), __value(std::move(src.__value)) {
135  GUM_CONS_MOV(O3Float);
136  }
137 
138  O3Float::~O3Float() { GUM_DESTRUCTOR(O3Float); }
139 
141  if (this == &src) { return *this; }
142  __pos = src.__pos;
143  __value = src.__value;
144  return *this;
145  }
146 
148  if (this == &src) { return *this; }
149  __pos = std::move(src.__pos);
150  __value = std::move(src.__value);
151  return *this;
152  }
153 
154  const O3Position& O3Float::position() const { return __pos; }
156 
157  float O3Float::value() const { return __value; }
158  float& O3Float::value() { return __value; }
159 
161  __pos(), __formula(std::unique_ptr< Formula >(new Formula(""))) {
162  GUM_CONSTRUCTOR(O3Formula);
163  }
164 
166  __pos(pos), __formula(std::unique_ptr< Formula >(new Formula(formula))) {
167  GUM_CONSTRUCTOR(O3Formula);
168  }
169 
171  __pos(src.__pos),
172  __formula(std::unique_ptr< Formula >(new Formula(src.formula()))) {
173  GUM_CONS_CPY(O3Formula);
174  }
175 
177  __pos(std::move(src.__pos)), __formula(std::move(src.__formula)) {
178  GUM_CONS_MOV(O3Formula);
179  }
180 
181  O3Formula::~O3Formula() { GUM_DESTRUCTOR(O3Formula); }
182 
184  if (this == &src) { return *this; }
185  __pos = src.__pos;
186  __formula = std::unique_ptr< Formula >(new Formula(src.formula()));
187  return *this;
188  }
189 
191  if (this == &src) { return *this; }
192  __pos = std::move(src.__pos);
193  __formula = std::move(src.__formula);
194  return *this;
195  }
196 
197  const O3Position& O3Formula::position() const { return __pos; }
199 
200  const Formula& O3Formula::formula() const { return *__formula; }
202 
203  O3Label::O3Label() : __pos(), __label() { GUM_CONSTRUCTOR(O3Label); }
204 
205  O3Label::O3Label(const O3Position& pos, const std::string& label) :
206  __pos(pos), __label(label) {
207  GUM_CONSTRUCTOR(O3Label);
208  }
209 
210  O3Label::O3Label(const O3Label& src) :
211  __pos(src.__pos), __label(src.__label) {
212  GUM_CONS_CPY(O3Label);
213  }
214 
216  __pos(std::move(src.__pos)), __label(std::move(src.__label)) {
217  GUM_CONS_MOV(O3Label);
218  }
219 
220  O3Label::~O3Label() { GUM_DESTRUCTOR(O3Label); }
221 
223  if (this == &src) { return *this; }
224  __pos = src.__pos;
225  __label = src.__label;
226  return *this;
227  }
228 
230  if (this == &src) { return *this; }
231  __pos = std::move(src.__pos);
232  __label = std::move(src.__label);
233  return *this;
234  }
235 
236  const O3Position& O3Label::position() const { return __pos; }
238 
239  const std::string& O3Label::label() const { return __label; }
240  std::string& O3Label::label() { return __label; }
241 
242  O3Type::O3Type() : __dep_flag(false) { GUM_CONSTRUCTOR(O3Type); }
243 
244  O3Type::O3Type(const O3Type& src) :
247  GUM_CONS_CPY(O3Type);
248  }
249 
251  __pos(std::move(src.__pos)), __name(std::move(src.__name)),
252  __superLabel(std::move(src.__superLabel)),
253  __labels(std::move(src.__labels)),
254  __dep_flag(std::move(src.__dep_flag)) {
255  GUM_CONS_MOV(O3Type);
256  }
257 
258  O3Type::~O3Type() { GUM_DESTRUCTOR(O3Type); }
259 
261  if (this == &src) { return *this; }
262  __pos = src.__pos;
263  __name = src.__name;
265  __labels = src.__labels;
266  __dep_flag = src.__dep_flag;
267  return *this;
268  }
269 
271  if (this == &src) { return *this; }
272  __pos = std::move(src.__pos);
273  __name = std::move(src.__name);
274  __superLabel = std::move(src.__superLabel);
275  __labels = std::move(src.__labels);
276  __dep_flag = std::move(src.__dep_flag);
277  return *this;
278  }
279 
280  O3Label& O3Type::name() { return __name; }
281  const O3Label& O3Type::name() const { return __name; }
282 
284  const O3Label& O3Type::superLabel() const { return __superLabel; }
285 
287  const O3Type::LabelMap& O3Type::labels() const { return __labels; }
288 
290  const O3Position& O3Type::position() const { return __pos; }
291 
292  bool& O3Type::deprecated() { return __dep_flag; }
293  const bool& O3Type::deprecated() const { return __dep_flag; }
294 
295  O3IntType::O3IntType() : __dep_flag(false) { GUM_CONSTRUCTOR(O3IntType); }
296 
298  __pos(src.__pos), __name(src.__name), __start(src.__start),
299  __end(src.__end), __dep_flag(src.__dep_flag) {
300  GUM_CONS_CPY(O3IntType);
301  }
302 
304  __pos(std::move(src.__pos)), __name(std::move(src.__name)),
305  __start(std::move(src.__start)), __end(std::move(src.__end)),
306  __dep_flag(std::move(src.__dep_flag)) {
307  GUM_CONS_MOV(O3IntType);
308  }
309 
310  O3IntType::~O3IntType() { GUM_DESTRUCTOR(O3IntType); }
311 
313  if (this == &src) { return *this; }
314  __pos = src.__pos;
315  __name = src.__name;
316  __start = src.__start;
317  __end = src.__end;
318  __dep_flag = src.__dep_flag;
319  return *this;
320  }
321 
323  if (this == &src) { return *this; }
324  __pos = std::move(src.__pos);
325  __name = std::move(src.__name);
326  __start = std::move(src.__start);
327  __end = std::move(src.__end);
328  __dep_flag = std::move(src.__dep_flag);
329  return *this;
330  }
331 
333  const O3Label& O3IntType::name() const { return __name; }
334 
336  const O3Integer& O3IntType::start() const { return __start; }
337 
339  const O3Integer& O3IntType::end() const { return __end; }
340 
342  const O3Position& O3IntType::position() const { return __pos; }
343 
344  bool& O3IntType::deprecated() { return __dep_flag; }
345  const bool& O3IntType::deprecated() const { return __dep_flag; }
346 
347  O3RealType::O3RealType() : __dep_flag(false) { GUM_CONSTRUCTOR(O3RealType); }
348 
350  __pos(src.__pos), __name(src.__name), __values(src.__values),
351  __dep_flag(src.__dep_flag) {
352  GUM_CONS_CPY(O3RealType);
353  }
354 
356  __pos(std::move(src.__pos)), __name(std::move(src.__name)),
357  __values(std::move(src.__values)),
358  __dep_flag(std::move(src.__dep_flag)) {
359  GUM_CONS_MOV(O3RealType);
360  }
361 
362  O3RealType::~O3RealType() { GUM_DESTRUCTOR(O3RealType); }
363 
365  if (this == &src) { return *this; }
366 
367  __pos = src.__pos;
368  __name = src.__name;
369  __values = src.__values;
370  __dep_flag = src.__dep_flag;
371  return *this;
372  }
373 
375  if (this == &src) { return *this; }
376 
377  __pos = std::move(src.__pos);
378  __name = std::move(src.__name);
379  __values = std::move(src.__values);
380  __dep_flag = std::move(src.__dep_flag);
381  return *this;
382  }
383 
385  const O3Position& O3RealType::position() const { return __pos; }
386 
388  const O3Label& O3RealType::name() const { return __name; }
389 
390  std::vector< O3Float >& O3RealType::values() { return __values; }
391  const std::vector< O3Float >& O3RealType::values() const { return __values; }
392 
393  bool& O3RealType::deprecated() { return __dep_flag; }
394  const bool& O3RealType::deprecated() const { return __dep_flag; }
395 
397  GUM_CONSTRUCTOR(O3PRM);
398  // Creating the boolean type
399  auto name = O3Label(O3Position(), "boolean");
400  auto f = O3Label(O3Position(), "false");
401  auto t = O3Label(O3Position(), "true");
402  auto labels = O3Type::LabelMap();
403  labels.push_back(O3Type::LabelPair(f, O3Label()));
404  labels.push_back(O3Type::LabelPair(t, O3Label()));
405  auto boolean = std::unique_ptr< O3Type >(new O3Type());
406  boolean->name() = std::move(name);
407  boolean->labels() = std::move(labels);
408  __types.push_back(std::move(boolean));
409  }
410 
411  O3PRM::O3PRM(const O3PRM& src) {
412  GUM_CONS_CPY(O3PRM);
413  for (const auto& t : src.__types) {
414  __types.emplace_back(new O3Type(*t));
415  }
416  for (const auto& t : src.__int_types) {
417  __int_types.emplace_back(new O3IntType(*t));
418  }
419  for (const auto& t : src.__real_types) {
420  __real_types.emplace_back(new O3RealType(*t));
421  }
422  for (const auto& i : src.__interfaces) {
423  __interfaces.emplace_back(new O3Interface(*i));
424  }
425  for (const auto& c : src.__classes) {
426  __classes.emplace_back(new O3Class(*c));
427  }
428  for (const auto& s : src.__systems) {
429  __systems.emplace_back(new O3System(*s));
430  }
431  for (const auto& i : src.__imports) {
432  __imports.emplace_back(new O3Import(*i));
433  }
434  }
435 
437  __types(std::move(src.__types)), __int_types(std::move(src.__int_types)),
438  __real_types(std::move(src.__real_types)),
439  __interfaces(std::move(src.__interfaces)),
440  __classes(std::move(src.__classes)), __systems(std::move(src.__systems)),
441  __imports(std::move(src.__imports)) {
442  GUM_CONS_MOV(O3PRM);
443  }
444 
445  O3PRM::~O3PRM() { GUM_DESTRUCTOR(O3PRM); }
446 
447  O3PRM& O3PRM::operator=(const O3PRM& src) {
448  if (this == &src) { return *this; }
449  for (const auto& t : src.__types) {
450  __types.emplace_back(new O3Type(*t));
451  }
452  for (const auto& t : src.__int_types) {
453  __int_types.emplace_back(new O3IntType(*t));
454  }
455  for (const auto& t : src.__real_types) {
456  __real_types.emplace_back(new O3RealType(*t));
457  }
458  for (const auto& i : src.__interfaces) {
459  __interfaces.emplace_back(new O3Interface(*i));
460  }
461  for (const auto& c : src.__classes) {
462  __classes.emplace_back(new O3Class(*c));
463  }
464  for (const auto& s : src.__systems) {
465  __systems.emplace_back(new O3System(*s));
466  }
467  for (const auto& i : src.__imports) {
468  __imports.emplace_back(new O3Import(*i));
469  }
470  return *this;
471  }
472 
474  if (this == &src) { return *this; }
475  __types = std::move(src.__types);
476  __int_types = std::move(src.__int_types);
477  __real_types = std::move(src.__real_types);
478  __interfaces = std::move(src.__interfaces);
479  __classes = std::move(src.__classes);
480  __systems = std::move(src.__systems);
481  __imports = std::move(src.__imports);
482  return *this;
483  }
484 
486  const O3PRM::O3TypeList& O3PRM::types() const { return __types; }
487 
490 
493  return __real_types;
494  }
495 
498  return __interfaces;
499  }
500 
502 
503  const O3PRM::O3ClassList& O3PRM::classes() const { return __classes; }
504 
506 
507  const O3PRM::O3SystemList& O3PRM::systems() const { return __systems; }
508 
510 
511  const O3PRM::O3ImportList& O3PRM::imports() const { return __imports; }
512 
514  GUM_CONSTRUCTOR(O3InterfaceElement);
515  }
516 
518  const O3Label& name,
519  bool isArray) :
520  __type(type),
521  __name(name), __isArray(isArray) {
522  GUM_CONSTRUCTOR(O3InterfaceElement);
523  }
524 
526  __type(src.__type), __name(src.__name), __isArray(src.__isArray) {
527  GUM_CONS_CPY(O3InterfaceElement);
528  }
529 
531  __type(std::move(src.__type)), __name(std::move(src.__name)),
532  __isArray(std::move(src.__isArray)) {
533  GUM_CONS_MOV(O3InterfaceElement);
534  }
535 
537  GUM_DESTRUCTOR(O3InterfaceElement);
538  }
539 
542  if (this == &src) { return *this; }
543  __type = src.__type;
544  __name = src.__name;
545  __isArray = src.__isArray;
546  return *this;
547  }
548 
550  if (this == &src) { return *this; }
551  __type = std::move(src.__type);
552  __name = std::move(src.__name);
553  __isArray = std::move(src.__isArray);
554  return *this;
555  }
556 
558  const O3Label& O3InterfaceElement::type() const { return __type; }
559 
561  const O3Label& O3InterfaceElement::name() const { return __name; }
562 
564  bool O3InterfaceElement::isArray() const { return __isArray; }
565 
567  GUM_CONSTRUCTOR(O3Interface);
568  }
569 
571  __pos(src.__pos), __name(src.__name), __superLabel(src.__superLabel) {
572  GUM_CONS_CPY(O3Interface);
573  auto copy = new O3InterfaceElementList(src.elements());
574  __elts = std::unique_ptr< O3InterfaceElementList >(copy);
575  }
576 
578  __pos(std::move(src.__pos)), __name(std::move(src.__name)),
579  __superLabel(std::move(src.__superLabel)),
580  __elts(std::move(src.__elts)) {
581  GUM_CONS_MOV(O3Interface);
582  }
583 
584  O3Interface::~O3Interface() { GUM_DESTRUCTOR(O3Interface); }
585 
587  if (this == &src) { return *this; }
588  __pos = src.__pos;
589  __name = src.__name;
591  auto copy = new O3InterfaceElementList(src.elements());
592  __elts = std::unique_ptr< O3InterfaceElementList >(copy);
593  return *this;
594  }
595 
597  if (this == &src) { return *this; }
598  __pos = std::move(src.__pos);
599  __name = std::move(src.__name);
600  __superLabel = std::move(src.__superLabel);
601  __elts = std::move(src.__elts);
602  return *this;
603  }
604 
606  const O3Position& O3Interface::position() const { return __pos; }
607 
609  const O3Label& O3Interface::name() const { return __name; }
610 
612  const O3Label& O3Interface::superLabel() const { return __superLabel; }
613 
615  return *__elts;
616  }
618  return *__elts;
619  }
620 
621  O3Attribute::O3Attribute() { GUM_CONSTRUCTOR(O3Attribute); }
622 
624  const O3Label& name,
625  const O3LabelList& parents) :
626  __type(type),
627  __name(name), __parents(parents) {
628  GUM_CONSTRUCTOR(O3Attribute);
629  }
630 
632  __type(src.__type), __name(src.__name), __parents(src.__parents) {
633  GUM_CONS_CPY(O3Attribute);
634  }
635 
637  __type(std::move(src.__type)), __name(std::move(src.__name)),
638  __parents(std::move(src.__parents)) {
639  GUM_CONS_MOV(O3Attribute);
640  }
641 
642  O3Attribute::~O3Attribute() { GUM_DESTRUCTOR(O3Attribute); }
643 
645  if (this == &src) { return *this; }
646  __type = src.__type;
647  __name = src.__name;
648  __parents = src.__parents;
649  return *this;
650  }
651 
653  if (this == &src) { return *this; }
654  __type = std::move(src.__type);
655  __name = std::move(src.__name);
656  __parents = std::move(src.__parents);
657  return *this;
658  }
659 
661  const O3Label& O3Attribute::type() const { return __type; }
662 
664  const O3Label& O3Attribute::name() const { return __name; }
665 
668  return __parents;
669  }
670 
672  GUM_CONSTRUCTOR(O3RawCPT);
673  }
674 
676  const O3Label& name,
677  const O3LabelList& parents,
678  const O3FormulaList& values) :
679  O3Attribute(type, name, parents) {
680  GUM_CONSTRUCTOR(O3RawCPT);
681  auto copy = new O3FormulaList(values);
682  __values = std::unique_ptr< O3FormulaList >(copy);
683  }
684 
686  GUM_CONS_CPY(O3RawCPT);
687  auto copy = new O3FormulaList(*(src.__values));
688  __values = std::unique_ptr< O3FormulaList >(copy);
689  }
690 
692  O3Attribute(src), __values(std::move(src.__values)) {
693  GUM_CONS_MOV(O3RawCPT);
694  }
695 
696  O3RawCPT::~O3RawCPT() { GUM_DESTRUCTOR(O3RawCPT); }
697 
699  if (this == &src) { return *this; }
701  auto copy = new O3FormulaList(*(src.__values));
702  __values = std::unique_ptr< O3FormulaList >(copy);
703  return *this;
704  }
705 
707  if (this == &src) { return *this; }
709  __values = std::move(src.__values);
710  return *this;
711  }
712 
714 
716 
717  std::unique_ptr< O3Attribute > O3RawCPT::copy() const {
718  auto copy = new O3RawCPT(*this);
719  return std::unique_ptr< O3Attribute >(copy);
720  }
721 
723  GUM_CONSTRUCTOR(O3RuleCPT);
724  }
725 
727  const O3Label& name,
729  O3RuleList&& rules) :
730  O3Attribute(type, name, parents),
731  __rules(std::unique_ptr< O3RuleList >(new O3RuleList(rules))) {
732  GUM_CONSTRUCTOR(O3RuleCPT);
733  }
734 
736  O3Attribute(src),
737  __rules(std::unique_ptr< O3RuleList >(new O3RuleList(src.rules()))) {
738  GUM_CONS_CPY(O3RuleCPT);
739  }
740 
742  O3Attribute(src), __rules(std::move(src.__rules)) {
743  GUM_CONS_MOV(O3RuleCPT);
744  }
745 
746  O3RuleCPT::~O3RuleCPT() { GUM_DESTRUCTOR(O3RuleCPT); }
747 
749  if (this == &src) { return *this; }
750 
752  __rules = std::unique_ptr< O3RuleList >(new O3RuleList(src.rules()));
753  return *this;
754  }
755 
757  if (this == &src) { return *this; }
758 
760  __rules = std::move(src.__rules);
761  return *this;
762  }
763 
765  const O3RuleCPT::O3RuleList& O3RuleCPT::rules() const { return *__rules; }
766 
767  std::unique_ptr< O3Attribute > O3RuleCPT::copy() const {
768  auto copy = new O3RuleCPT(*this);
769  return std::unique_ptr< O3Attribute >(copy);
770  }
771 
773  GUM_CONSTRUCTOR(O3Class);
774 
775  auto i = new O3LabelList();
776  __interfaces = std::unique_ptr< O3LabelList >(i);
777 
778  auto p = new O3ParameterList();
779  __params = std::unique_ptr< O3ParameterList >(p);
780 
781  auto r = new O3ReferenceSlotList();
782  __refs = std::unique_ptr< O3ReferenceSlotList >(r);
783 
784  auto e = new O3AttributeList();
785  __attrs = std::unique_ptr< O3AttributeList >(e);
786 
787  auto a = new O3AggregateList();
788  __aggs = std::unique_ptr< O3AggregateList >(a);
789  }
790 
791  O3Class::O3Class(const O3Class& src) :
792  __pos(src.__pos), __name(src.__name), __superLabel(src.__superLabel) {
793  GUM_CONS_CPY(O3Class);
794  auto i = new O3LabelList(src.interfaces());
795  __interfaces = std::unique_ptr< O3LabelList >(i);
796 
797  auto p = new O3ParameterList(src.parameters());
798  __params = std::unique_ptr< O3ParameterList >(p);
799 
800  auto r = new O3ReferenceSlotList(src.referenceSlots());
801  __refs = std::unique_ptr< O3ReferenceSlotList >(r);
802 
803  auto e = new O3AttributeList();
804  __attrs = std::unique_ptr< O3AttributeList >(e);
805  for (const auto& elt : src.attributes()) {
806  __attrs->push_back(elt->copy());
807  }
808 
809  auto a = new O3AggregateList(src.aggregates());
810  __aggs = std::unique_ptr< O3AggregateList >(a);
811  }
812 
814  __pos(std::move(src.__pos)), __name(std::move(src.__name)),
815  __superLabel(std::move(src.__superLabel)),
816  __interfaces(std::move(src.__interfaces)),
817  __params(std::move(src.__params)), __refs(std::move(src.__refs)),
818  __attrs(std::move(src.__attrs)), __aggs(std::move(src.__aggs)) {
819  GUM_CONS_MOV(O3Class);
820  }
821 
822  O3Class::~O3Class() { GUM_DESTRUCTOR(O3Class); }
823 
825  if (this == &src) { return *this; }
826  __pos = src.__pos;
827  __name = src.__name;
829 
830  auto i = new O3LabelList(src.interfaces());
831  __interfaces = std::unique_ptr< O3LabelList >(i);
832 
833  auto p = new O3ParameterList(src.parameters());
834  __params = std::unique_ptr< O3ParameterList >(p);
835 
836  auto r = new O3ReferenceSlotList(src.referenceSlots());
837  __refs = std::unique_ptr< O3ReferenceSlotList >(r);
838 
839  auto e = new O3AttributeList();
840  __attrs = std::unique_ptr< O3AttributeList >(e);
841  for (const auto& elt : src.attributes()) {
842  __attrs->push_back(elt->copy());
843  }
844 
845  auto a = new O3AggregateList(src.aggregates());
846  __aggs = std::unique_ptr< O3AggregateList >(a);
847  return *this;
848  }
849 
851  if (this == &src) { return *this; }
852  __pos = std::move(src.__pos);
853  __name = std::move(src.__name);
854  __superLabel = std::move(src.__superLabel);
855  __interfaces = std::move(src.__interfaces);
856  __params = std::move(src.__params);
857  __refs = std::move(src.__refs);
858  __attrs = std::move(src.__attrs);
859  __aggs = std::move(src.__aggs);
860  return *this;
861  }
862 
863  const O3Position& O3Class::position() const { return __pos; }
865 
866  const O3Label& O3Class::name() const { return __name; }
867  O3Label& O3Class::name() { return __name; }
868 
869  const O3Label& O3Class::superLabel() const { return __superLabel; }
871 
873  return *__interfaces;
874  }
876 
878  return *__params;
879  }
881 
883  return *__refs;
884  }
886 
888 
890  return *__attrs;
891  }
892 
895  return *__aggs;
896  }
897 
899  GUM_CONSTRUCTOR(O3Parameter);
900  }
901 
903  const O3Label& name,
904  const O3Integer& value) :
905  __type(O3Parameter::PRMType::INT),
906  __pos(pos), __name(name),
907  __value(O3Float(value.position(), (float)value.value())) {
908  GUM_CONSTRUCTOR(O3Parameter);
909  }
910 
912  const O3Label& name,
913  const O3Float& value) :
914  __type(O3Parameter::PRMType::FLOAT),
915  __pos(pos), __name(name), __value(value) {
916  GUM_CONSTRUCTOR(O3Parameter);
917  }
918 
920  __type(src.__type), __pos(src.__pos), __name(src.__name),
921  __value(src.__value) {
922  GUM_CONS_CPY(O3Parameter);
923  }
924 
926  __type(std::move(src.__type)), __pos(std::move(src.__pos)),
927  __name(std::move(src.__name)), __value(std::move(src.__value)) {
928  GUM_CONS_MOV(O3Parameter);
929  }
930 
931  O3Parameter::~O3Parameter() { GUM_DESTRUCTOR(O3Parameter); }
932 
934  if (this == &src) { return *this; }
935  __type = src.__type;
936  __pos = src.__pos;
937  __name = src.__name;
938  __value = src.__value;
939  return *this;
940  }
941 
943  if (this == &src) { return *this; }
944  __type = std::move(src.__type);
945  __pos = std::move(src.__pos);
946  __name = std::move(src.__name);
947  __value = std::move(src.__value);
948  return *this;
949  }
950 
953 
955  const O3Position& O3Parameter::position() const { return __pos; }
956 
958  const O3Label& O3Parameter::name() const { return __name; }
959 
961  const O3Float& O3Parameter::value() const { return __value; }
962 
964 
966  const O3Label& name,
967  bool isArray) :
968  __type(type),
969  __name(name), __isArray(isArray) {
970  GUM_CONSTRUCTOR(O3ReferenceSlot);
971  }
972 
974  __type(src.__type), __name(src.__name), __isArray(src.__isArray) {
975  GUM_CONS_CPY(O3ReferenceSlot);
976  }
977 
979  __type(std::move(src.__type)), __name(std::move(src.__name)),
980  __isArray(std::move(src.__isArray)) {
981  GUM_CONS_MOV(O3ReferenceSlot);
982  }
983 
985 
987  if (this == &src) { return *this; }
988  __type = src.__type;
989  __name = src.__name;
990  __isArray = src.__isArray;
991  return *this;
992  }
993 
995  if (this == &src) { return *this; }
996  __type = std::move(src.__type);
997  __name = std::move(src.__name);
998  __isArray = std::move(src.__isArray);
999  return *this;
1000  }
1001 
1003  const O3Label& O3ReferenceSlot::type() const { return __type; }
1004 
1006  const O3Label& O3ReferenceSlot::name() const { return __name; }
1007 
1009  bool O3ReferenceSlot::isArray() const { return __isArray; }
1010 
1012  __variableType(), __aggregateType(), __name(), __parents(),
1013  __parameters() {
1014  GUM_CONSTRUCTOR(O3Aggregate);
1015  }
1016 
1019  __name(src.__name), __parents(src.__parents),
1020  __parameters(src.__parameters) {
1021  GUM_CONS_CPY(O3Aggregate);
1022  }
1023 
1025  __variableType(std::move(src.__variableType)),
1026  __aggregateType(std::move(src.__aggregateType)),
1027  __name(std::move(src.__name)), __parents(std::move(src.__parents)),
1028  __parameters(std::move(src.__parameters)) {
1029  GUM_CONS_MOV(O3Aggregate);
1030  }
1031 
1033 
1035  if (this == &src) { return *this; }
1038  __name = src.__name;
1039  __parents = src.__parents;
1040  __parameters = src.__parameters;
1041  return *this;
1042  }
1043 
1045  if (this == &src) { return *this; }
1046  __aggregateType = std::move(src.__aggregateType);
1047  __variableType = std::move(src.__variableType);
1048  __name = std::move(src.__name);
1049  __parents = std::move(src.__parents);
1050  __parameters = std::move(src.__parameters);
1051  return *this;
1052  }
1053 
1055 
1057 
1059 
1061 
1063 
1064  const O3Label& O3Aggregate::name() const { return __name; }
1065 
1067 
1069  return __parents;
1070  }
1071 
1073 
1075  return __parameters;
1076  }
1077 
1079 
1081  __leftInstance(src.__leftInstance), __leftIndex(src.__leftIndex),
1082  __leftReference(src.__leftReference),
1083  __rightInstance(src.__rightInstance), __rightIndex(src.__rightIndex) {
1084  GUM_CONS_CPY(O3Assignment);
1085  }
1086 
1088  __leftInstance(std::move(src.__leftInstance)),
1089  __leftIndex(std::move(src.__leftIndex)),
1090  __leftReference(std::move(src.__leftReference)),
1091  __rightInstance(std::move(src.__rightInstance)),
1092  __rightIndex(std::move(src.__rightIndex)) {
1093  GUM_CONS_CPY(O3Assignment);
1094  }
1095 
1097 
1099  if (this == &src) { return *this; }
1101  __leftIndex = src.__leftIndex;
1104  __rightIndex = src.__rightIndex;
1105  return *this;
1106  }
1107 
1109  if (this == &src) { return *this; }
1110  __leftInstance = std::move(src.__leftInstance);
1111  __leftIndex = std::move(src.__leftIndex);
1112  __leftReference = std::move(src.__leftReference);
1113  __rightInstance = std::move(src.__rightInstance);
1114  __rightIndex = std::move(src.__rightIndex);
1115  return *this;
1116  }
1117 
1119 
1121 
1122  const O3Integer& O3Assignment::leftIndex() const { return __leftIndex; }
1123 
1125 
1127  return __leftReference;
1128  }
1129 
1131 
1133  return __rightInstance;
1134  }
1135 
1137 
1139 
1141 
1142  O3Increment::O3Increment() { GUM_CONSTRUCTOR(O3Increment); }
1143 
1148  GUM_CONS_CPY(O3Increment);
1149  }
1150 
1152  __leftInstance(std::move(src.__leftInstance)),
1153  __leftIndex(std::move(src.__leftIndex)),
1154  __leftReference(std::move(src.__leftReference)),
1155  __rightInstance(std::move(src.__rightInstance)),
1156  __rightIndex(std::move(src.__rightIndex)) {
1157  GUM_CONS_CPY(O3Increment);
1158  }
1159 
1161 
1163  if (this == &src) { return *this; }
1165  __leftIndex = src.__leftIndex;
1168  __rightIndex = src.__rightIndex;
1169  return *this;
1170  }
1171 
1173  if (this == &src) { return *this; }
1174  __leftInstance = std::move(src.__leftInstance);
1175  __leftIndex = std::move(src.__leftIndex);
1176  __leftReference = std::move(src.__leftReference);
1177  __rightInstance = std::move(src.__rightInstance);
1178  __rightIndex = std::move(src.__rightIndex);
1179  return *this;
1180  }
1181 
1183 
1185 
1186  const O3Integer& O3Increment::leftIndex() const { return __leftIndex; }
1187 
1189 
1191 
1193 
1195 
1198 
1200 
1201  O3Instance::O3Instance() { GUM_CONSTRUCTOR(O3Instance); }
1202 
1204  __type(src.__type), __name(src.__name), __size(src.__size),
1205  __parameters(src.__parameters) {
1206  GUM_CONS_CPY(O3Instance);
1207  }
1208 
1210  __type(std::move(src.__type)), __name(std::move(src.__name)),
1211  __size(std::move(src.__size)),
1212  __parameters(std::move(src.__parameters)) {
1213  GUM_CONS_MOV(O3Instance);
1214  }
1215 
1216  O3Instance::~O3Instance() { GUM_DESTRUCTOR(O3Instance); }
1217 
1219  if (this == &src) { return *this; }
1220  __type = src.__type;
1221  __name = src.__name;
1222  __size = src.__size;
1223  __parameters = src.__parameters;
1224  return *this;
1225  }
1226 
1228  if (this == &src) { return *this; }
1229  __type = std::move(src.__type);
1230  __name = std::move(src.__name);
1231  __size = std::move(src.__size);
1232  __parameters = std::move(src.__parameters);
1233  return *this;
1234  }
1235 
1236  const O3Label& O3Instance::type() const { return __type; }
1237 
1239 
1240  const O3Label& O3Instance::name() const { return __name; }
1241 
1243 
1244  const O3Integer& O3Instance::size() const { return __size; }
1245 
1247 
1249  return __parameters;
1250  }
1251 
1253  return __parameters;
1254  }
1255 
1256  O3System::O3System() { GUM_CONSTRUCTOR(O3System); }
1257 
1259  __name(src.__name), __instances(src.__instances),
1260  __assigments(src.__assigments), __increments(src.__increments) {
1261  GUM_CONS_CPY(O3System);
1262  }
1263 
1265  __name(std::move(src.__name)), __instances(std::move(src.__instances)),
1266  __assigments(std::move(src.__assigments)),
1267  __increments(std::move(src.__increments)) {
1268  GUM_CONS_MOV(O3System);
1269  }
1270 
1271  O3System::~O3System() { GUM_DESTRUCTOR(O3System); }
1272 
1274  if (this == &src) { return *this; }
1275  __name = src.__name;
1276  __instances = src.__instances;
1277  __assigments = src.__assigments;
1278  __increments = src.__increments;
1279  return *this;
1280  }
1281 
1283  if (this == &src) { return *this; }
1284  __name = std::move(src.__name);
1285  __instances = std::move(src.__instances);
1286  __assigments = std::move(src.__assigments);
1287  __increments = std::move(src.__increments);
1288  return *this;
1289  }
1290 
1291  const O3Label& O3System::name() const { return __name; }
1292 
1294 
1296  return __instances;
1297  }
1298 
1300 
1302  return __assigments;
1303  }
1304 
1306 
1308  return __increments;
1309  }
1310 
1312 
1313  std::ostream& operator<<(std::ostream& o, const O3Label& src) {
1314  o << src.label();
1315  return o;
1316  }
1317 
1319  GUM_CONSTRUCTOR(O3InstanceParameter);
1320  }
1321 
1323  __name(src.__name), __value(src.__value), __isInteger(src.__isInteger) {
1324  GUM_CONS_CPY(O3InstanceParameter);
1325  }
1326 
1328  __name(std::move(src.__name)), __value(std::move(src.__value)),
1329  __isInteger(std::move(src.__isInteger)) {
1330  GUM_CONS_MOV(O3InstanceParameter);
1331  }
1332 
1334  GUM_DESTRUCTOR(O3InstanceParameter);
1335  }
1336 
1339  if (this == &src) { return *this; }
1340  __name = src.__name;
1341  __value = src.__value;
1342  __isInteger = src.__isInteger;
1343  return *this;
1344  }
1345 
1348  if (this == &src) { return *this; }
1349  __name = std::move(src.__name);
1350  __value = std::move(src.__value);
1351  __isInteger = std::move(src.__isInteger);
1352  return *this;
1353  }
1354 
1355  const O3Label& O3InstanceParameter::name() const { return __name; }
1356 
1358 
1359  const O3Float& O3InstanceParameter::value() const { return __value; }
1360 
1362 
1364 
1366 
1367  O3Import::O3Import() { GUM_CONSTRUCTOR(O3Import); }
1368 
1369  O3Import::O3Import(const O3Import& src) : __import(src.__import) {
1370  GUM_CONSTRUCTOR(O3Import);
1371  }
1372 
1374  GUM_CONS_MOV(O3Import);
1375  }
1376 
1377  O3Import::~O3Import() { GUM_DESTRUCTOR(O3Import); }
1378 
1380  if (this == &src) { return *this; }
1381  __import = src.__import;
1382  return *this;
1383  }
1384 
1386  if (this == &src) { return *this; }
1387  __import = std::move(src.__import);
1388  return *this;
1389  }
1390 
1391  const O3Label& O3Import::import() const { return __import; }
1392 
1394 
1395  } // namespace o3prm
1396  } // namespace prm
1397 } // namespace gum
std::vector< std::unique_ptr< O3RealType > > O3RealTypeList
Definition: O3prm.h:894
virtual O3RuleCPT & operator=(const O3RuleCPT &src)
Definition: O3prm.cpp:748
O3LabelList & parents()
Definition: O3prm.cpp:1066
O3ClassList & classes()
Definition: O3prm.cpp:501
O3SystemList __systems
Definition: O3prm.h:935
O3ReferenceSlot & operator=(const O3ReferenceSlot &src)
Definition: O3prm.cpp:986
std::vector< O3ReferenceSlot > O3ReferenceSlotList
Definition: O3prm.h:621
O3IncrementList & increments()
Definition: O3prm.cpp:1311
O3LabelList __parameters
Definition: O3prm.h:607
virtual O3LabelList & parents()
Definition: O3prm.cpp:666
O3ClassList __classes
Definition: O3prm.h:934
O3Position & operator=(const O3Position &src)
Definition: O3prm.cpp:57
std::unique_ptr< O3ParameterList > __params
Definition: O3prm.h:662
O3Position & position()
Definition: O3prm.cpp:605
std::vector< O3InstanceParameter > O3InstanceParameterList
Definition: O3prm.h:790
O3IncrementList __increments
Definition: O3prm.h:856
The O3Increment is part of the AST of the O3PRM language.
Definition: O3prm.h:715
O3Position & position()
Definition: O3prm.cpp:237
O3Position & position()
Definition: O3prm.cpp:289
O3Formula & operator=(const O3Formula &src)
Definition: O3prm.cpp:183
virtual O3RuleList & rules()
Definition: O3prm.cpp:764
std::vector< O3Increment > O3IncrementList
Definition: O3prm.h:830
The O3InstanceParameter is part of the AST of the O3PRM language.
Definition: O3prm.h:756
O3Position __pos
Definition: O3prm.h:658
virtual std::unique_ptr< O3Attribute > copy() const
Definition: O3prm.cpp:767
O3Increment & operator=(const O3Increment &src)
Definition: O3prm.cpp:1162
The O3Parameter is part of the AST of the O3PRM language.
Definition: O3prm.h:392
std::vector< O3Label > O3LabelList
Definition: O3prm.h:542
O3PRM & operator=(const O3PRM &src)
Definition: O3prm.cpp:447
The O3IntType is part of the AST of the O3PRM language.
Definition: O3prm.h:245
O3Label & name()
Definition: O3prm.cpp:280
O3Position & position()
Definition: O3prm.cpp:341
O3Position & position()
Definition: O3prm.cpp:954
O3ReferenceSlotList & referenceSlots()
Definition: O3prm.cpp:885
Evaluates a string as a algebraic formula.
Definition: formula.h:271
std::unique_ptr< O3ReferenceSlotList > __refs
Definition: O3prm.h:663
O3Position __pos
Definition: O3prm.h:131
O3RealTypeList & real_types()
Definition: O3prm.cpp:491
O3Interface & operator=(const O3Interface &src)
Definition: O3prm.cpp:586
std::vector< std::unique_ptr< O3Attribute > > O3AttributeList
Definition: O3prm.h:622
std::unique_ptr< O3LabelList > __interfaces
Definition: O3prm.h:661
std::vector< std::unique_ptr< O3Import > > O3ImportList
Definition: O3prm.h:898
The O3Aggregate is part of the AST of the O3PRM language.
Definition: O3prm.h:575
O3AggregateList & aggregates()
Definition: O3prm.cpp:893
std::ostream & operator<<(std::ostream &o, const O3Label &src)
Definition: O3prm.cpp:1313
STL namespace.
std::vector< std::unique_ptr< O3IntType > > O3IntTypeList
Definition: O3prm.h:893
The O3RealType is part of the AST of the O3PRM language.
Definition: O3prm.h:285
O3Integer & start()
Definition: O3prm.cpp:335
std::unique_ptr< O3AttributeList > __attrs
Definition: O3prm.h:664
O3InstanceParameterList & parameters()
Definition: O3prm.cpp:1252
std::vector< O3Label > O3LabelList
Definition: O3prm.h:619
The O3Type is part of the AST of the O3PRM language.
Definition: O3prm.h:202
O3RealType & operator=(const O3RealType &src)
Definition: O3prm.cpp:364
O3InstanceList & instances()
Definition: O3prm.cpp:1299
O3Assignment & operator=(const O3Assignment &src)
Definition: O3prm.cpp:1098
The O3Label is part of the AST of the O3PRM language.
Definition: O3prm.h:171
The O3Attribute is part of the AST of the O3PRM language.
Definition: O3prm.h:469
O3Position & position()
Definition: O3prm.cpp:155
virtual O3FormulaList & values()
Definition: O3prm.cpp:713
std::unique_ptr< O3FormulaList > __values
Definition: O3prm.h:530
gum is the global namespace for all aGrUM entities
Definition: agrum.h:25
O3RealTypeList __real_types
Definition: O3prm.h:932
The O3Import is part of the AST of the O3PRM language.
Definition: O3prm.h:866
O3LabelList & parameters()
Definition: O3prm.cpp:1072
O3ParameterList & parameters()
Definition: O3prm.cpp:880
std::string __file
Definition: O3prm.h:72
std::vector< O3Label > O3LabelList
Definition: O3prm.h:471
std::string & label()
Definition: O3prm.cpp:240
virtual O3Attribute & operator=(const O3Attribute &src)
Definition: O3prm.cpp:644
std::vector< O3Formula > O3FormulaList
Definition: O3prm.h:510
std::string & file()
Definition: O3prm.cpp:73
O3IntTypeList __int_types
Definition: O3prm.h:931
O3Parameter & operator=(const O3Parameter &src)
Definition: O3prm.cpp:933
std::vector< std::unique_ptr< O3Interface > > O3InterfaceList
Definition: O3prm.h:895
The O3RuleCPT is part of the AST of the O3PRM language.
Definition: O3prm.h:540
std::vector< O3Float > & values()
Definition: O3prm.cpp:390
The O3Position is part of the AST of the O3PRM language.
Definition: O3prm.h:51
std::unique_ptr< O3AggregateList > __aggs
Definition: O3prm.h:665
std::vector< O3Float > __values
Definition: O3prm.h:310
std::unique_ptr< O3RuleList > __rules
Definition: O3prm.h:565
std::vector< std::unique_ptr< O3Class > > O3ClassList
Definition: O3prm.h:896
O3Position __pos
Definition: O3prm.h:189
The O3Class is part of the AST of the O3PRM language.
Definition: O3prm.h:617
O3Label & superLabel()
Definition: O3prm.cpp:870
O3Integer & rightIndex()
Definition: O3prm.cpp:1196
std::vector< O3Rule > O3RuleList
Definition: O3prm.h:545
virtual O3RawCPT & operator=(const O3RawCPT &src)
Definition: O3prm.cpp:698
O3TypeList __types
Definition: O3prm.h:930
O3Integer & operator=(const O3Integer &src)
Definition: O3prm.cpp:101
std::string __label
Definition: O3prm.h:190
The O3Instance is part of the AST of the O3PRM language.
Definition: O3prm.h:788
O3IntType & operator=(const O3IntType &src)
Definition: O3prm.cpp:312
O3ImportList & imports()
Definition: O3prm.cpp:509
O3Position & position()
Definition: O3prm.cpp:116
std::unique_ptr< O3InterfaceElementList > __elts
Definition: O3prm.h:382
The O3ReferenceSlot is part of the AST of the O3PRM language.
Definition: O3prm.h:436
std::vector< LabelPair > LabelMap
Definition: O3prm.h:205
virtual O3Label & type()
Definition: O3prm.cpp:660
O3AssignmentList & assignments()
Definition: O3prm.cpp:1305
O3IntTypeList & int_types()
Definition: O3prm.cpp:488
O3InstanceParameterList __parameters
Definition: O3prm.h:816
O3Instance & operator=(const O3Instance &src)
Definition: O3prm.cpp:1218
std::vector< O3Aggregate > O3AggregateList
Definition: O3prm.h:623
std::vector< O3Parameter > O3ParameterList
Definition: O3prm.h:620
O3Aggregate & operator=(const O3Aggregate &src)
Definition: O3prm.cpp:1034
std::pair< O3Label, O3Label > LabelPair
Definition: O3prm.h:204
The O3System is part of the AST of the O3PRM language.
Definition: O3prm.h:826
std::vector< std::unique_ptr< O3Type > > O3TypeList
Definition: O3prm.h:892
O3AttributeList & attributes()
Definition: O3prm.cpp:887
O3SystemList & systems()
Definition: O3prm.cpp:505
O3InterfaceList __interfaces
Definition: O3prm.h:933
O3InterfaceList & interfaces()
Definition: O3prm.cpp:496
Headers for the AST of the O3PRM language.
O3InterfaceElementList & elements()
Definition: O3prm.cpp:614
The O3Float is part of the AST of the O3PRM language.
Definition: O3prm.h:113
O3Position & position()
Definition: O3prm.cpp:384
The O3RawCPT is part of the AST of the O3PRM language.
Definition: O3prm.h:508
O3ImportList __imports
Definition: O3prm.h:936
std::vector< O3Label > O3LabelList
Definition: O3prm.h:577
O3InterfaceElement & operator=(const O3InterfaceElement &src)
Definition: O3prm.cpp:541
O3Import & operator=(const O3Import &src)
Definition: O3prm.cpp:1379
The O3Assignment is part of the AST of the O3PRM language.
Definition: O3prm.h:675
std::vector< O3InterfaceElement > O3InterfaceElementList
Definition: O3prm.h:356
O3Label & superLabel()
Definition: O3prm.cpp:283
O3LabelList & interfaces()
Definition: O3prm.cpp:875
O3Float & operator=(const O3Float &src)
Definition: O3prm.cpp:140
O3TypeList & types()
Definition: O3prm.cpp:485
std::unique_ptr< Formula > __formula
Definition: O3prm.h:103
The O3Integer is part of the AST of the O3PRM language.
Definition: O3prm.h:142
std::vector< O3Instance > O3InstanceList
Definition: O3prm.h:828
The O3InterfaceElement is part of the AST of the O3PRM language.
Definition: O3prm.h:321
The O3PRM is part of the AST of the O3PRM language.
Definition: O3prm.h:890
O3Label & operator=(const O3Label &src)
Definition: O3prm.cpp:222
O3Position __pos
Definition: O3prm.h:231
O3Type & operator=(const O3Type &src)
Definition: O3prm.cpp:260
O3Position & position()
Definition: O3prm.cpp:864
O3InstanceList __instances
Definition: O3prm.h:854
O3Class & operator=(const O3Class &src)
Definition: O3prm.cpp:824
The O3Interface is part of the AST of the O3PRM language.
Definition: O3prm.h:354
O3AssignmentList __assigments
Definition: O3prm.h:855
std::vector< std::unique_ptr< O3System > > O3SystemList
Definition: O3prm.h:897
virtual O3Label & name()
Definition: O3prm.cpp:663
The O3Formula is part of the AST of the O3PRM language.
Definition: O3prm.h:84
std::vector< O3Assignment > O3AssignmentList
Definition: O3prm.h:829
LabelMap & labels()
Definition: O3prm.cpp:286
O3Position & position()
Definition: O3prm.cpp:198
O3Label __superLabel
Definition: O3prm.h:233
O3InstanceParameter & operator=(const O3InstanceParameter &src)
Definition: O3prm.cpp:1338
virtual std::unique_ptr< O3Attribute > copy() const
Definition: O3prm.cpp:717
O3System & operator=(const O3System &src)
Definition: O3prm.cpp:1273