Marking.hh

Go to the documentation of this file.

#ifndef __DIADES__PETRI__MARKING__HH__
#define __DIADES__PETRI__MARKING__HH__

#include <diades/graph/Graph.hh>
#include <iostream>

namespace Diades
{
        namespace Petri
        {

                typedef Diades::Graph::Node Place;

                class Marking
                {
                private:
                        std::unordered_map<Place, unsigned> _marking;
                        mutable std::string _hashSequence;
                        mutable bool _hasHash;
                public:

                        Marking() : _marking(), _hashSequence(), _hasHash(true)
                        {
                        }

                        Marking(const Marking & marking) : _marking(marking._marking), _hashSequence(marking._hashSequence), _hasHash(marking._hasHash)
                        {
                        }

                        Marking(Marking && marking) : _marking(std::move(marking._marking)), _hashSequence(std::move(marking._hashSequence)), _hasHash(std::move(marking._hasHash))
                        {
                        }
                        
                        
                        Marking & operator=(const Marking & marking)
                        {
                                if(&marking != this)
                                {
                                        _marking = marking._marking;
                                        _hashSequence = marking._hashSequence;
                                        _hasHash = marking._hasHash;
                                }
                                return *this;
                        }

                        void
                        increaseMark(Place p)
                        {
                                _hasHash = false;
                                auto it = _marking.find(p);
                                if(it == _marking.end())
                                {
                                        _marking[p] = 1;
                                }
                                else
                                {
                                        it->second++;
                                }
                        }

                        bool
                        decreaseMark(Place p)
                        {
                                _hasHash = false;
                                auto it = _marking.find(p);
                                bool possible = false;
                                if(it != _marking.end())
                                {
                                        possible = true;
                                        if(it->second == 1)
                                        {
                                                _marking.erase(it);
                                        }
                                        else
                                        {
                                                it->second--;
                                        }
                                }
                                return possible;
                        }

                        void
                        mark(Place p, unsigned tokens)
                        {
                                _hasHash = false;
                                if(tokens == 0)
                                {
                                        unmark(p);
                                }
                                else
                                {
                                        _marking[p] = tokens;
                                }
                        }

                        void
                        unmark(Place p)
                        {
                                _hasHash = false;
                                _marking.erase(p);
                        }

                        unsigned
                        getMark(Place p) const
                        {
                                auto it = _marking.find(p);
                                if(it == _marking.end())
                                {
                                        return 0;
                                }
                                return it->second;
                        }

                        bool
                        empty() const
                        {
                                return _marking.empty();
                        }

                        void
                        clear()
                        {
                                _hashSequence = "";
                                _hasHash = true;
                                ;
                                _marking.clear();
                        }

                        std::unordered_map<Place, unsigned>::const_iterator
                        begin() const
                        {
                                return _marking.begin();
                        }

                        std::unordered_map<Place, unsigned>::const_iterator
                        end() const
                        {
                                return _marking.end();
                        }

                        bool operator==(const Marking & marking) const
                        {
                                if(this == &marking)
                                {
                                        return true;
                                }
                                return _marking == marking._marking;
                        }

                        void
                        computeHashSequence() const
                        {
                                _hashSequence = "";
                                stringstream stream;
                                for(auto & p : _marking)
                                {
                                        stream << "_" << p.first.id() << "_" << p.second;
                                }
                                _hashSequence = stream.str();
                                _hasHash = true;
                        }

                        const string &
                        getHashSequence() const
                        {
                                if(!_hasHash)
                                {
                                        computeHashSequence();
                                }
                                return _hashSequence;
                        }

                        bool
                        hitsNoneOf(const vector<Marking> & markings)
                        {
                                bool result = true;
                                unsigned i = 0;
                                while(result && (i < markings.size()))
                                {
                                        result = !hits(markings[i]);
                                        ++i;
                                }
                                std::cout << "Does " << getHashSequence() << " hit none of the right faulty markings ? " << result << std::endl;
                                return result;
                        }

                        bool
                        hits(const Marking & marking) const
                        {
                                std::cout << "Does " << getHashSequence() << " hit " << marking.getHashSequence() << " ? ";
                                bool result = true;
                                auto it = marking.begin();
                                while(result && (it != marking.end()))
                                {
                                        result = getMark(it->first) >= it->second;
                                        ++it;
                                }
                                std::cout << result << std::endl;
                                return result;
                        }




                };
        };

};



namespace std
{

        template <>
        class hash<Diades::Petri::Marking>
        {
        public:

                size_t operator()(const Diades::Petri::Marking & m) const
                {
                        return hash<string>()(m.getHashSequence());
                }
        };
}





#endif