Merge lp:~verifypn-cpn/verifypn/unfold-improve into lp:verifypn

[Andreas Klostergaard]

Improved the unfolding of colored Petri nets

[Jiri Srba (srba)]

Version 219 is consistent and well performing.

[Jiri Srba (srba)]

Version 220 is also consistent, no noticable improvement (data in the spreadsheet).

review: Approve

[Jiri Srba (srba)]

There are some warnings to be fixed:

PetriEngine/Colored/ColoredPetriNetBuilder.cpp:31:34: warning: moving a
      temporary object prevents copy elision [-Wpessimizing-move]
            _places.emplace_back(std::move(Colored::Place {name, type, t...
                                 ^
PetriEngine/Colored/ColoredPetriNetBuilder.cpp:31:34: note: remove std::move
      call here
  ..._places.emplace_back(std::move(Colored::Place {name, type, tokens}));
                          ^~~~~~~~~~ ~
PetriEngine/Colored/ColoredPetriNetBuilder.cpp:46:39: warning: moving a
      temporary object prevents copy elision [-Wpessimizing-move]
            _transitions.emplace_back(std::move(Colored::Transition {nam...
                                      ^
PetriEngine/Colored/ColoredPetriNetBuilder.cpp:46:39: note: remove std::move
      call here
  ..._transitions.emplace_back(std::move(Colored::Transition {name, guard}));
                               ^~~~~~~~~~ ~

review: Needs Fixing

[lp:~verifypn-cpn/verifypn/unfold-improve]

221. By Peter Gjøl Jensen on 2018-06-26

fixed warnings

[Peter Gjøl Jensen (peter-gjoel)]

Warnings should be fixed now.

[Jiri Srba (srba)]

Warning fixed.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2018-04-19 22:14:38 +0000
+++ CMakeLists.txt	2018-06-26 07:06:25 +0000
@@ -1,15 +1,19 @@
 cmake_minimum_required(VERSION 2.8.4)
 project(verifypn)
 
-if (UNIX)
+if (UNIX AND NOT APPLE)
     if (CMAKE_SIZEOF_VOID_P EQUAL 8) # is system 64-bit?
         set(ARCH_TYPE "linux64")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -flto -march=x86-64 -std=c++14  -m64 -I.")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto=4 -march=x86-64 -std=c++14 -m64 -static -static-libgcc -static-libstdc++")
     else()
         set(ARCH_TYPE "linux32")
     endif ()
 elseif(APPLE)
     if (CMAKE_SIZEOF_VOID_P EQUAL 8) # is system 64-bit?
         set(ARCH_TYPE "osx64")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.7 -std=c++14  -m64 -I. -stdlib=libc++")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -dynamic -mmacosx-version-min=10.7 -std=c++14 -m64 -stdlib=libc++ -lc++")
     else()
         set(ARCH_TYPE "osx32")
     endif ()
@@ -21,11 +25,9 @@
     endif()
 endif ()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -flto -march=x86-64 -std=c++14  -m64 -I.")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -pedantic-errors -O2 -DNDEBUG")
 set(CMAKE_CXX_FLAGS_DEBUG  "${CMAKE_CXX_FLAGS_DEBUG} -g")
 
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto=4 -march=x86-64 -std=c++14 -m64 -static -static-libgcc -static-libstdc++")
 set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -O2 -DNDEBUG")
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -g")
 
 
=== modified file 'PetriEngine/AbstractPetriNetBuilder.h'
--- PetriEngine/AbstractPetriNetBuilder.h	2018-05-12 15:14:12 +0000
+++ PetriEngine/AbstractPetriNetBuilder.h	2018-06-26 07:06:25 +0000
@@ -42,7 +42,7 @@
         /** Add a new colored place with a unique name */
         virtual void addPlace(const std::string& name,
                 Colored::ColorType* type,
-                Colored::Multiset tokens,
+                Colored::Multiset&& tokens,
                 double x = 0,
                 double y = 0)
         {
@@ -55,7 +55,7 @@
                 double y = 0) = 0;
         /** Add a new colored transition with a unique name */
         virtual void addTransition(const std::string& name,
-                Colored::GuardExpression_ptr guard,
+                const Colored::GuardExpression_ptr& guard,
                 double x = 0,
                 double y = 0)
         {
@@ -70,7 +70,7 @@
         /** Add colored input arc with given arc expression */
         virtual void addInputArc(const std::string& place,
                 const std::string& transition,
-                Colored::ArcExpression_ptr expr)
+                const Colored::ArcExpression_ptr& expr)
         {
             std::cerr << "Colored input arcs are not supported in standard P/T nets" << std::endl;
             exit(ErrorCode);
@@ -82,7 +82,7 @@
         /** Add output arc with given arc expression */
         virtual void addOutputArc(const std::string& transition,
                 const std::string& place,
-                Colored::ArcExpression_ptr expr)
+                const Colored::ArcExpression_ptr& expr)
         {
             std::cerr << "Colored output arcs are not supported in standard P/T nets" << std::endl;
             exit(ErrorCode);
 
=== modified file 'PetriEngine/Colored/ColoredNetStructures.h'
--- PetriEngine/Colored/ColoredNetStructures.h	2018-03-13 22:08:31 +0000
+++ PetriEngine/Colored/ColoredNetStructures.h	2018-06-26 07:06:25 +0000
@@ -33,8 +33,7 @@
         struct Transition {
             std::string name;
             GuardExpression_ptr guard;
-            std::vector<std::unordered_map<std::string,const Color*>> bindings;
-            std::vector<size_t> arcs;
+            std::vector<Arc> arcs;
         };
         
         struct Place {
 
=== modified file 'PetriEngine/Colored/ColoredPetriNetBuilder.cpp'
--- PetriEngine/Colored/ColoredPetriNetBuilder.cpp	2018-05-20 18:25:00 +0000
+++ PetriEngine/Colored/ColoredPetriNetBuilder.cpp	2018-06-26 07:06:25 +0000
@@ -1,10 +1,4 @@
 /*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-
-/* 
  * File:   ColoredPetriNetBuilder.cpp
  * Author: Klostergaard
  * 
@@ -30,11 +24,11 @@
         }
     }
 
-    void ColoredPetriNetBuilder::addPlace(const std::string& name, Colored::ColorType* type, Colored::Multiset tokens, double x, double y) {
+    void ColoredPetriNetBuilder::addPlace(const std::string& name, Colored::ColorType* type, Colored::Multiset&& tokens, double x, double y) {
         if(_placenames.count(name) == 0)
         {
             uint32_t next = _placenames.size();
-            _places.push_back(Colored::Place {name, type, tokens});
+            _places.emplace_back(Colored::Place {name, type, tokens});
             _placenames[name] = next;
         }
     }
@@ -45,11 +39,11 @@
         }
     }
 
-    void ColoredPetriNetBuilder::addTransition(const std::string& name, Colored::GuardExpression_ptr guard, double x, double y) {
+    void ColoredPetriNetBuilder::addTransition(const std::string& name, const Colored::GuardExpression_ptr& guard, double x, double y) {
         if(_transitionnames.count(name) == 0)
         {
             uint32_t next = _transitionnames.size();
-            _transitions.push_back(Colored::Transition {name, guard});
+            _transitions.emplace_back(Colored::Transition {name, guard});
             _transitionnames[name] = next;
         }
     }
@@ -60,7 +54,7 @@
         }
     }
 
-    void ColoredPetriNetBuilder::addInputArc(const std::string& place, const std::string& transition, Colored::ArcExpression_ptr expr) {
+    void ColoredPetriNetBuilder::addInputArc(const std::string& place, const std::string& transition, const Colored::ArcExpression_ptr& expr) {
         addArc(place, transition, expr, true);
     }
 
@@ -70,11 +64,11 @@
         }
     }
 
-    void ColoredPetriNetBuilder::addOutputArc(const std::string& transition, const std::string& place, Colored::ArcExpression_ptr expr) {
+    void ColoredPetriNetBuilder::addOutputArc(const std::string& transition, const std::string& place, const Colored::ArcExpression_ptr& expr) {
         addArc(place, transition, expr, false);
     }
 
-    void ColoredPetriNetBuilder::addArc(const std::string& place, const std::string& transition, Colored::ArcExpression_ptr expr, bool input) {
+    void ColoredPetriNetBuilder::addArc(const std::string& place, const std::string& transition, const Colored::ArcExpression_ptr& expr, bool input) {
         if(_transitionnames.count(transition) == 0)
         {
             std::cout << "Transition '" << transition << "' not found. Adding it." << std::endl;
@@ -95,10 +89,9 @@
         arc.place = p;
         arc.transition = t;
         assert(expr != nullptr);
-        arc.expr = expr;
+        arc.expr = std::move(expr);
         arc.input = input;
-        _transitions[t].arcs.push_back(_arcs.size());
-        _arcs.push_back(arc);
+        _transitions[t].arcs.push_back(std::move(arc));
     }
 
     void ColoredPetriNetBuilder::addColorType(const std::string& id, Colored::ColorType* type) {
@@ -121,9 +114,6 @@
                 unfoldTransition(transition);
             }
 
-            for (auto& arc : _arcs) {
-                unfoldArc(arc);
-            }
             _unfolded = true;
             auto end = std::chrono::high_resolution_clock::now();
             _time = (std::chrono::duration_cast<std::chrono::microseconds>(end - start).count())*0.000001;
@@ -135,50 +125,42 @@
     void ColoredPetriNetBuilder::unfoldPlace(Colored::Place& place) {
         for (size_t i = 0; i < place.type->size(); ++i) {
             std::string name = place.name + ";" + std::to_string(i);
-            const Colored::Color* color = &(*place.type)[i];
+            const Colored::Color* color = &place.type->operator[](i);
             _ptBuilder.addPlace(name, place.marking[color], 0.0, 0.0);
-            _ptplacenames[place.name][color->getId()] = name;
+            _ptplacenames[place.name][color->getId()] = std::move(name);
             ++_nptplaces;
         }
     }
 
     void ColoredPetriNetBuilder::unfoldTransition(Colored::Transition& transition) {
         BindingGenerator gen(transition, _arcs, _colors);
+        size_t i = 0;
         for (auto& b : gen) {
-            size_t i = transition.bindings.size();
-            std::unordered_map<std::string, const Colored::Color*> binding;
-            for (auto& elem : b) {
-                binding[elem.var->name] = elem.color;
-            }
-            transition.bindings.push_back(binding);
-            std::string name = transition.name + ";" + std::to_string(i);
+            std::string name = transition.name + ";" + std::to_string(i++);
             _ptBuilder.addTransition(name, 0.0, 0.0);
             _pttransitionnames[transition.name].push_back(name);
             ++_npttransitions;
+            for (auto& arc : transition.arcs) {
+                unfoldArc(arc, b, name);
+            }
         }
     }
 
-    void ColoredPetriNetBuilder::unfoldArc(Colored::Arc& arc) {
-        Colored::Transition& transition = _transitions[arc.transition];
-        for (size_t i = 0; i < transition.bindings.size(); ++i) {
-            Colored::ExpressionContext context {transition.bindings[i], _colors};
-            Colored::Multiset ms = arc.expr->eval(context);
-
-            for (auto color : ms) {
-                if (color.second == 0) {
-                    continue;
-                }
-
-                std::string pName = _ptplacenames[_places[arc.place].name][color.first->getId()];
-                std::string tName = _pttransitionnames[transition.name][i];
-
-                if (arc.input) {
-                    _ptBuilder.addInputArc(pName, tName, false, color.second);
-                } else {
-                    _ptBuilder.addOutputArc(tName, pName, color.second);
-                }
-                ++_nptarcs;
-            }
+    void ColoredPetriNetBuilder::unfoldArc(Colored::Arc& arc, Colored::ExpressionContext::BindingMap& binding, std::string& tName) {
+        Colored::ExpressionContext context {binding, _colors};
+        auto ms = arc.expr->eval(context);
+
+        for (const auto& color : ms) {
+            if (color.second == 0) {
+                continue;
+            }
+            const std::string& pName = _ptplacenames[_places[arc.place].name][color.first->getId()];
+            if (arc.input) {
+                _ptBuilder.addInputArc(pName, tName, false, color.second);
+            } else {
+                _ptBuilder.addOutputArc(tName, pName, color.second);
+            }
+            ++_nptarcs;
         }
     }
 
@@ -191,24 +173,24 @@
 
             for (auto& transition : _transitions) {
                 _ptBuilder.addTransition(transition.name, 0.0, 0.0);
-            }
-
-            for (auto& arc : _arcs) {
-                try {
-                    if (arc.input) {
-                        _ptBuilder.addInputArc(_places[arc.place].name, _transitions[arc.transition].name, false,
-                                               arc.expr->weight());
-                    } else {
-                        _ptBuilder.addOutputArc(_transitions[arc.transition].name, _places[arc.place].name,
-                                                arc.expr->weight());
+                for (auto& arc : transition.arcs) {
+                    try {
+                        if (arc.input) {
+                            _ptBuilder.addInputArc(_places[arc.place].name, _transitions[arc.transition].name, false,
+                                                   arc.expr->weight());
+                        } else {
+                            _ptBuilder.addOutputArc(_transitions[arc.transition].name, _places[arc.place].name,
+                                                    arc.expr->weight());
+                        }
+                    } catch (Colored::WeightException& e) {
+                        std::cerr << "Exception on arc: " << arcToString(arc) << std::endl;
+                        std::cerr << "In expression: " << arc.expr->toString() << std::endl;
+                        std::cerr << e.what() << std::endl;
+                        exit(ErrorCode);
                     }
-                } catch (Colored::WeightException e) {
-                    std::cerr << "Exception on arc: " << arcToString(arc) << std::endl;
-                    std::cerr << "In expression: " << arc.expr->toString() << std::endl;
-                    std::cerr << e.what() << std::endl;
-                    exit(ErrorCode);
                 }
             }
+
             _stripped = true;
             _isColored = false;
         }
@@ -240,13 +222,13 @@
         return *this;
     }
 
-    std::vector<Colored::Binding> BindingGenerator::Iterator::operator++(int) {
+    const Colored::ExpressionContext::BindingMap BindingGenerator::Iterator::operator++(int) {
         auto prev = _generator->currentBinding();
         ++*this;
         return prev;
     }
 
-    std::vector<Colored::Binding>& BindingGenerator::Iterator::operator*() {
+    Colored::ExpressionContext::BindingMap& BindingGenerator::Iterator::operator*() {
         return _generator->currentBinding();
     }
 
@@ -260,13 +242,12 @@
         if (_expr != nullptr) {
             _expr->getVariables(variables);
         }
-        for (auto ai : transition.arcs) {
-            auto& arc = arcs[ai];
+        for (auto arc : transition.arcs) {
             assert(arc.expr != nullptr);
             arc.expr->getVariables(variables);
         }
         for (auto var : variables) {
-            _bindings.push_back(Colored::Binding {var, &(*var->colorType)[0]});
+            _bindings[var->name] = &var->colorType->operator[](0);
         }
         
         if (!eval())
@@ -277,20 +258,16 @@
         if (_expr == nullptr)
             return true;
 
-        std::unordered_map<std::string, const Colored::Color*> binding;
-        for (auto& elem : _bindings) {
-            binding[elem.var->name] = elem.color;
-        }
-        Colored::ExpressionContext context {binding, _colorTypes};
+        Colored::ExpressionContext context {_bindings, _colorTypes};
         return _expr->eval(context);
     }
-    
-    std::vector<Colored::Binding>& BindingGenerator::nextBinding() {
+
+    Colored::ExpressionContext::BindingMap& BindingGenerator::nextBinding() {
         bool test = false;
         while (!test) {
-            for (size_t i = 0; i < _bindings.size(); ++i) {
-                _bindings[i].color = &++(*_bindings[i].color);
-                if (_bindings[i].color->getId() != 0) {
+            for (auto& _binding : _bindings) {
+                _binding.second = &_binding.second->operator++();
+                if (_binding.second->getId() != 0) {
                     break;
                 }
             }
@@ -303,23 +280,23 @@
         return _bindings;
     }
 
-    std::vector<Colored::Binding>& BindingGenerator::currentBinding() {
+    Colored::ExpressionContext::BindingMap& BindingGenerator::currentBinding() {
         return _bindings;
     }
 
     bool BindingGenerator::isInitial() const {
         for (auto& b : _bindings) {
-            if (b.color->getId() != 0) return false;
+            if (b.second->getId() != 0) return false;
         }
         return true;
     }
 
     BindingGenerator::Iterator BindingGenerator::begin() {
-        return Iterator(this);
+        return {this};
     }
 
     BindingGenerator::Iterator BindingGenerator::end() {
-        return Iterator(nullptr);
+        return {nullptr};
     }
 }
 
 
=== modified file 'PetriEngine/Colored/ColoredPetriNetBuilder.h'
--- PetriEngine/Colored/ColoredPetriNetBuilder.h	2018-05-20 18:25:00 +0000
+++ PetriEngine/Colored/ColoredPetriNetBuilder.h	2018-06-26 07:06:25 +0000
@@ -1,10 +1,4 @@
 /*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-
-/* 
  * File:   ColoredPetriNetBuilder.h
  * Author: Klostergaard
  *
@@ -39,14 +33,14 @@
                 double y = 0) override ;
         void addPlace(const std::string& name,
                 Colored::ColorType* type,
-                Colored::Multiset tokens,
-                double x = 0,
-                double y = 0) override;
-        void addTransition(const std::string& name,
-                double x = 0,
-                double y = 0) override;
-        void addTransition(const std::string& name,
-                Colored::GuardExpression_ptr guard,
+                Colored::Multiset&& tokens,
+                double x = 0,
+                double y = 0) override;
+        void addTransition(const std::string& name,
+                double x = 0,
+                double y = 0) override;
+        void addTransition(const std::string& name,
+                const Colored::GuardExpression_ptr& guard,
                 double x = 0,
                 double y = 0) override;
         void addInputArc(const std::string& place,
@@ -55,13 +49,13 @@
                 int) override;
         void addInputArc(const std::string& place,
                 const std::string& transition,
-                Colored::ArcExpression_ptr expr) override;
+                const Colored::ArcExpression_ptr& expr) override;
         void addOutputArc(const std::string& transition,
                 const std::string& place,
                 int weight = 1) override;
         void addOutputArc(const std::string& transition,
                 const std::string& place,
-                Colored::ArcExpression_ptr expr) override;
+                const Colored::ArcExpression_ptr& expr) override;
         void addColorType(const std::string& id,
                 Colored::ColorType* type) override;
 
@@ -81,7 +75,11 @@
         }
 
         uint32_t getArcCount() const {
-            return _arcs.size();
+            uint32_t sum = 0;
+            for (auto& t : _transitions) {
+                sum += t.arcs.size();
+            }
+            return sum;
         }
 
         uint32_t getUnfoldedPlaceCount() const {
@@ -134,12 +132,12 @@
         
         void addArc(const std::string& place,
                 const std::string& transition,
-                Colored::ArcExpression_ptr expr,
+                const Colored::ArcExpression_ptr& expr,
                 bool input);
         
         void unfoldPlace(Colored::Place& place);
         void unfoldTransition(Colored::Transition& transition);
-        void unfoldArc(Colored::Arc& arc);
+        void unfoldArc(Colored::Arc& arc, Colored::ExpressionContext::BindingMap& binding, std::string& name);
     };
     
     class BindingGenerator {
@@ -154,12 +152,12 @@
             bool operator==(Iterator& other);
             bool operator!=(Iterator& other);
             Iterator& operator++();
-            std::vector<Colored::Binding> operator++(int);
-            std::vector<Colored::Binding>& operator*();
+            const Colored::ExpressionContext::BindingMap operator++(int);
+            Colored::ExpressionContext::BindingMap& operator*();
         };
     private:
         Colored::GuardExpression_ptr _expr;
-        std::vector<Colored::Binding> _bindings;
+        Colored::ExpressionContext::BindingMap _bindings;
         ColoredPetriNetBuilder::ColorTypeMap& _colorTypes;
         
         bool eval();
@@ -168,9 +166,9 @@
         BindingGenerator(Colored::Transition& transition,
                 const std::vector<Colored::Arc>& arcs,
                 ColoredPetriNetBuilder::ColorTypeMap& colorTypes);
-        
-        std::vector<Colored::Binding>& nextBinding();
-        std::vector<Colored::Binding>& currentBinding();
+
+        Colored::ExpressionContext::BindingMap& nextBinding();
+        Colored::ExpressionContext::BindingMap& currentBinding();
         bool isInitial() const;
         Iterator begin();
         Iterator end();
 
=== modified file 'PetriEngine/Colored/Expressions.h'
--- PetriEngine/Colored/Expressions.h	2018-05-27 12:00:38 +0000
+++ PetriEngine/Colored/Expressions.h	2018-06-26 07:06:25 +0000
@@ -32,7 +32,9 @@
     
     namespace Colored {
         struct ExpressionContext {
-            std::unordered_map<std::string, const Color*>& binding;
+            typedef std::unordered_map<std::string, const Color*> BindingMap;
+
+            BindingMap& binding;
             std::unordered_map<std::string, ColorType*>& colorTypes;
             
             const Color* findColor(const std::string& color) const {
@@ -191,8 +193,8 @@
                 return _color->toString() + "++";
             }
 
-            SuccessorExpression(ColorExpression_ptr color)
-                    : _color(color) {}
+            SuccessorExpression(ColorExpression_ptr&& color)
+                    : _color(std::move(color)) {}
         };
         
         class PredecessorExpression : public ColorExpression {
@@ -212,8 +214,8 @@
                 return _color->toString() + "--";
             }
 
-            PredecessorExpression(ColorExpression_ptr color)
-                    : _color(color) {}
+            PredecessorExpression(ColorExpression_ptr&& color)
+                    : _color(std::move(color)) {}
         };
         
         class TupleExpression : public ColorExpression {
@@ -250,8 +252,8 @@
                 return res;
             }
 
-            TupleExpression(std::vector<ColorExpression_ptr> colors)
-                    : _colors(colors) {}
+            TupleExpression(std::vector<ColorExpression_ptr>&& colors)
+                    : _colors(std::move(colors)) {}
         };
         
         class GuardExpression : public Expression {
@@ -279,8 +281,8 @@
                 _right->getVariables(variables);
             }
             
-            LessThanExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            LessThanExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class GreaterThanExpression : public GuardExpression {
@@ -298,8 +300,8 @@
                 _right->getVariables(variables);
             }
             
-            GreaterThanExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            GreaterThanExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class LessThanEqExpression : public GuardExpression {
@@ -317,8 +319,8 @@
                 _right->getVariables(variables);
             }
             
-            LessThanEqExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            LessThanEqExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class GreaterThanEqExpression : public GuardExpression {
@@ -336,8 +338,8 @@
                 _right->getVariables(variables);
             }
             
-            GreaterThanEqExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            GreaterThanEqExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class EqualityExpression : public GuardExpression {
@@ -355,8 +357,8 @@
                 _right->getVariables(variables);
             }
             
-            EqualityExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            EqualityExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class InequalityExpression : public GuardExpression {
@@ -374,8 +376,8 @@
                 _right->getVariables(variables);
             }
             
-            InequalityExpression(ColorExpression_ptr left, ColorExpression_ptr right)
-                    : _left(left), _right(right) {}
+            InequalityExpression(ColorExpression_ptr&& left, ColorExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class NotExpression : public GuardExpression {
@@ -391,7 +393,7 @@
                 _expr->getVariables(variables);
             }
             
-            NotExpression(GuardExpression_ptr expr) : _expr(expr) {}
+            NotExpression(GuardExpression_ptr&& expr) : _expr(std::move(expr)) {}
         };
         
         class AndExpression : public GuardExpression {
@@ -409,7 +411,7 @@
                 _right->getVariables(variables);
             }
             
-            AndExpression(GuardExpression_ptr left, GuardExpression_ptr right)
+            AndExpression(GuardExpression_ptr&& left, GuardExpression_ptr&& right)
                     : _left(left), _right(right) {}
         };
         
@@ -428,8 +430,8 @@
                 _right->getVariables(variables);
             }
             
-            OrExpression(GuardExpression_ptr left, GuardExpression_ptr right)
-                    : _left(left), _right(right) {}
+            OrExpression(GuardExpression_ptr&& left, GuardExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class ArcExpression : public Expression {
@@ -539,10 +541,10 @@
                 return res;
             }
 
-            NumberOfExpression(std::vector<ColorExpression_ptr> color, uint32_t number = 1)
-                    : _number(number), _color(color), _all(nullptr) {}
-            NumberOfExpression(AllExpression_ptr all, uint32_t number = 1)
-                    : _number(number), _color(), _all(all) {}
+            NumberOfExpression(std::vector<ColorExpression_ptr>&& color, uint32_t number = 1)
+                    : _number(number), _color(std::move(color)), _all(nullptr) {}
+            NumberOfExpression(AllExpression_ptr&& all, uint32_t number = 1)
+                    : _number(number), _color(), _all(std::move(all)) {}
         };
 
         typedef std::shared_ptr<NumberOfExpression> NumberOfExpression_ptr;
@@ -582,8 +584,8 @@
                 return res;
             }
 
-            AddExpression(std::vector<ArcExpression_ptr> constituents)
-                    : _constituents(constituents) {}
+            AddExpression(std::vector<ArcExpression_ptr>&& constituents)
+                    : _constituents(std::move(constituents)) {}
         };
         
         class SubtractExpression : public ArcExpression {
@@ -619,8 +621,8 @@
                 return _left->toString() + " - " + _right->toString();
             }
 
-            SubtractExpression(ArcExpression_ptr left, ArcExpression_ptr right)
-                    : _left(left), _right(right) {}
+            SubtractExpression(ArcExpression_ptr&& left, ArcExpression_ptr&& right)
+                    : _left(std::move(left)), _right(std::move(right)) {}
         };
         
         class ScalarProductExpression : public ArcExpression {
@@ -645,8 +647,8 @@
                 return std::to_string(_scalar) + " * " + _expr->toString();
             }
 
-            ScalarProductExpression(ArcExpression_ptr expr, uint32_t scalar)
-                    : _scalar(scalar), _expr(expr) {}
+            ScalarProductExpression(ArcExpression_ptr&& expr, uint32_t scalar)
+                    : _scalar(std::move(scalar)), _expr(expr) {}
         };
     }
 }
 
=== modified file 'PetriParse/PNMLParser.cpp'
--- PetriParse/PNMLParser.cpp	2018-05-20 18:25:00 +0000
+++ PetriParse/PNMLParser.cpp	2018-06-26 07:06:25 +0000
@@ -206,7 +206,7 @@
         for (auto it = element->first_node(); it; it = it->next_sibling()) {
             constituents.push_back(parseArcExpression(it));
         }
-        return std::make_shared<PetriEngine::Colored::AddExpression>(constituents);
+        return std::make_shared<PetriEngine::Colored::AddExpression>(std::move(constituents));
     } else if (strcmp(element->name(), "subtract") == 0) {
         auto left = element->first_node();
         auto right = left->next_sibling();
@@ -290,7 +290,7 @@
         for (auto it = element->first_node(); it; it = it->next_sibling()) {
             colors.push_back(parseColorExpression(it));
         }
-        return std::make_shared<PetriEngine::Colored::TupleExpression>(colors);
+        return std::make_shared<PetriEngine::Colored::TupleExpression>(std::move(colors));
     } else if (strcmp(element->name(), "subterm") == 0 || strcmp(element->name(), "structure") == 0) {
         return parseColorExpression(element->first_node());
     }
@@ -336,13 +336,13 @@
     }
     auto allExpr = parseAllExpression(first);
     if (allExpr) {
-        return std::make_shared<PetriEngine::Colored::NumberOfExpression>(allExpr, number);
+        return std::make_shared<PetriEngine::Colored::NumberOfExpression>(std::move(allExpr), number);
     } else {
         std::vector<PetriEngine::Colored::ColorExpression_ptr> colors;
         for (auto it = first; it; it = it->next_sibling()) {
             colors.push_back(parseColorExpression(it));
         }
-        return std::make_shared<PetriEngine::Colored::NumberOfExpression>(colors, number);
+        return std::make_shared<PetriEngine::Colored::NumberOfExpression>(std::move(colors), number);
     }
 }
 
@@ -436,7 +436,7 @@
         }
         else
         {
-            builder->addPlace(id, type, hlinitialMarking, x, y);
+            builder->addPlace(id, type, std::move(hlinitialMarking), x, y);
         }
     }
     //Map id to name