In This Package:

DybInputLoadTool.cc

Go to the documentation of this file.

#include "DybInputLoadTool.h"

#include "RootIOSvc/IRootIOSvc.h"
#include "RootIOSvc/RootIOAddress.h"
#include "RootIOSvc/RootIOBaseCnv.h"
#include "RootIOSvc/RootInputStream.h"
#include "PerBaseEvent/PerHeaderObject.h"
#include "PerBaseEvent/PerRegistrationSequence.h"

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/DataObject.h"

#include <vector>

using namespace DayaBay;

DybInputLoadTool::DybInputLoadTool(const std::string& type,
                                   const std::string& name,
                                   const IInterface* parent)
    : GaudiTool(type,name,parent)
    , m_rioSvc(0)
    , m_convSvc(0)
    , m_cache_hos(false)
{
    declareInterface<IDybInputLoadTool>(this);
    declareProperty("RootIOSvc",m_rioSvcName="RootIOCnvSvc",
                    "Name of the IRootIOSvc to use");
    declareProperty("ConversionSvc",m_convSvcName="RootIOCnvSvc",
                    "Name of the IConversionSvc to use");
}

DybInputLoadTool::~DybInputLoadTool()
{
}
    
StatusCode DybInputLoadTool::queryInterface( const InterfaceID& riid, void** ppvIf )
{
    if ( riid == IDybInputLoadTool::interfaceID() )  {
        *ppvIf = (IDybInputLoadTool*)this;
        addRef();
        return StatusCode::SUCCESS;
    }
    return AlgTool::queryInterface( riid, ppvIf );
}


StatusCode DybInputLoadTool::initialize()
{
    MsgStream log(msgSvc(), "DybInputLoadTool");
    { // IRootIOSvc
        IService* isvc = 0; 
        StatusCode sc = this->service(m_rioSvcName,isvc,true);
        if(sc.isFailure()){
            log << MSG::ERROR << "Failed to get "<<m_rioSvcName<<" RootIOCnvSvc" << endreq;
            return sc;
        }

        sc = isvc->queryInterface(IRootIOSvc::interfaceID(), (void**)&m_rioSvc);
        if (sc.isFailure()) {
            log << MSG::ERROR << "Service " << m_rioSvcName
                << " does not implement IRootIOSvc" << endreq;
            return sc;
        }
    }

    { // IConversionSvc
        IService* isvc = 0; 
        StatusCode sc = this->service(m_convSvcName,isvc,true);
        if(sc.isFailure()){
            log << MSG::ERROR << "Failed to get "<<m_convSvcName<<" ConversionSvc" << endreq;
            return sc;
        }

        sc = isvc->queryInterface(IConversionSvc::interfaceID(), (void**)&m_convSvc);
        if (sc.isFailure()) {
            log << MSG::ERROR << "Service " << m_convSvcName
                << " does not implement IConversionSvc" << endreq;
            return sc;
        }
    }
    return StatusCode::SUCCESS;
}

StatusCode DybInputLoadTool::finalize()
{
    return StatusCode::SUCCESS;
}

RootInputStream* DybInputLoadTool::get_stream(const std::string& path)
{
    IRootIOSvc::InputStreamMap& ism = m_rioSvc->inputStreams();
    IRootIOSvc::InputStreamMap::iterator it = ism.find(path);
    if (it != ism.end()) {
        return it->second;
    }
    it = ism.find("default");
    if (it != ism.end()) {
        return it->second;
    }
    return 0;
}

/*
 * Load persistent object at given entry and path, return it or zero.
 * If fileNumber is not -1 then interpret entry as a file entry into
 * the given file number.
 */
template<class PerType>
PerType* DybInputLoadTool::get_pobj(int entry, const std::string& path, int fileNumber)
{
    MsgStream log(msgSvc(), "DybInputLoadTool");

    RootInputStream* ris = this->get_stream(path);
    if (!ris) {
        log << MSG::ERROR << "Failed to get input stream for " << path << endreq;
        return 0;
    }

    if (fileNumber == -1) {
        bool ok = ris->setEntry(entry);
        if (!ok) {
            log << MSG::ERROR << "Failed to setEntry(" << entry
                << ") with stream \"" << path << "\"" << endreq;
            return 0;
        }
    }
    else {
        bool ok = ris->setFileEntry(fileNumber,entry);
        if (!ok) {
            log << MSG::ERROR << "Failed to setFileEntry(" << fileNumber << "," << entry
                << ") with stream \"" << path << "\"" << endreq;
            return 0;
        }
    }

    PerType* pto = dynamic_cast<PerType*>(ris->obj());
    if (!pto) {
        log << MSG::ERROR << "Cast failed for object at entry = " << entry
            << " in stream \"" << path << "\"" << endreq;
        return 0;
    }

    return pto;
}

/* 
 * Return the converted data object of the given cliID and path, or
 * zero.  The persistent object is assumed to already have been
 * loaded.  See get_pobj().  This calls the converter's createObj() in
 * a way that will not load the persistent object and also explicitly
 * will NOT call fillObjRefs().
 */

