Event.hh

Go to the documentation of this file.

#ifndef __DIADES__PETRI__EVENT__HH__
#define __DIADES__PETRI__EVENT__HH__

#include<iostream>
#include<unordered_map>
#include<vector>
#include<utils/Assertion.hh>
#include<utils/Substring.hh>

using std::vector;

namespace Diades
{
  namespace Petri
  {


        class EventInvalid : public runtime_error, public domain_error
        {
        public:
          EventInvalid(const string& whatArg) : runtime_error(whatArg),  domain_error(whatArg){
                ::std::cerr << "EXCEPTION Event -> " << whatArg << ::std::endl;
          }
        };




        class Event;

        class EventData {
        private:
          string _type;
          size_t _id;

        private:
          EventData(const string & type, size_t id):_type(type),_id(id){}

          const string &  type() const { return _type; }



          size_t  id() const { return _id; }

          friend class Event;
        };

        class EventFactory;

        class Event {
        private:
          EventData * _data;
        public:
          Event():_data(0){}

        private:
          Event(const string & type,size_t id):_data(new EventData(type,id)){}

        public:
          Event(const Event & event):_data(event._data){}


          string  type() const { if(isNull()) {return "Null";}  return _data->type(); }

          bool isNull() const { return _data == 0; }

          bool operator == (const Event & e) const { return _data == e._data; }

          bool operator < (const Event & e) const { return _data < e._data; }

          bool operator > (const Event & e) const { return _data > e._data; }

          size_t id() const { if(_data == 0) { return 0; } return _data->id(); }

          friend std::ostream & operator << (std::ostream & os, const Event & e) { return os << e.type(); }


          friend class EventFactory;
        };
  };
};

namespace std
{
  template<> struct hash<Diades::Petri::Event> {
        size_t operator()(const Diades::Petri::Event & e) const {
          return e.id();
        }
  };
};


namespace Diades
{
  namespace Petri
  {


        class EventFactory
        {
        public:

          static EventFactory * Instance();

        protected:
          EventFactory():_events(1),_mapping(){}

        public:
          const Event & getEvent(const string & type)
          {
                unordered_map<string,Event>::const_iterator it = _mapping.find(type);
                if(it == _mapping.end())
                  {
                        size_t newId = _events.size();
                        _events.push_back(Event(type,newId));
                        _mapping[type] = _events.back();
                        return _events.back();
                  }
                return it->second;
          }

          const Event & getEvent(size_t id) const
          {
                require(EventInvalid, _events.size() > id,"getEvent: invalid id");
                return _events[id];
          }


          ~EventFactory();

          size_t numberOfCurrentEvents() const { return _events.size(); }

        private:
          vector<Event> _events;
          unordered_map<string,Event> _mapping;
          static EventFactory * _instance;
        };
  };
};

#endif