LabelledPrioritizedTimeNet.hh

Go to the documentation of this file.

/* 
 * @file:   LabelledPrioritizedTimeNet.hh
 * @author: Yannick Pencolé
 *
 * @date 22 March 2018, 12:30
 */

#ifndef __DIADES__PETRI__LABELLEDPRIORITIZEDTIMENET__HH__
#define __DIADES__PETRI__LABELLEDPRIORITIZEDTIMENET__HH__

#include<diades/utils/Exceptions.hh>
#include<diades/utils/Interval.hh>
#include<diades/graph/ConstNodeMap.hh>
#include<diades/petri/LabelledPrioritizedNet.hh>
#include<diades/petri/TimeDecomposedTransition.hh>

namespace Diades 
{
    namespace Petri 
    {
        
        class LabelledPrioritizedTimeNet : public LabelledPrioritizedNet {
        public:

            static string typeName() {
                return "Diades::Petri::LabelledPrioritizedTimeNet";
            }

            typedef ::Diades::Utils::Exception<LabelledPrioritizedTimeNet> Exception;


            typedef int Time;
            typedef ::Diades::Utils::Interval Interval;

        private:
            Diades::Graph::ConstNodeMap<Interval> _staticInterval;
            list<Transition> _toDecompose;
            vector<TimeDecomposedTransition> _decompositions;
            Diades::Graph::ConstNodeMap<int> _decIndex;
          
        public:

            bool isTimeDecomposed(const Transition & t) const {
                return _decIndex[t] != -1;
            }

            
            const vector<TimeDecomposedTransition> & decomposedTransitions() const {
                return _decompositions;
            }

            
            
            void timeDecomposition();
            
            void timeDecomposition(Event  e);

            const Interval & staticInterval(const Transition & t) const {
                return _staticInterval[t];
            }

            LabelledPrioritizedTimeNet() : LabelledPrioritizedNet(), 
                _staticInterval(), 
                _toDecompose(), 
                _decompositions(), 
                _decIndex() {
                _staticInterval.init(graph());
                _decIndex.init(graph());
            }

            virtual ~LabelledPrioritizedTimeNet(){}
            
            virtual Transition newTransition(const set<Place> & pre, 
                                             const set<Place> & post,
                                             const string & name, 
                                             const Interval & interval, 
                                             Event  event);
            
            
            
            virtual void nameOfTransition2Dot(ostream & os, 
                                              Transition transition) 
                                               const;


            // ??void mergeNonTriggeredPlaces();

        protected:

            virtual void net2TinaTransitionInterval(ostream & os,
                    Transition  trans) const {
                os << _staticInterval[trans].toTina();
            }

                        
                        
                        
            virtual size_t timeDecomposition(Transition t);

                        
                        
                        virtual Transition shiftTransition(Transition t);
                        
                        
                        
                public:
                        
                        virtual Place makeEventConflictFree(Place p);
                        
                        
                        virtual void makeEventConflictFree();
                        
        };
    };

};

#endif /* __DIADES__PETRI__LABELLEDPRIORITIZEDTIMENET__HH__ */