DataObject* DybInputLoadTool::get_dataobject(int clID, const std::string& path)
{
    MsgStream log(msgSvc(), "DybInputLoadTool");

    IConverter* converter = m_convSvc->converter(clID);
    if (!converter) {
        log << MSG::ERROR << "Failed to get converter for class ID = " << clID
            << " in stream \"" << path << "\"" << endreq;
        return 0;
    }

    RootIOBaseCnv* riocnv = dynamic_cast<RootIOBaseCnv*>(converter);
    if (!riocnv) {
        log << MSG::ERROR << "Converter not a RootIOBaseCnv for class ID = " << clID
            << " in stream \"" << path << "\"" << endreq;
        return 0;
    }

    RootInputStream* ris = this->get_stream(path);
    if (!ris) {
        log << MSG::ERROR << "Failed to get input stream for " << path << endreq;
        return 0;
    }

    RootInputAddress ria(clID,path);
    ria.setStream(ris);
    ria.readDone();             // It is assumed that the persistent
                                // object is already read into memory
                                // (in this case, it is done in
                                // get_pobj()) so we tell createObj()
                                // not to do it again.
    DataObject* dobj = 0;
    StatusCode sc = riocnv->createObj(&ria,dobj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to createObj for class ID = " << clID
            << " in stream \"" << path << "\"" << endreq;
        return 0;
    }
    return dobj;
}

HeaderObject* DybInputLoadTool::get_header(int entry, const std::string& path, 
                                           bool input_headers, int fileNumber)
{
    MsgStream log(msgSvc(), "DybInputLoadTool");

    // See if we are cacheing hos and if we have a ho we know.
    if (m_cache_hos) {
        HoID id(entry,path);
        HoCache::iterator it = m_hocache.find(id);
        if (it != m_hocache.end()) {
            return it->second;
        }
    }

    PerHeaderObject* pho = this->get_pobj<PerHeaderObject>(entry,path,fileNumber);
    if (!pho) return 0;

    log << MSG::DEBUG << "get_header("<<entry<<",\"" << path << "\"," 
        << " id=" << pho->clID 
        << " w/ "
        << pho->inputHeaders.size()
        << " inputHeaders, " << input_headers<<",f#"<<fileNumber
        <<") -> ho @ " << pho->context.GetTimeStamp()
        <<endreq;

    std::vector<PerRef> pinputHeaders = pho->inputHeaders;
    pho->inputHeaders.clear();

    std::vector<const IHeader*> tinputHeaders;
    if (input_headers) {
        
        if (fileNumber == -1) { // we MUST set a file number when
                                // resolving references
            RootInputStream* ris = this->get_stream(path);
            fileNumber = ris->fileNumber();
            log << MSG::DEBUG << "get_header: using file number " << fileNumber << endreq;
        }

        for (size_t ind=0; ind< pinputHeaders.size(); ++ind) {
            HeaderObject* ho = this->get_header(pinputHeaders[ind].entry(),
                                                pinputHeaders[ind].path(),
                                                input_headers, fileNumber);
            if (ho) tinputHeaders.push_back(ho);
        }
    }
    log << MSG::DEBUG << "get_header: restored " << tinputHeaders.size()
        << " inputHeaders out of a possible "
        << pinputHeaders.size() << endreq;

    DataObject* dobj = this->get_dataobject(pho->clID, path);
    if (!dobj) return 0;
    
    HeaderObject* ho = dynamic_cast<HeaderObject*>(dobj);
    if (input_headers) ho->setInputHeaders(tinputHeaders);

    log << MSG::DEBUG << "get_header: got HO: id#" << ho->clID()
        << " \"" << ho->defLoc() << "\" @ " << ho->context().AsString()
        << endreq;

    // If we are cacheing hos keep the ho we know.
    if (m_cache_hos) {
        m_hocache[HoID(entry,path)] = ho;
    }

    return ho;
}


IDybInputLoadTool::ExecutionFrame DybInputLoadTool::get_frame(int entry, const std::string& path,
                                                               bool input_headers)
{
    MsgStream log(msgSvc(), "DybInputLoadTool");

    IDybInputLoadTool::ExecutionFrame ef;

    PerRegistrationSequence* prs = this->get_pobj<PerRegistrationSequence>(entry,path);
    if (!prs) return ef;

    m_cache_hos = true;
    m_hocache.clear();
    for (size_t ind=0; ind < prs->reglist.size(); ++ind) {
        RootInputStream* ris = this->get_stream(path);
        int fileNumber = ris->fileNumber();

        HeaderObject* ho = this->get_header(prs->reglist[ind].entry,
                                            prs->reglist[ind].path,
                                            input_headers, fileNumber);
        if (!ho) {
            log << MSG::ERROR << "Failed to get Header object at entry " 
                << prs->reglist[ind].entry << " and path " << prs->reglist[ind].path << endreq;
            continue;
        }

        IDybInputLoadTool::ExecutionFrameEntry entry(prs->reglist[ind].path,ho);
        ef.push_back(entry);
    }
    m_cache_hos = false;
    m_hocache.clear();
    return ef;
}

int DybInputLoadTool::get_entries(const std::string& path)
{
    IRootIOSvc::InputStreamMap& ism = m_rioSvc->inputStreams();
    IRootIOSvc::InputStreamMap::iterator it = ism.find(path);
    if (it != ism.end()) {
        return it->second->entries();
    }
    return -1;
}

---