base/SubEvent.h

#ifndef BASE_SUBEVENT_H
#define BASE_SUBEVENT_H
 
#include <algorithm>
#include <vector>
 
namespace base {
 
 
   class SubEvent {
      public:
         SubEvent() {}
 
         virtual ~SubEvent() {}
 
         virtual void Clear() {}
 
         virtual void Sort() {}
 
         virtual unsigned Multiplicity() const { return 0; }
 
   };
 
   template<class MsgClass>
   class MessageExt {
      protected:
         MsgClass fMessage; 
 
         double fGlobalTime;  
 
      public:
 
         MessageExt() :
            fMessage(),
            fGlobalTime(0.)
         {
         }
 
         MessageExt(const MsgClass& _msg, double globaltm) :
            fMessage(_msg),
            fGlobalTime(globaltm)
         {
         }
 
         MessageExt(const MessageExt& src) :
            fMessage(src.fMessage),
            fGlobalTime(src.fGlobalTime)
         {
         }
 
         MessageExt& operator=(const MessageExt& src)
         {
            fMessage = src.fMessage;
            fGlobalTime = src.fGlobalTime;
            return *this;
         }
 
         ~MessageExt() {}
 
         bool operator<(const MessageExt &rhs) const
            { return (fGlobalTime < rhs.fGlobalTime); }
 
         const MsgClass& msg() const { return fMessage; }
 
         double GetGlobalTime() const { return fGlobalTime; }
   };
 
 
   template<class MsgClass>
   class SubEventEx : public base::SubEvent {
      protected:
         std::vector<MsgClass> fExtMessages;   
 
      public:
 
         SubEventEx(unsigned capacity = 0) : base::SubEvent(), fExtMessages()  { fExtMessages.reserve(capacity); }
 
         ~SubEventEx() {}
 
         void AddMsg(const MsgClass &_msg) { fExtMessages.emplace_back(_msg); }
 
         unsigned Size() const { return fExtMessages.size(); }
 
         unsigned Capacity() const { return fExtMessages.capacity(); }
 
         void SetCapacity(unsigned sz) { fExtMessages.reserve(sz); }
 
         MsgClass &msg(unsigned indx) { return fExtMessages[indx]; }
 
         std::vector<MsgClass>* vect_ptr() { return &fExtMessages; }
 
         virtual unsigned Multiplicity() const { return Size(); }
 
         virtual void Clear() { fExtMessages.clear(); }
 
         virtual void Sort()
         {
            std::sort(fExtMessages.begin(), fExtMessages.end());
         }
 
   };
 
}
 
#endif