LabelledPrioritizedNet.hh

Go to the documentation of this file.

#ifndef __DIADES_PETRI_LABELLEDPRIORITIZEDNET__HH__
#define __DIADES_PETRI_LABELLEDPRIORITIZEDNET__HH__

#include"LabelledNet.hh"


namespace Diades
{

        namespace Petri
        {

                class LabelledPrioritizedNet : public LabelledNet
                {
                private:
                        std::set<Transition> _involved;
                        std::set<Transition> _reversedInvolved;
                        Diades::Graph::NodeMap<std::set<Transition>> _priorities;
                        Diades::Graph::NodeMap<std::set<Transition>> _reversedPriorities;
                public:

                        LabelledPrioritizedNet();

                        
                        
                        LabelledPrioritizedNet(const LabelledPrioritizedNet & net);



                        LabelledPrioritizedNet & operator=(const LabelledPrioritizedNet & net);

                        
                        
                        LabelledPrioritizedNet & append(const LabelledPrioritizedNet & net);
                        
                        LabelledPrioritizedNet(const LabelledPrioritizedNet & lppn1, 
                                                                   const LabelledPrioritizedNet & lppn2, 
                                                                   const unordered_set<Event> & syncEvents);




                        LabelledPrioritizedNet & merge(const LabelledPrioritizedNet & lppn1, 
                                                                                   const LabelledPrioritizedNet & lppn2,
                                                                                   const unordered_set<Event> & syncEvents,
                                                                                   std::unordered_map< Transition, std::list<Transition> > & lppn1SyncTrans,
                                                                                   std::unordered_map< Transition, std::list<Transition> > & lppn2SyncTrans,
                                                                                   std::unordered_map< Transition, std::pair<Transition,Transition> > & syncTransitions,
                                                                                   std::unordered_map< Place, Place > & lppn1Place,
                                std::unordered_map< Place, Place > & lppn2Place,
                                std::unordered_map< Place, std::pair<Place, Place> > & syncPlaces);

                        void
                        setPriority(Transition t1, Transition t2);

                        const set<Transition> &
                        priorities(Transition tr) const;

                        const set<Transition> &
                        reversedPriorities(Transition tr) const;

                        void
                        resetPriority(Transition t1, Transition t2);

                        void
                        priorities2Dot(ostream & os) const;

                        virtual void
                        deleteTransition(Transition t1);

                        
                        
                        
                        
                        
                protected:

                        virtual void
                        priorities2Tina(ostream & os) const;

                        
                        virtual void
                        net2TinaEnd(ostream & os,const string & header) const;

                        virtual void
                        writeEndOfDotFile(ostream & os) const;
                        
                        virtual void copyLabelledPrioritizedNet(const LabelledPrioritizedNet & net,
                                                                                Diades::Graph::ConstNodeMap<Diades::Graph::Node> & nodeMap,
                                                                                Diades::Graph::NodeMap<Diades::Graph::Node> & nodeMapCopy,
                                                                                Diades::Graph::ConstEdgeMap<Diades::Graph::Edge> & edgeMap,
                                                                                Diades::Graph::EdgeMap<Diades::Graph::Edge> & edgeMapCopy);
                        
                        
                        
                        virtual void appendLabelledPrioritizedNet(const LabelledPrioritizedNet & net,
                                                                                   Diades::Graph::ConstNodeMap<Diades::Graph::Node> & nodeMap,
                                                                                   Diades::Graph::NodeMap<Diades::Graph::Node> & nodeMapCopy,
                                                                                   Diades::Graph::ConstEdgeMap<Diades::Graph::Edge> & edgeMap,
                                                                                   Diades::Graph::EdgeMap<Diades::Graph::Edge> & edgeMapCopy);
                        
                        
                        virtual void mergeLabelledPrioritizedNet(const LabelledPrioritizedNet & lppn1, const LabelledPrioritizedNet & lppn2,
                                                                                const unordered_set<Event> & syncEvents,
                                                                                Diades::Graph::ConstNodeMap<Diades::Graph::Node> & nodeMapLppn1,
                                                                                Diades::Graph::NodeMap<Diades::Graph::Node> & nodeMapFromLppn1,
                                                                                Diades::Graph::ConstNodeMap<Diades::Graph::Node> & nodeMapLppn2,
                                                                                Diades::Graph::NodeMap<Diades::Graph::Node> & nodeMapFromLppn2,
                                                                                std::unordered_map< Transition, std::list<Transition> > & lppn1SyncTrans,
                                                                                std::unordered_map< Transition, std::list<Transition> > & lppn2SyncTrans,
                                                                                std::unordered_map< Transition, std::pair<Transition,Transition> > & syncTransitions,
                                                                                std::unordered_map< Place, Place > & lppn1Place,
                                std::unordered_map< Place, Place > & lppn2Place,
                                std::unordered_map< Place, std::pair<Place, Place> > & syncPlaces);






                };
        };

};

#endif