QGlobalDataManager.hh

Go to the documentation of this file.

#ifndef _Q_GLOBALDATAMANAGER_HH_
#define _Q_GLOBALDATAMANAGER_HH_
 
#include "QDiana.hh"
#include "QError.hh"
#include "QObject.hh"
#include "QGlobalHandle.hh"
#include "QGlobalLabel.hh"
#include "QMessage.hh"
#include <string>
#include <sstream>
#include <vector>
#include <map>
 
Q_BEGIN_NAMESPACE
 
class QGlobalDataManager {
    public:
        static QGlobalDataManager& GetInstance(const std::string& owner="");
        QGlobalDataManager();
 
        ~QGlobalDataManager();
 
        void Clear();
        template<class Q> QError Get(const std::string& owner, GlobalHandle<Q> * gh, const std::string& inSource, bool printError=true) const;
        template<class Q> QError Get( GlobalHandle<Q>* gh, const std::string& inSource, bool printError = true) const;
 
        template<class Q> const Q& Get(const std::string& owner, const std::string& name, const std::string& inSource) const
        {
            GlobalHandle<Q> gd(name);
            Get(owner, &gd, inSource);
            return gd.Get();
        }
        template<class Q> const Q& Get(const std::string& name, const std::string& inSource) const
        {
            GlobalHandle<Q> gd(name);
            Get(&gd,inSource);
            return gd.Get();
        }
        template<class Q> QError Set( GlobalHandle<Q>* gh, const std::string& outSource, bool printError = true) const;
        template<class Q> QError Set(const std::string& name, const Q& obj, const std::string& outSource) const
        {
            GlobalHandle<Q> gd(name.c_str());
            gd.Set(obj);
            return Set(&gd,outSource);
        }
 
        std::vector<QGlobalLabel> GetWriteLabels() const;
 
        const QObject* GetByLabel(const QGlobalLabel&) const;
 
        void SetOwner(const std::string& owner) { fOwner =  owner; }
 
        void SetInputVersion(std::string versionTag) { fInputVersion = versionTag; }
        
        void EnableCache(const bool enable) { fCacheEnabled = enable; }
 
        void Dump(std::ostream& o) const;
   
        bool GetCacheEnable() const
        { return fCacheEnabled;}
 
private:
        struct CachedObject {
            std::string source;
            std::string version;
            QObject* object;
        };
        std::string fOwner;
       
       
        mutable std::map<QGlobalLabel, CachedObject> fDataMap;
 
        mutable std::map<QGlobalLabel, std::string> fDefaultMap;
 
        bool fCacheEnabled;
        
        static int fInstances;
 
        std::string fOutputVersion; 
 
        std::string fInputVersion; 
 
        static QGlobalDataManager* fUniqueInstance;
        friend class QBaseModule;
 
 
};
 
template<class Q> QError QGlobalDataManager::Get( GlobalHandle<Q>* bgh, const std::string& inSource, bool printError) const
{
    if(!fOwner.empty()) bgh->SetOwner(fOwner);
    return Get(bgh->GetOwner(),bgh,inSource, printError);
}
 
