QEvent.hh

Go to the documentation of this file.

#ifndef _Q_EVENT_HH_
#define _Q_EVENT_HH_
 
#include <string>
#include <sstream>
#include <map>
#include <vector>
#include <iostream>
#include "QObject.hh"
#include "QError.hh"
#include "QHandle.hh"
#include "QDiana.hh"
#include "QAliases.hh"
#include "QEventLabel.hh"
 
Q_BEGIN_NAMESPACE
 
class QEvent 
{
    public:
        typedef std::map<QEventLabel,QObject**> QObjectMap;
 
        QEvent();
 
        QEvent(const QEvent& ev);
 
        ~QEvent();
 
        unsigned int GetReadNumber() const {return fReadNumber;}
 
        template<typename Q> void Get(const char* owner,ReadHandle<Q>& handle) const 
        {
            handle.Set(0,owner);
            QObject** evData = GetObject(owner,handle.GetObjectName());
            if(evData) handle.Set(evData,owner);
        }
        template<typename Q> void Get(ReadHandle<Q>& handle) const 
        {
            const char* owner = fModuleName->c_str();
            handle.Set(0,owner);
            QObject** evData = GetObject(owner,handle.GetObjectName());
            if(evData) handle.Set(evData,owner);
        }
 
        template<typename Q> const Q& Get(const char* owner, const char* name) const
        {
            ReadHandle<Q> handle(name);
            Get(owner,handle);
            return handle.Get();
        }
 
        template<typename Q> const Q& Get(const char* name) const
        {
            ReadHandle<Q> handle(name);
            Get(handle);
            return handle.Get();
        }
 
        template<typename Q> const Q& GetByLabel(const QEventLabel& label) const
        {
            ReadHandle<Q> handle(label.GetName().c_str());
            handle.Set(0,label.GetOwner().c_str());
            QObject** evData = this->GetObjectByLabel(label);
            if(evData) handle.Set(evData,label.GetOwner().c_str());
            return handle.Get();
        }
 
        template<typename Q> void Get(WriteHandle<Q>& handle) 
        {
            if(!fModuleName) {
                std::stringstream msg;
                msg<<"Module name not set while getting in write mode a "<<handle.GetObjectName();
                throw QError(QERR_EVENT_GENERIC,__FILE__,__LINE__,msg.str());
            }
            Get(fModuleName->c_str(),handle);
        }
        template<typename Q> Q& Get(const char* name)
        {
            WriteHandle<Q> handle(name);
            Get(handle);
            return handle.Get();
        }
 
        template<typename Q>  void Add(WriteHandle<Q>& handle) 
        {
            if(!fModuleName) {
                std::stringstream msg;
                msg<<"Module name not set while adding a "<<handle.GetObjectName();
                throw QError(QERR_EVENT_GENERIC,__FILE__,__LINE__,msg.str());
            }
            Add(fModuleName->c_str(),handle);
            handle.Get().SetIsJustAdded();
        }
 
        template<typename Q> Q& Add(const std::string& name)
        {
            WriteHandle<Q> handle(name.c_str());
            Add(handle);
            return handle.Get();
        }
 
        template<typename Q> void Require(const std::string& owner, const std::string& name) const
        {
            QEventLabel label(owner,name);
            return RequireByLabel<Q>(label);
        }
 
        template<typename Q> void RequireByLabel(const QEventLabel& label) const
        {
            ReadHandle<Q> handle(label.name.c_str());
            Get(label.owner.c_str(),handle);
            if(!handle.Exists()) {
                std::stringstream msg;
                msg<<"Required object: "<<label.GetStringLabel()<<" of type: "<<handle.GetObjectType()<<" not found in the event";
                throw QError(QERR_EVENT_GENERIC,__FILE__,__LINE__,msg.str());   
            } else {
                QObject** obj = GetObjectByLabel(label);
                (*obj)->SetIsRequired();
            }
        }
        void SetAlias(const std::string& name, const std::string& pathInObject, const std::string& alias)
        {
            QAliases& aliases = GetAliases();
            aliases.Add(QEventLabel(*GetOwner(),name),pathInObject,alias);
        }
 
        void Dump(std::ostream& o) const; 
 
        const QAliases& GetAliases() const { return fAliases; }
        
        const std::string* GetOwner() const { return fModuleName; }
        template<typename Q> bool Contains(const char *owner,const char *name) const
        {
            QEventLabel label(owner,name);
            QObjectMap::const_iterator it = fObjectMap.find(label);
            if(it!=fObjectMap.end()){
              if( (*(it->second))->IsA() == Q::Class() )
                return true;
            }
            return false;
        }
        template<typename Q> bool Contains(const char *label) const
        {
            QObjectMap::const_iterator it = fObjectMap.find(label);
            if(it!=fObjectMap.end()){
              if( (*(it->second))->IsA() == Q::Class() )
                return true;
            }
            return false;
        }
  
    protected:
 
 
 
        template<typename Q> void Get(const char* owner, WriteHandle<Q>& handle)
        {
            handle.Set(0,owner);
            QObject** evData = GetObject(owner,handle.GetObjectName());
            if(evData) handle.Set(evData,owner);
        }
 
        template<typename Q> void Add(const char* owner, WriteHandle<Q>& handle)
        {
            const char* name = handle.GetObjectName();
            if(!handle.GetAddress()) {
                // if found set the existing object otherwise create a new one.
                QObject** address = GetObject(owner,name);
                if(address &&  fOverWrite) 
                    handle.Set(address,owner);
                else 
                    handle.CreateObject(owner);
            }
            Add(owner,name,handle.GetAddress());
        }
 
        template<typename Q> Q& Add(const char* owner, const char* name)
        {
            WriteHandle<Q> handle(name);
            Add(owner, handle);
            return handle.Get();
        }
 
        void Clear();
 
        void Consolidate();
 
        void SetOwner(const std::string* owner) const { fModuleName = owner; }
 
        QAliases& GetAliases() { return fAliases; }
 
        std::vector<QEventLabel> GetLabels() const;
 
        void SetReadNumber(const unsigned int readNumber) {fReadNumber = readNumber; }
        
        void SetOverWrite(const bool ow = true) { fOverWrite = ow; }
        const QEvent& operator=(const QEvent& ev);
 
        QObject** GetObject(const char* owner, const char* name) const;
        QObject** GetObjectByLabel(const QEventLabel& label) const;
 
    private:
        void GetLabel(const char* owner, const char* name, QEventLabel& label) const;
 
        void Add(const char* owner, const char* name, QObject**);
 
 
        QObjectMap fObjectMap;
        std::map<std::string, std::string> fDefaultMap;
        
        const std::string mutable* fModuleName;
 
        unsigned int fReadNumber;
 
        bool fOverWrite;
 
        QAliases fAliases;
 
        friend class QEventAssembler;
        friend class QBaseModule;
};
 
Q_END_NAMESPACE
 
#endif