Event.hh

Go to the documentation of this file.

/*
 * @file Event,hh
 * @author Yannick Pencolé, ypencole@laas.fr, LAAS-CNRS,Univ. Toulouse
 *
 * Created on October 23rd 2017, 22:19
 */

#ifndef __DIADES_AUTOMATA_EXPERIMENTAL_EVENT_HH
#define __DIADES_AUTOMATA_EXPERIMENTAL_EVENT_HH
#include<unordered_map>
#include<vector>
#include <diades/utils/Exceptions.hh>
#include <diades/utils/Assertion.hh>
#include <diades/utils/Verbose.hh>
#include <diades/utils/InfoManager.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {
         using Diades::Utils::Msg;
         using Diades::Utils::NullValue;
         using Diades::Utils::InfoManager;
             
         template<typename _Event,
         typename _EventId,
         typename NullEvent = NullValue<_Event>,
         typename NullEventId = NullValue<_EventId>,
         typename Hash = std::hash<_Event> >
         class EventManager :
         public InfoManager<_Event,
         _EventId,
         NullEvent,
         NullEventId,
         Hash>
         {
         public:
            using IM = InfoManager<_Event,
                    _EventId,
                    NullEvent,
                    NullEventId,
                    Hash>;
            using Event = typename IM::Info;
            using EventId = typename IM::InfoId;

            static string
            typeName()
            {
               return "Diades::Automata::Experimental::EventManager";
            }
            using Exception = Diades::Utils::Exception<EventManager>;


           


         private:

            using EventIdIterator = typename IM::InfoIdIterator;




           

         public:




            EventManager() = default;


            EventManager(EventManager const& other) = default;

            EventManager& operator=(EventManager const& other) = default;
          
            
            
            
            EventManager(EventManager&& other) = default;
            EventManager& operator=(EventManager&& other) = default;

            virtual ~EventManager() = default;

            bool
            hasEvent(const Event & event) const
            {
               return IM::hasInfo(event);
            }

            bool
            hasEventId(EventId id) const
            {
               return IM::hasInfoId(id);
            }

            bool
            setEvent(const Event & event, EventId id)
            {
               return IM::setInfo(event,id);
            }

            EventId
            eventId(const Event & event)
            {
               return IM::infoId(event);
            }

            const Event &
            getEvent(EventId id) const
            {
               return IM::getInfo(id);
            }


            size_t
            numberOfEvents() const
            {
               return IM::numberOfInfos();
            }
            
            EventId nullEventId() const
            {
               return IM::nullInfoId;
            }
            
            Event nullEvent() const
            {
               return IM::nullInfo;
            }
            
         };
         
         