template<class Q> QError QGlobalDataManager::Get(const std::string& owner, GlobalHandle<Q>* bgh, const std::string& inSource, bool printError) const
{
    bgh->SetOwner(owner);
    if(owner == "") {
        // look for default owner
        const QGlobalLabel& label = bgh->GetLabel(); 
        std::map<QGlobalLabel,std::string>::const_iterator idef = fDefaultMap.find(label);
        if(idef != fDefaultMap.end())
            bgh->SetOwner(idef->second);
        else 
            bgh->SetOwner(bgh->GetDefaultOwner());
    }
 
    bgh->SetVersion(fInputVersion);
 
    const QGlobalLabel& label = bgh->GetLabel();
    Q** addr = bgh->GetAddress();
    // if in cache return;
    std::map<QGlobalLabel, CachedObject>::const_iterator iter = fDataMap.find(label);
 
    QError err = QERR_SUCCESS;
 
    if(iter != fDataMap.end()) {
        bool cacheError = true;
        cacheError = cacheError && inSource != "" && inSource != iter->second.source && iter->second.object;
        cacheError = cacheError && bgh->GetVersion() != iter->second.version;
        if(cacheError) {
            std::stringstream msg;
            msg<<"Cannot get object "<<std::string(label)<<" from \""<<inSource
                <<"\"(Version=\""<<bgh->GetVersion()
                <<"\") since it is in cache with another source: \""<<iter->second.source
                <<"\"(Version=\""<<iter->second.version
                <<"\"). If outside diana, you may consider to disable the cache [see QGlobalDataManager::EnableCache()]";
            if(printError) QMessageHandler::Error("QGlobalDataManager::Get()", msg.str());
            err = QERR_GLOBAL_GENERIC;
            err.SetDescription(msg.str());
            bgh->fGlobalDataManagerError = err;
        }
        *addr = dynamic_cast<Q*>(iter->second.object);
        return err;
    }
 
    err = QERR_GLOBAL_GENERIC;
    err.SetDescription("Object not found");
 
    if(inSource == "DB") {
        err = bgh->FillFromDB();
    } else if(!inSource.empty()) {
        err = bgh->FillFromFile(inSource);
    } 
    if(err != QERR_SUCCESS) {
        if(*addr) (*addr)->InValidate();
        bgh->fGlobalDataManagerError = err;
        // if looking for cache, do not cache non existing objects
        if(fCacheEnabled && inSource != "") {
            fDataMap[label].object = 0;
            fDataMap[label].source = inSource;
            fDataMap[label].version = bgh->GetVersion();
        }
        return err;
    }
    // cache object
    if(fCacheEnabled) {
        fDataMap[label].source = inSource;
        fDataMap[label].version = bgh->GetVersion();
        fDataMap[label].object = (*addr)->Duplicate();
        (*addr)->FullyFill(fDataMap[label].object);
        (*addr) = (Q*)fDataMap[label].object;
    }
 
    // fill defaults:
    QGlobalLabel defLab = bgh->GetLabel();
    defLab.fOwner = "";
    if(fDefaultMap.find(defLab) == fDefaultMap.end()) {
        fDefaultMap[defLab] = bgh->GetOwner();
        std::stringstream msg;
        msg<<"Setting default owner \""<<bgh->GetOwner()<<"\" ";
        msg<<"for object \""<<defLab.GetStringLabel()<<"\"";
        QMessageHandler::Debug("QGlobalDataManager::Get()", msg.str());
    }
 
    return err;
}
 
template<class Q> QError QGlobalDataManager::Set(GlobalHandle<Q> * bgh, const std::string& outSource, bool printError) const
{
    // here we print error messages on screen since we are not sure that
    // the caller will check it.
    QError err = QERR_SUCCESS;
    if(bgh->GetOwner() == "") {
        if(!fOwner.empty()) bgh->SetOwner(fOwner);
        else {
            err = QERR_GLOBAL_GENERIC;
            err.SetDescription("QGlobalDataManager::Set(): Unable to Set object, since no owner has been specified (if you are using this class outside diana, set the object owner with QGlobalDataManager::SetOwner())");
            if(printError) QMessageHandler::Error("QGlobalDataManager::Set()",err.GetDescription());
            return err;
        }
    }
 
    if(bgh->GetVersion() == "") {
        bgh->SetVersion(fOutputVersion);
    }
    if(fCacheEnabled) {
        // cache object
        const QGlobalLabel& label = bgh->GetLabel();
        std::map<QGlobalLabel, CachedObject>::const_iterator iter = fDataMap.find(label);
        if(iter == fDataMap.end()) {
            fDataMap[label].object = 0;
            fDataMap[label].source = outSource;
            fDataMap[label].version = bgh->GetVersion();
        }
        std::map<QGlobalLabel, CachedObject>::iterator iter2 = fDataMap.find(label);
        if(bgh->IsValid()) {
            Q** addr = bgh->GetAddress();
            if(!iter2->second.object) iter2->second.object = (*addr)->Duplicate();
            if((*addr) != (iter2->second.object)) 
                (*addr)->FullyFill(iter2->second.object);
        } else {
            if(iter2->second.object) iter2->second.object->Reset();
        }
    }
 
    // save object
    if(outSource == "DB") {
        err = bgh->StoreOnDB();
    } else if(!outSource.empty()){
        err = bgh->StoreOnFile(outSource);
    }
    if(err != QERR_SUCCESS)
        if(printError) QMessageHandler::Error("QGlobalDataManager::Set()",err.GetDescription());
 
 
    // fill defaults:
    QGlobalLabel defLab = bgh->GetLabel();
    defLab.fOwner = "";
    if(fDefaultMap.find(defLab) == fDefaultMap.end()) {
        fDefaultMap[defLab] = bgh->GetOwner();
        std::stringstream msg;
        msg<<"Setting default owner \""<<bgh->GetOwner()<<"\" ";
        msg<<"for object \""<<defLab.GetStringLabel()<<"\"";
        QMessageHandler::Debug("QGlobalDataManager::Set()", msg.str());
    }
 
    return err;
 
}
 
Q_END_NAMESPACE
 
#endif