LRootGlobalWriter.cc

Go to the documentation of this file.

#include "LRootGlobalWriter.hh"
#include "QDianaR.hh"
#include "TFile.h"
#include "QObject.hh"
#include "QString.hh"
#include "TROOT.h"
#include <sstream>
#include "QTFilePointer.hh"
 
REGISTER_GLOBAL_WRITER(LRootGlobalWriter, ".root")
 
using namespace Diana;
using std::stringstream;
 
 
LRootGlobalWriter::LRootGlobalWriter() : QGlobalWriter("RootGlobalWriter")
{
   fFile = NULL;
   fIsMRootFileWriter = false;
}
 
LRootGlobalWriter::~LRootGlobalWriter()
{
    Close();
    std::map<std::string, QObject*>::iterator iter = fObjectCache.begin();
    while(iter != fObjectCache.end()) {
        if(iter->second) delete iter->second;
        iter++;
    }
 
}
 
QError LRootGlobalWriter::FlushCache(TFile* oFile)
{
    QError err = QERR_SUCCESS;
    if(fObjectCache.empty()) return err;
 
 
    if(!oFile || oFile->IsZombie()) {
        err = QERR_CANNOT_OPEN_FILE;
        err.SetDescription(__FILE__,__LINE__,std::string("Cannot open file CurrentWriter"));
        return err;
    }
    
    if(fFile != oFile || fFileName != oFile->GetName()) {
        fFile = oFile;
        fFileName = fFile->GetName();
        TDirectory* rootGlobalDir = fFile->GetDirectory(ROOT_GLOBAL_DIR);
        if(rootGlobalDir == 0) rootGlobalDir = fFile->mkdir(ROOT_GLOBAL_DIR,"Diana global objects");
        if(rootGlobalDir) { 
            rootGlobalDir->cd();
        } else {
            err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,std::string("Cannot create directory \"") + std::string(ROOT_GLOBAL_DIR) + std::string("\" in file: ") + "CurrentWriter");
            return err;
        }
    }
 
    fFile->cd(ROOT_GLOBAL_DIR); 
    std::map<std::string, QObject*>::iterator iter = fObjectCache.begin();
    while(iter != fObjectCache.end()) {
        if(iter->second) {
            if(iter->second->Write(iter->first.c_str()) == 0) {
                stringstream msg;
                err = QERR_CANNOT_OPEN_FILE;
                msg<<"Error while writing object \""<< iter->first;;
                err.SetDescription(__FILE__,__LINE__,msg.str());
            }
        }
        if(iter->second) delete iter->second;
        iter++;
    }
 
    fObjectCache.clear();
    return err;
}
 
 
 
QError LRootGlobalWriter::SetQObject(const std::string&name, const std::string& className, const QObject* obj, const std::string& descr)
{
    QError err = QERR_SUCCESS;
    if(obj==NULL) {
        err = QERR_UNKNOWN_ERR;
        stringstream msg;
        msg<<"Error while writing object \""<< name <<"\": "<<" null pointer";
        err.SetDescription(__FILE__,__LINE__,msg.str());
        return err;
    }
 
 
    if(fIsMRootFileWriter) 
    {
        if(name == "RootFileWriter@FlushCache") {
            const QTFilePointer* fp = dynamic_cast<const QTFilePointer*>(obj);
            if(fp && fp->fP) {
                return FlushCache(fp->fP);
            } else {
                stringstream msg;
                msg<<"Cannot execute command RootFileWriter@FlushCache because the QTFilePointer is not valid";
                err.SetDescription(__FILE__,__LINE__,msg.str());
                return err;
            }
        }
        // Fill cache
        std::map<std::string, QObject*>::iterator iter = fObjectCache.find(name);
        if(iter != fObjectCache.end() && iter->second) delete iter->second;
        fObjectCache[name] = obj->Duplicate();
        obj->FullyFill(fObjectCache[name]);
        return err;
    } else if(fFile)  {
        const TObject* wobj = 0;
        if(name.find_first_of('@') == std::string::npos) {
            // Old object
            wobj = 0;
            if(wobj == 0) {
                err = QERR_UNKNOWN_ERR;
                stringstream msg;
                msg<<"Error while writing object in Old format \""<< name <<"\": "<<" conversion failed (try to look at QObjectR::Get)";
                err.SetDescription(__FILE__,__LINE__,msg.str());
                return err;
            }
 
        } else {
            wobj = obj;
        }
        fFile->cd(ROOT_GLOBAL_DIR); 
        if(wobj->Write(name.c_str()) == 0) {
            stringstream msg;
            err = QERR_CANNOT_OPEN_FILE;
            msg<<"Error while writing object \""<< name;;
            err.SetDescription(__FILE__,__LINE__,msg.str());
        }
    }
    return err;
}
 
 
 
QError LRootGlobalWriter::Open(const std::string& filename,const std::string& opt)
{
    QError err = QERR_SUCCESS;
    fIsMRootFileWriter = false;
    if(opt == "CURRENT_WRITER")  {
        fIsMRootFileWriter = true;
        return err;
    } else if(!fFile) { 
        fFile = new TFile(filename.c_str(), "RECREATE");
    }
    if(!fFile || fFile->IsZombie()) {
        err = QERR_CANNOT_OPEN_FILE;
        err.SetDescription(__FILE__,__LINE__,std::string("Cannot open file ") + filename);
        delete fFile;
        fFile = NULL;
    } else {
        TDirectory* rootGlobalDir = fFile->GetDirectory(ROOT_GLOBAL_DIR);
        if(rootGlobalDir == 0) rootGlobalDir = fFile->mkdir(ROOT_GLOBAL_DIR,"Diana global objects");
        if(rootGlobalDir) { 
            rootGlobalDir->cd();
        } else {
            err = QERR_UNKNOWN_ERR;
            err.SetDescription(__FILE__,__LINE__,std::string("Cannot create directory \"") + std::string(ROOT_GLOBAL_DIR) + std::string("\" in file: ") + filename);
        }
    }
    fFileName = filename;
    return err;
}
 
QError LRootGlobalWriter::Close()
{
    QError err = QERR_SUCCESS;
    if(fFile && !fIsMRootFileWriter){
        // MV FIXME this check if for cint. When we do ".q" TFiles are automatically deleted
        // by root so that this delete results in a double free.
        if(gROOT->GetListOfFiles()->GetSize() > 0) delete fFile;
    }
    fFile = NULL;
    return err;
}