In This Package:

StageDataManager.cc

Go to the documentation of this file.

#include "StageDataManager.h"
#include "Stage/HeaderStageData.h"

#include "Event/HeaderObject.h"

#include "GaudiKernel/IDataProviderSvc.h"

#include <vector>

using namespace DayaBay;
using namespace std;

StageDataManager::StageDataManager(const std::string& name, ISvcLocator* svc)
    : Service(name,svc)
{
}

StageDataManager::~StageDataManager()
{
}
    
StatusCode StageDataManager::initialize()
{
    StatusCode sc = this->Service::initialize();
    if (sc.isFailure()) return sc;

    sc = this->service("EventDataSvc",m_evtsvc);
    if (sc.isFailure()) return sc;

    MsgStream log(msgSvc(), "StageDataManager");
    log << MSG::DEBUG << "Initialized" << endreq;

    return sc;
}

StatusCode StageDataManager::finalize()
{
    MsgStream log(msgSvc(), "StageDataManager");
    log << MSG::DEBUG << "Finalizing" << endreq;

    return this->Service::finalize();
}

StatusCode StageDataManager::queryInterface(const InterfaceID& riid, void** ppint)
{
    if (IID_IStageDataManager.versionMatch(riid)) {
        *ppint = (IStageDataManager*)this;
    }
    else {
        return this->Service::queryInterface(riid,ppint);
    }
    addRef();
    return StatusCode::SUCCESS;
}

StatusCode StageDataManager::registerData(const std::string& location, IStageData& sd)
{
    MsgStream log(msgSvc(), "StageDataManager");

    HeaderObject& ho = sd.header();

    log << MSG::DEBUG << "Registering data at " << location 
        << " id#" << ho.clID() << " @ " << ho.context().AsString()
        << endreq;

    HeaderStageData<HeaderObject>* hsd = new HeaderStageData<HeaderObject>(ho);
    ho.addRef();
    m_cache[location].insert(IStageDataListPair(hsd->time(),hsd));
    return StatusCode::SUCCESS;
}

// depth first collecting of HOs
static bool find_hos(const HeaderObject* ho, vector<const HeaderObject*> &hos)
{
    if (!ho) return false;

    const vector<const IHeader*>& inHOs = ho->inputHeaders();

    size_t nhos = inHOs.size();

    for (size_t ind=0; ind<nhos; ++ind) {
        const IHeader* iho = inHOs[ind];
        const HeaderObject* other_ho = dynamic_cast<const HeaderObject*>(iho);
        bool ok = find_hos(other_ho,hos);
        if (!ok) return false;
    }

    hos.push_back(ho);

    return true;
}

// Return the IStageData corresponding to the given HO, if it exists
// in the list.
static IStageDataList::iterator find_ho(IStageDataList& sdlist, const HeaderObject* ho)
{
    IStageDataList::iterator it, done = sdlist.end();
    for (it = sdlist.begin(); it != done; ++it) {
        const HeaderObject* other_ho = &(it->second->header());
        if (ho == other_ho) return it;
    }
    return done;
}

// Remove all items from the front of sdlist, up to but not including
// last.  Return a vector of all the HOs from the SDs removed.
static vector<const HeaderObject*> strip_sdlist(IStageDataList& sdlist, IStageDataList::iterator last)
{
    vector<const HeaderObject*> dead_hos;
    vector<IStageData*> dead_data;
    
    for (IStageDataList::iterator it = sdlist.begin(); it != last; ++it) {
        dead_data.push_back(it->second);
        dead_hos.push_back(&(it->second->header()));
    }
    sdlist.erase(sdlist.begin(), last);
    for (size_t ind=0; ind<dead_data.size(); ++ind) {
        delete dead_data[ind];
    }
    dead_data.clear();

    return dead_hos;
}

