Event.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EVENT__HH
#define __DIADES__AUTOMATA__EVENT__HH

/*
 * Event.hh
 *
 *  Created on: 2 dec. 2008
 *      Author: ypencole
 */



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


using std::istream;
using std::ostream;
using std::vector;
using std::unordered_map;

namespace Diades
{
  namespace Automata {


        class EventFactory;

    

        typedef struct {
          unsigned _id;
          string _label;
          string _nickname;
        } EventData;



        class Event {
          public:
                static string typeName() { return "Automata::Event"; }
               
                typedef Diades::Utils::Exception<Event> Exception;
          typedef unsigned Id;
          




          typedef string Label;
 
           static Event  nullEvent();
           
           static const Event::Label & nullEventLabel();
           
           
           static Event getEvent(const Label & evtLabel);
           
           static Event  getEvent(const Id & evtId);
           
           static void allocateEvents(size_t capacity);
           
           static void destroyEvents();
           
        public:
          typedef EventData * EventDataPointer;  
        
        private:
          EventDataPointer _ptr; // pointer to the EventData

          Event(EventDataPointer data):_ptr(data) {}

        public:
//        template<class Archive>
//        void save(Archive & ar, const unsigned int version) const
//        {
//              if(isValid())
//                {
//                      unsigned idt = id();
//                      ar & idt;
//                      string lab = label();
//                      ar << lab;
//                      lab = nickname();
//                      ar <<  lab;
//                }
//              else
//                {
//                      string empty;
//                      unsigned zero = 0;
//                      ar & zero;
//                      ar & empty;
//                      ar & empty;
//                }
//        }
//        
//        template<class Archive>
//        void load(Archive & ar, const unsigned int version);
//
//        BOOST_SERIALIZATION_SPLIT_MEMBER();
                
        public:
          Event():_ptr(nullptr){}

          Event(const Event & e):_ptr(e._ptr){}

          bool isValid() const { return _ptr != nullptr; }

          const Label & label() const;
        
          const Label & nickname() const {
                require(Exception,isValid(),"nickname: the event is invalid.");
                return _ptr->_nickname;
          }


        
          void setNickname(const Label & nick)
          {
                _ptr->_nickname = nick;
          }
        
          Id   id()   const {
                require(Exception,isValid(),"id: the event is invalid.");
                return _ptr->_id;
          }

          Event & operator=(const Event & e) { if(this != &e) { _ptr = e._ptr; } return *this; }

          bool operator < (const Event & e) const {
                if( (!isValid()) && (!e.isValid()))
                  {
                        return false;
                  }
                if(!isValid())
                  {
                        return true;
                  }
                if(!e.isValid())
                  {
                        return false;
                  }
                return id() < e.id();
          }

          bool operator == (const Event & e) const {
                if(isValid() && e.isValid())
                  {
                        return ( id() == e.id() );
                  }
                return (!isValid()) && (!e.isValid());
          }

          bool operator != (const Event & e) const {
                return !(*this == e);
          }



          bool operator > (const Event & e) const {
                return !( ((*this) < e) || ((*this) == e));
          }

          int memoryUsage() const { return sizeof(_ptr); };

          int dataMemoryUsage() const { if(isValid()) { return sizeof(_ptr->_id) + sizeof(_ptr->_label) + sizeof(_ptr->_nickname); } return 0; }

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

          friend istream & operator >>(istream & is, Event & e);
          
          
          ostream & save(ostream & os) const
          {
                require(Exception,isValid(),"save: invalid event");
                return os << id() << " " << label() << " " << nickname();
          }

          istream & load(istream & is);

          friend class EventFactory;
        };
  };
};


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

        
        class EventFactory
        {
        public:
               static string typeName() { return "Automata::EventFactory"; }
                typedef Diades::Utils::Exception<EventFactory> Exception;
          static void destroy();

          static void init(size_t capacity);
          
          static EventFactory * factory();

          Event getEvent(Event::Id id);

          Event setEvent(Event::Id id, const Event::Label & label, const Event::Label & nick);  

          Event nullEvent() const { return _events[0]; }

          Event getEvent(const Event::Label & label);

          ~EventFactory();

          const Event::Label & nullEventLabel() const
          {
                return _nullEventLabel;
          }

          size_t capacity() const
          {
            return _events.capacity();
          }
          
        protected:

          EventFactory();

          EventFactory(size_t capacity);
          
        private:
          static EventFactory * _instance; // the unique instance of EventFactory
          vector<Event> _events; // the set of created events _events[0] is the null event
          unordered_map<Event::Label,Event> _mapping; // mapping to get the event from the label
          Event::Label _nullEventLabel;

        };



//      template<class Archive>
//      void Event::load(Archive & ar, const unsigned int version)
//      {
//        Event::Id id;
//        string label;
//        string nickname;
//        ar & id;
//        ar & label;
//        ar & nickname;
//        if(label.empty())
//              {
//                _ptr = 0;
//              }
//        else
//              {
//                operator=(EventFactory::factory()->setEvent(id,label,nickname));
//              }
//      }

  };

};



          

#endif