QGlobalHandle.hh

Go to the documentation of this file.

#ifndef _Q_GLOBALHANDLE_HH_
#define _Q_GLOBALHANDLE_HH_
#include "QGlobalReaderDispatcher.hh"
#include "QGlobalWriterDispatcher.hh"
#include "QGlobalReader.hh"
#include "QGlobalWriter.hh"
#include "QGlobalLabel.hh"
#include "QDemangle.hh"
#include <sstream>
 
Q_BEGIN_NAMESPACE
 
class QGlobalDataManager;
 
template<class Q> class GlobalHandle
{
    public:
        GlobalHandle(const std::string& name, const std::string& defaultOwner = "")
        { 
            fLabel.fName = name;
            fLabel.fOwner = "";
            fVersion = "";
            fObject = 0;
            fMyObject = 0;
            fDefaultOwner = defaultOwner;
            fGlobalDataManagerError = QERR_SUCCESS;
            fDescription = "";
        }
 
        GlobalHandle(const GlobalHandle<Q>& other)
        {
            fLabel = other.fLabel;
            fVersion = other.fVersion;
            fObject = 0;
            fMyObject = 0;
            if(other.fMyObject) {
                Set(other.Get());
            } else {
                fObject = other.fObject;
            }
            fDefaultOwner = other.fDefaultOwner;
            fGlobalDataManagerError = other.fGlobalDataManagerError;
            fDescription = other.fDescription;
        }
        virtual ~GlobalHandle() 
        { 
            if(fMyObject) delete fMyObject;
        };
 
        const QGlobalLabel& GetLabel() const { return fLabel; }
        const std::string& GetName() const { return fLabel.fName; }
        const std::string& GetOwner() const { return fLabel.fOwner; }
        const std::string& GetDefaultOwner() const { return fDefaultOwner; }
        int GetChannel() const { return fLabel.fChannel; }
        int GetChannel2() const { return fLabel.fChannel2; }
        int GetBeginRun() const { return fLabel.fBeginRun; }
        int GetEndRun() const { return fLabel.fEndRun; }
        int GetRun() const { return fLabel.fBeginRun; }
        int GetBeginDataset() const { return fLabel.fBeginDataset; }
        int GetEndDataset() const { return fLabel.fEndDataset; }
        int GetDataset() const { return fLabel.fBeginDataset; }
        void GetValidityInterval(int& beginRun, int& endRun) const
        {
            beginRun = fLabel.fBeginRun; 
            endRun = fLabel.fEndRun; 
        }
        void SetChannel(const int chan) { fLabel.fChannel = chan; }
        void SetChannel2(const int chan) { fLabel.fChannel2 = chan; }
        void SetRunInterval(const int start, const int end) { fLabel.fBeginRun = start; fLabel.fEndRun = end; }
        void SetRun(const int run) { fLabel.fBeginRun = fLabel.fEndRun = run; }
 
        void SetDatasetInterval(const int start, const int end) { fLabel.fBeginDataset = start; fLabel.fEndDataset = end; }
        void SetDataset(const int ds) { fLabel.fBeginDataset = fLabel.fEndDataset = ds; }
 
        void AddKey(const std::string& key, const int digits)
        {
            QGlobalLabel::ExtraKey& thisKey =  fLabel.fExtraKeys[key];            
            thisKey.Clear();
            thisKey.fDigits = digits;
        }
        void SetKey(const std::string& key, const int value)
        {
            if( fLabel.fExtraKeys.find(key) == fLabel.fExtraKeys.end()) {
                std::stringstream msg;
                msg<<"QGlobalHandle of type: "<<Demangle(fObject)
                    <<" has no extra key: \""
                    <<key
                    <<"\". Add it via GloabalHandle::AddKey() in your GlobalHandle ctor)";
                DianaThrow( QError(QERR_GLOBAL_HANDLE,__FILE__,__LINE__,msg.str()) );
 
            }
            fLabel.fExtraKeys[key].fValue = value;
        }
        int GetKey(const std::string& key) const 
        {
            if( fLabel.fExtraKeys.find(key) == fLabel.fExtraKeys.end()) {
                std::stringstream msg;
                msg<<"QGlobalHandle of type: "<<Demangle(fObject)
                    <<" has no extra key: \""
                    <<key
                    <<"\". Add it via GloabalHandle::AddKey() in your GlobalHandle ctor)";
                DianaThrow( QError(QERR_GLOBAL_HANDLE,__FILE__,__LINE__,msg.str()) );
 
            }
            return fLabel.fExtraKeys.find(key)->second.fValue;
        }
 
        bool HaveKey(const std::string& key) const
        {
            return (fLabel.fExtraKeys.find(key) != fLabel.fExtraKeys.end());
        }
 
 
        void Set(const Q& obj) 
        { 
            CreateObject();
            fObject->Reset();
            obj.Q::Fill(fObject);
            // Force validity
            fObject->Validate();
        } 
        const Q& Get() const 
        { 
            if(!IsValid()) {
                std::stringstream msg;
                msg<<"Global Object (Name: \""<<this->GetName()
                    <<"\" , Owner: \""<<this->GetOwner()<<"\", label: \""<<fLabel.GetStringLabel()<<"\") is not valid";
                if(fGlobalDataManagerError != QERR_SUCCESS) {
                    msg<<": "<<fGlobalDataManagerError.GetDescription();
                }
                DianaThrow( QError(QERR_GLOBAL_HANDLE,__FILE__,__LINE__,msg.str()));
            } 
            return *fObject;
        } 
        bool IsValid() const  {return fObject && fObject->IsValid(); }
 
        const QError& GetError() const { return fGlobalDataManagerError; }
 
        void SetDescription(const std::string& descr) { fDescription = descr; }
 
        virtual QError FillFromFile(const std::string& fname)
        {
            QError err = QERR_SUCCESS;
            const QGlobalReader* reader = QGlobalReaderDispatcher::GetInstance().GetReader(fname,err);
            const Q* tobj = 0;
            std::string key = fLabel.GetStringLabel();
            if(reader) {
                tobj = reader->Get<Q>(fLabel,err);
            } else {
                std::string str = "Error while opening file: \"";
                str += fname + "\": ";
                str += err.GetDescription();
                err.SetDescription(str);
                return err;
            }
 
            if(err==QERR_SUCCESS) {
                Set(*tobj);
                if(tobj->IsValid()) fObject->Validate();
                else fObject->InValidate();
            } else {
                std::string str = "Error while reading object: \"";
                str += fLabel.GetStringLabel() + "\" ";
                str += "From file \"";
                str += fname;
                str += "\": ";
                str += err.GetDescription();
                err.SetDescription(str);
                return err;
            }
 
            return err;
        }
 
        virtual QError StoreOnFile(const std::string& fname) const
        {
            QError err = QERR_SUCCESS;
            if(!IsValid()) {
                err = QERR_GLOBAL_HANDLE;
                std::stringstream strstr;
 
                strstr<<"StoreOnFile(): global Object (Name: \""<<this->GetName()
                                        <<"\" , Owner: \""<<this->GetOwner()<<"\") is not valid, so it is not being written";
                err.SetDescription(strstr.str());
                return err;
            }
            QGlobalWriter* writer = QGlobalWriterDispatcher::GetInstance().GetWriter(fname,err);
            if(writer)  err = writer->Set(fLabel.GetStringLabel(), *fObject,fDescription);
            else {
                std::string str = "Error while opening file: \"";
                str += fname + "\": ";
                str += err.GetDescription();
                err.SetDescription(str);
                return err;
            }
            if( err != QERR_SUCCESS) {
                std::string str = "Error while writing object: \"";
                str += fLabel.GetStringLabel() + "\" ";
                str += "on file \"";
                str += fname;
                str += "\": ";
                str += err.GetDescription();
                err.SetDescription(str);
            }
            return err;
 
        }
 
        virtual QError FillFromDB() 
        { 
            QError err = QERR_NOT_IMPLEMENTED;
            std::stringstream strstr;
            strstr<<"FillFromDB() is not implemented for object of type: "
                <<Demangle(fObject)<<"(Name: \""<<this->GetName()
                <<"\" , Owner: \""<<this->GetOwner()<<"\")."
                <<" Write a specific GlobalHandle!";
            err.SetDescription(strstr.str());
            return err;
        }
 
        virtual QError StoreOnDB() const 
        { 
            QError err = QERR_NOT_IMPLEMENTED;
            std::stringstream strstr;
            strstr<<"StoreOnDB() is not implemented for object of type: "
                <<Demangle(fObject)<<"(Name: \""<<this->GetName()
                <<"\" , Owner: \""<<this->GetOwner()<<"\")."
                <<" Write a specific GlobalHandle!";
            err.SetDescription(strstr.str());
            return err;
        }
 
        virtual QError StoreOnDB() 
        { 
            return const_cast<const GlobalHandle<Q>* >(this)->StoreOnDB();
        }
 
        std::string GetVersion() const { return fVersion; }
 
 
 
    protected:
        Q** GetAddress() { return &fObject; }
 
        Q** const GetAddress() const { return &fObject; }
 
        void CreateObject()
        {
            if(fObject) {
                std::stringstream msg;
                msg<<"QGlobalHandle of type: "<<Demangle(fObject)
                    <<" already owns a QObject"
                    <<" ( Name: "<<GetName()
                    <<" Owned by: "<<GetOwner()
                    <<" )";
 
                DianaThrow( QError(QERR_GLOBAL_HANDLE,__FILE__,__LINE__,msg.str()) );
            }
 
            fMyObject = new Q;
            fObject = fMyObject;
        }
 
    private:
        void SetOwner(const std::string& owner) { fLabel.fOwner = owner; }
        GlobalHandle() {};
        const GlobalHandle<Q>& operator=(const GlobalHandle<Q>& other) { return *this; }
 
        void SetVersion(const std::string& tag) { fVersion = tag; }
        Q* fObject;
        Q* fMyObject;
 
 
        QGlobalLabel fLabel;
        std::string fVersion;
        std::string fDefaultOwner;
        QError fGlobalDataManagerError;
        std::string fDescription;
 
        friend class QGlobalDataManager;
};
 
Q_END_NAMESPACE
 
 
#endif