//         /**
//          * @struct EventStringLabel
//          * This structure can be used to instanciate EventManager
//          * that would create Event with label as string.
//          * 
//          * 
//          */
//         struct EventStringLabel
//         {
//            typedef std::string Label;
//
//            static Label
//            nullLabel()
//            {
//               return "";
//            }
//
//            static Label
//            appendLabel(const Label & prefix, const Label & postfix)
//            {
//               return prefix + postfix;
//            }
//
//         };
//
//         /**
//          * @class EventManager
//          * An EventManager is a container of EventStructure. An EventStructure
//          * associates to an identifier an EventLabel. Based on this class
//          * it is then possible to manipulate Event as simple ids. No pointers/references
//          * are embedded in an Event. To get the effective label of a given Event ask
//          * the EventManager (hash table + vector). For efficiency purpose, an Event 
//          * does not even hold a pointer about the EventManager that creates it. 
//          * It means that an Event may have several meanings depending on the 
//          * EventManagers that are available. It is up to the client to manage 
//          * Event's ownership.
//          * 
//          * An EventManager aims at being very flexible. It can be copied. We can perform
//          * intersection, union of EventManagers. But be aware that two EventManagers are
//          * totally independent. A consistency check can be performed to attest that
//          * an EventManager owns a subset of events from another manager with the same codes.
//          * If two EventManagers own the same EventLabel with the same codes they are equivalent.
//          * 
//          * The template parameter EventLabel should implement a static method nullLabel()
//          * that returns a null label of class Label
//          */
//         template<typename EventLabel, typename EventId>
//         class EventManager
//         {
//         public:
//
//
//            /// Label the real content of an Event
//            typedef typename EventLabel::Label Label;
//
//            /// the mapping between any Label and any Event
//            typedef std::unordered_map<Label, EventId> Map;
//
//            static string
//            typeName()
//            {
//               return "Automata::Experimental::EventManager";
//            }
//            typedef Diades::Utils::Exception<EventManager> Exception;
//
//
//
//         private:
//
//            /**
//             * @class EventStructure
//             * This class implements the content of an Event (data associated
//             * to an Event). Basically, it is a name (Label) and possibly a nickname 
//             * (Label). 
//             */
//            struct EventStructure
//            {
//
//               EventStructure() : _label(EventLabel::nullLabel()), _nickname(EventLabel::nullLabel()), _event(0)
//               {
//               }
//
//               /**
//                * Paramterized constructor
//                * @param label the Label of the Event
//                * @param nickname the nickname of the Event (Label)
//                * @param event the id of the Event.
//                * 
//                */
//               EventStructure(Label label, Label nickname, EventId event) :
//               _label(label), _nickname(nickname), _event(event)
//               {
//               }
//
//               /**
//                * Move constructor
//                * @param structure the EventStructure to move
//                */
//               EventStructure(EventStructure && structure) :
//               _label(structure._label),
//               _nickname(structure._nickname),
//               _event(structure._event)
//               {
//               }
//
//               /**
//                * Copy constructor
//                * @param structure the EventStructure to copy
//                */
//               EventStructure(const EventStructure & structure) :
//               _label(structure._label),
//               _nickname(structure._nickname),
//               _event(structure._event)
//               {
//               }
//
//               /**
//                * Assignment operator
//                * @param es the EventStructure to copy
//                * @return the current EventStructure
//                */
//               EventStructure & operator=(const EventStructure & es)
//               {
//                  if(this != &es)
//                  {
//                     _label = es._label;
//                     _nickname = es._nickname;
//                     _event = es._event;
//                  }
//                  return *this;
//               }
//
//               /**
//                * Equality operator
//                * @param es the EventStructure to compare with
//                * @return true is both EventStructure are equal (value equality)
//                */
//               bool operator==(const EventStructure & es) const
//               {
//                  return(_event == es._event) && (_nickname == es._nickname) && (_label == es._label);
//               }
//
//               /** Difference operator
//                * @param es the EventStructure to compare with
//                * @return true is both EventStructure are difference (value difference)
//                */
//               bool operator!=(const EventStructure & es) const
//               {
//                  return !(*this == es);
//               }
//               Label _label;
//               Label _nickname;
//               EventId _event;
//            };
//
//
//            /// _eventMap association between a Label and its corresponding Event id
//            Map _eventMap;
//            /** _events Event storage of the Events created by the manager. The Event of 
//             * index i is stored in _events[i] and _events[i]._event == i
//             *
//             **/
//            std::vector<EventStructure> _events;
//
//            /**
//             * _eventIds might look redundant as it is a vector such that 
//             * _events[i] = index useful to implement an iterator begin/end
//             * on the _events of the manager
//             **/
//            std::vector<EventId> _eventIds;
//
//
//
//
//         public:
//
//            /**
//             * Default constructor
//             * 
//             * Any default manager owns a null Event
//             */
//            EventManager() : _eventMap(), _events(), _eventIds()
//            {
//               _events.emplace_back();
//               _eventMap[EventLabel::nullLabel()] = nullEvent();
//               _eventIds.push_back(0);
//            }
//
//            /**
//             * Copy constructor
//             * @param manager the manager to copy
//             */
//            EventManager(const EventManager & manager) :
//            _eventMap(manager._eventMap),
//            _events(manager._events),
//            _eventIds(manager._eventIds)
//            {
//            }
//
//            /**
//             * Move constructor
//             * @param manager the manager to move
//             */
//            EventManager(EventManager && manager) :
//            _eventMap(manager._eventMap),
//            _events(manager._events),
//            _eventIds(manager._eventIds)
//            {
//            }
//
//            /**
//             * Destructor
//             */
//            ~EventManager()
//            {
//               clear();
//            }
//
//            /**
//             * Assignment operator
//             * @param manager the manager to copy
//             * @return the current manager
//             */
//            EventManager & operator=(const EventManager & manager)
//            {
//               if(this != &manager)
//               {
//                  _eventMap = manager._eventMap;
//                  _events = manager._events;
//                  _eventIds = manager._eventIds;
//               }
//               return *this;
//            }
//
//            /**
//             * 
//             * @param label a Label
//             * @return true if the manager owns an Event with such a Label
//             */
//            bool
//            hasEvent(const Label & label) const
//            {
//               return _eventMap.find(label) != _eventMap.end();
//            }
//
//            /**
//             * 
//             * @param event an Event
//             * @return true if the manager owns such an Event
//             */
//            bool
//            hasEvent(EventId event) const
//            {
//               if(event == 0)
//               {
//                  return true;
//               }
//               return _events.size() > event && _events[event]._event != 0;
//            }
//
//            /**
//             * Associate the specific label to a specific event id
//             * @param label
//             * @param event
//             * @return true if the assignement is a success
//             * (i.e. label is indeed associated with id. id was not assigned to
//             * anything else, and label was not assigned to another id
//             */
//            bool
//            setEvent(const Label & label, EventId evt)
//            {
//               if(hasEvent(label))
//               {
//                  return event(label) == evt;
//               }
//               if(evt >= _events.size())
//               {
//                  _events.resize(evt + 1);
//               }
//               _events[evt]._event = evt;
//               _events[evt]._label = label;
//               _events[evt]._nickname = label;
//               _eventIds.push_back(evt);
//               _eventMap[label] = evt;
//               return true;
//            }
//
//            /**
//             * 
//             * @param label a Label
//             * @return the Event of the manager whose Label is label
//             */
//            EventId
//            event(const Label & label)
//            {
//               auto it = _eventMap.find(label);
//               if(it == _eventMap.end())
//               {
//                  _eventMap[label] = _events.size();
//                  _events.emplace_back(label, label, _events.size());
//                  _eventIds.push_back(_events.back()._event);
//                  return _events.back()._event;
//               }
//               return it->second;
//            }
//
//            /**
//             * 
//             * @param event an Event
//             * @return the Label of the Event
//             * @pre hasEvent(event)
//             */
//            const Label &
//            getLabel(EventId event) const
//            {
//               require(Exception, hasEvent(event),
//                       Msg("getLabel: event %1% does not exist in this EventManager")
//                       % event);
//               return _events[event]._label;
//            }
//
//            /**
//             * 
//             * @param event an Event
//             * @return the nickname (Label) of the Event
//             * @pre hasEvent(event)
//             */
//            const Label &
//            getNickname(EventId event) const
//            {
//               require(Exception, hasEvent(event),
//                       Msg("getNickname: event %1% does not exist in this EventManager")
//                       % event);
//               return _events[event]._nickname;
//            }
//
//            /**
//             * 
//             * @return the set of (Label -> Event) contained in the manager 
//             */
//            const EventManager::Map &
//            map() const
//            {
//               return _eventMap;
//            }
//
//            /**
//             * 
//             * @return the null Event of the manager 
//             */
//            EventId
//            nullEvent() const
//            {
//               return EventId();
//            }
//
//            /**
//             * 
//             * @param e an Event
//             * @return true if e is the null Event of the manager
//             */
//            bool
//            isNull(EventId e) const
//            {
//               return e == nullEvent();
//            }
//
//            /**
//             * @param capacity the capacity to reserve
//             * @return the current EventManager
//             * 
//             * The current EventManager is fully reinitialised so any
//             * Event that was associate with it is now invalid (except the
//             * null Event). 'capacity' allocates memory. The recommended 
//             * use is to create less Events than capacity. If more, there
//             * will be  memory reallocation (performance issue only).
//             * 
//             * @pre capacity > 0 
//             */
//            EventManager &
//            initialise(unsigned capacity)
//            {
//               require(Exception, capacity > 0,
//                       Msg("initialise: capacity is set to %1%")
//                       % capacity);
//               clear();
//               _events.reserve(capacity + 1);
//               _events.emplace_back();
//               _eventIds.push_back(0);
//               _eventMap[EventLabel::nullLabel()] = nullEvent();
//               return *this;
//            }
//
//         private:
//
//            /**
//             * Clear the manager, the manager is invalid
//             */
//            void
//            clear()
//            {
//               _events.clear();
//               _eventIds.clear();
//               _eventMap.clear();
//            }
//
//         public:
//            using EventIterator = typename std::vector<EventId>::const_iterator;
//
//            /**
//             * 
//             * @return an iterator on the first Event of the manager
//             */
//            EventIterator
//            begin() const
//            {
//               return _eventIds.begin();
//            }
//
//            /**
//             * 
//             * @return an iterator after the last Event of the manager 
//             */
//            EventIterator
//            end() const
//            {
//               return _eventIds.end();
//            }
//
//            /**
//             * 
//             * @return the number of events (null event is included)
//             */
//            EventId
//            numberOfEvents() const
//            {
//               return(EventId) _eventIds.size();
//            }
//
//            /**
//             * Consistency checking
//             * @param manager the manager to check with
//             * @return true if the current manager is consistent with
//             * the other one.
//             * 
//             * @p consistency: a manager is consistent with another one
//             * if any Event owned by the current manager is owned by
//             * the other one with the same Label.  
//             */
//            bool
//            isConsistentWith(const EventManager & manager) const
//            {
//               if(numberOfEvents() > manager.numberOfEvents())
//               {
//                  return false;
//               }
//               bool result = true;
//               size_t index = 1;
//               while(index < numberOfEvents())
//               {
//                  result = (_events[index] == manager._events[index]);
//                  ++index;
//               }
//               return result;
//            }
//
//            /**
//             * Equivalence checking
//             * @param manager the manager to check with
//             * @return true if the current manager is equivalent to
//             * the other one.
//             * 
//             * @p equivalence: a manager is equivalent to another one
//             * if any Event owned by the current manager is owned by
//             * the other one with the same Label and reciprocally
//             */
//            bool
//            isEquivalentTo(const EventManager & manager) const
//            {
//               return isConsistentWith(manager) && manager.isConsistentWith(*this);
//            }
//
//            /**
//             * Manager appending
//             * @param manager the manage to append
//             * @return the current EventManager that results from the appending
//             * with the other one.
//             * 
//             * 
//             * By appending, we mean that any Label of the manager in 
//             * parameter will be included in the current manager. However,
//             * the Event of the current manager associated with a given Label
//             * might not be (will certainly be not)  the same as the Event 
//             * in the other manager.
//             */
//            EventManager &
//            appendWith(const EventManager & manager)
//            {
//               if(this != &manager)
//               {
//                  for(EventId evt = 1; evt < manager.numberOfEvents(); ++evt)
//                  {
//                     event(manager.getLabel(evt));
//                  }
//               }
//               return *this;
//            }
//
//            /**
//             * Intersection of two EventManager's
//             * @param m1 the first EventManager
//             * @param m2 the second EventManager
//             * @return the current EventManager.
//             * 
//             * The current EventManager is the intersection of m1 and m2.
//             * It means that the current EventManager consists of the Label
//             * owned by both m1 and m2. The associated Event is obviously 
//             * different.
//             */
//            EventManager &
//            makeIntersection(const EventManager & m1,
//                             const EventManager & m2)
//            {
//               if(&m1 == &m2)
//               {
//                  if(this != &m1)
//                  {
//                     *this = m1;
//                  }
//                  return *this;
//               }
//
//               if(this == &m1)
//               {
//                  EventManager tmp(*this);
//                  makeIntersection(tmp, m2);
//               }
//               else
//               {
//                  if(this == &m2)
//                  {
//                     EventManager tmp(*this);
//                     makeIntersection(m1, tmp);
//                  }
//                  else
//                  {
//                     initialise(m1.numberOfEvents() + 1);
//                     for(size_t i = 1; i < m1.numberOfEvents(); ++i)
//                     {
//                        if(m2.hasEvent(m1.getLabel(i)))
//                        {
//                           event(m1.getLabel(i));
//                        }
//                     }
//
//                  }
//               }
//               return *this;
//            }
//
//            /**
//             * Union of two EventManager's
//             * @param m1 the first EventManager
//             * @param m2 the second EventManager
//             * @return the current EventManager.
//             * 
//             * The current EventManager is the union of m1 and m2.
//             * It means that the current EventManager consists of the Label
//             * owned by at least one EventManager m1 or m2. The associated 
//             * Event is obviously different.
//             */
//            EventManager &
//            makeUnion(const EventManager & m1,
//                      const EventManager & m2)
//            {
//               if(&m1 == &m2)
//               {
//                  if(this != &m1)
//                  {
//                     *this = m1;
//                  }
//                  return *this;
//               }
//               if(this == &m1)
//               {
//                  for(size_t i = 1; i < m2.numberOfEvents(); ++i)
//                  {
//                     if(!hasEvent(m2.getLabel(i)))
//                     {
//                        event(m2.getLabel(i));
//                     }
//                  }
//               }
//               else
//               {
//                  if(this == &m2)
//                  {
//
//                     for(size_t i = 1; i < m1.numberOfEvents(); ++i)
//                     {
//                        if(!hasEvent(m1.getLabel(i)))
//                        {
//                           event(m1.getLabel(i));
//                        }
//                     }
//
//
//
//                  }
//                  else
//                  {
//                     *this = m1;
//                     appendWith(m2);
//                  }
//
//               }
//               return *this;
//            }
//
//            /**
//             * Assign the current EventManager with all the events from
//             * the other one. Each event has a label appended with a prefix
//             * Note that the null event remains  unmodified
//             * @param mgr the EventManager to copy
//             * @param prefix the prefix to add to any Event of mgr
//             * @return the current EventManager
//             */
//            EventManager &
//            assignWith(const EventManager & mgr,
//                       const Label & prefix)
//            {
//               initialise(mgr._events.capacity());
//               for(auto & pair : mgr.map())
//               {
//                  if(!mgr.isNull(pair.second))
//                  {
//                     event(EventLabel::appendLabel(prefix, pair.first));
//                  }
//               }
//               return *this;
//            }
//         };
      }
   }
}





#endif /* EVENT_HH */