QHandle.hh

Go to the documentation of this file.

#ifndef _Q_HANDLE_HH_
#define _Q_HANDLE_HH_
 
#include <sstream>
#include "QObject.hh"
#include "QError.hh"
#include "QDemangle.hh"
#include "QDiana.hh"
 
Q_BEGIN_NAMESPACE
 
template<class T> class QHandle
{
        public:
 
                virtual bool Exists() const {return (fObject ? true : false);}
 
                virtual bool IsValid() const {return (Exists() && fObject->IsValid());}
 
                const char* GetObjectName() const { return fObjectName; } 
 
                const char* GetObjectOwner() const { return fOwner; } 
        
        std::string GetObjectType() const { return Demangle(fObject); } 
 
                void Set(QObject** address,const char* owner) 
                { 
                        if(fObject) {
                                std::stringstream msg;
                msg<<"QHandle of type: "<<GetObjectType()
                    <<" already owns a QObject";
                if(fOwner)
                    msg<<" Owned by: "<<fOwner; 
 
                throw QError(QERR_EVENT_HANDLE,__FILE__,__LINE__,msg.str());
                        }
            fOwner = owner;
            fAddress = address;
            if(fAddress) fObject = dynamic_cast<T*>((QObject*)*fAddress); 
        }
 
        virtual ~QHandle() {};
 
        protected:
 
        QHandle(const char* objectName) : fObject(0), fAddress(0)
        { 
            fObjectName = objectName;
            fOwner = "";
        }
 
        void ThrowError() const
        { 
            std::stringstream msg;
            msg<<"Object ( Name: "<<this->fObjectName
               <<"; Owner: "<<this->fOwner
               <<"; Type: "<<this->GetObjectType();
            if(!Exists()) {
               msg<<" ) does not exist";
            } else {
               msg<<"; Address: "<<fObject;
               if(!IsValid()) {
                   msg<<" ) is not valid";
               } else {
                   msg<<" ) is valid"; // so why an error? :)
               }
 
            }
            throw QError(QERR_EVENT_HANDLE,__FILE__,__LINE__,msg.str());
        }
 
    protected:
        QObject** BaseGetAddress()
        {
            return fAddress;
        }
 
        const char* fObjectName;
        const char* fOwner;
                T* fObject;
        QObject** fAddress;
 
        QHandle(const QHandle&) {};
        const QHandle& operator=(const QHandle&) { return *this; };
 
        private:
};
 
template<typename T> class ReadHandle : public QHandle<T>
{
        public:
        ReadHandle(const char* name) : QHandle<T>(name) {}
 
 
        const T& Get() const 
        { 
            if(!this->IsValid()) this->ThrowError(); 
            return *(this->fObject); 
        } 
 
    private:
};
 
template<typename T> class WriteHandle : public QHandle<T> 
{
    public:
        WriteHandle(const char* name) : QHandle<T>(name) {}
 
        T& Get()
        { 
            if(!this->Exists()) {
                std::stringstream msg;
                msg<<"Object ( Name: "<<this->fObjectName
                    <<"; Owner : "<<this->fOwner
                    <<"; Type: "<<this->GetObjectType()
                    <<" ) does not exist (probably not added to the event?)";
                throw QError(QERR_EVENT_HANDLE,__FILE__,__LINE__,msg.str());
            }
            // if somebody wants to write it, it is automatically made valid.
            this->fObject->Validate();
            return *(this->fObject);
        }
 
        void CreateObject(const char* owner) 
        {
            T** pobj = new (T*);
            *pobj = new T;
            T* obj = *pobj;
            if(obj) {
                obj->Reset();
                this->Set((QObject**)pobj,owner);
            }
        }
 
        QObject** GetAddress() 
        {
            return this->BaseGetAddress();
        }
 
 
};
 
 
Q_END_NAMESPACE
 
#endif