// Walk the cache.  If the HO is found, write it out and all others in
// the same location that are earlier
void StageDataManager::find_and_flush(const HeaderObject* ho)
{
    MsgStream log(msgSvc(), "StageDataManager");

    LocDataListMap::iterator it, done = m_cache.end();
    for (it = m_cache.begin(); it != done; ++it) {
        
        const string& loc = it->first;
        IStageDataList& sdlist = it->second;

        IStageDataList::iterator sdit = find_ho(sdlist,ho);
        if (sdit == sdlist.end()) continue;

        ++sdit;                 // always up-to-but-not-including
        size_t before = sdlist.size();
        vector<const HeaderObject*> dead_hos = strip_sdlist(sdlist, sdit);
        size_t after = sdlist.size();

        size_t siz = dead_hos.size();
        log << MSG::DEBUG << "Loading " << siz << " HeaderObjects into TES, stripped from "
            << before << " to " << after
            << endreq;

        for (size_t ind=0; ind<siz; ++ind) {
            // gotta break const'ness here because the TES must call
            // addRef/release.  This const-incorectness is ultimately
            // because HeaderObject::inputHeaders() forces constness
            // on us, even thought the original HO isn't const.  This
            // is probably a deficiency of HeaderObject.
            HeaderObject* malleable_ho = const_cast<HeaderObject*>(dead_hos[ind]);
            m_evtsvc->registerObject(loc,malleable_ho);

            log << MSG::DEBUG << "Releasing HeaderObject clID: " << malleable_ho->clID() << endreq;
            malleable_ho->release();
        }

        // in principle, we could bail from the function at this point
        // as no one would ever think to put a HO in more than one
        // spot.  But, lets be paranoid and keep checking.
    }
}

StatusCode StageDataManager::consumeData(IStageData& sd)
{
    MsgStream log(msgSvc(), "StageDataManager");
    log << MSG::DEBUG << "consumeData()" << endreq;

    // need to:
    // 
    // 3. add sd->header() to TES, if not yet already added
    // 
    // 2. add all input headers to TES, inyaa
    // 
    // 1. add all cached headers to TES, inyaa and if earlier than any
    // in the category above on a per-location basis

    const HeaderObject& ho = sd.header();

    if (1) {                    // some debugging
        log << MSG::DEBUG << "Consuming with " << m_cache.size() << " locations cached"
            << endreq;
        LocDataListMap::iterator it, done = m_cache.end();
        for (it = m_cache.begin(); it != done; ++it) {
            IStageDataList& sdlist = it->second;
            log << MSG::DEBUG << "\t" << it->first 
                << " with " << sdlist.size()
                << ":" << endreq;
            IStageDataList::iterator lit, ldone = sdlist.end();
            for (lit = sdlist.begin(); lit != ldone; ++lit) {
                HeaderObject& ho = lit->second->header();
                log << MSG::DEBUG << "\t\t id#"
                    << ho.clID() << " at \""
                    << ho.defLoc() << "\" @ " 
                    << ho.context().AsString()
                    << endreq;
            }
        }
    }
    vector<const HeaderObject*> hos;
    bool ok = find_hos(&ho,hos);
    if (!ok) {
        log << MSG::ERROR << "Got IHeader that isn't a HeaderObject! WTF?" << endreq;
        return StatusCode::FAILURE;        
    }

    size_t nhos = hos.size();

    log << MSG::DEBUG << "Consuming id#" << ho.clID() 
        << " \"" << ho.defLoc() << "\" @ " 
        << ho.context().AsString()
        << " along with " << nhos << " other HeaderObjects" << endreq;

    for (size_t ind=0; ind<nhos; ++ind) {
        log << MSG::DEBUG << "\t" << ind << ": id#" << hos[ind]->clID() 
            << " \"" << hos[ind]->defLoc() << "\" @ " 
            << hos[ind]->context().AsString() << endreq;
        this->find_and_flush(hos[ind]);
    }

    return StatusCode::SUCCESS;
}

    
    

---