DybOutputHeaderSvc.cpp

Go to the documentation of this file.

#include "DybOutputHeaderSvc.h"
#include "Event/IHeader.h"
#include "Event/HeaderObject.h"

#include "DybKernel/EventStoreIncident.h"

#include "GaudiKernel/IRegistry.h"

using namespace DayaBay;

DybOutputHeaderSvc::DybOutputHeaderSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
    , m_incsvc(0)
{
}

DybOutputHeaderSvc::~DybOutputHeaderSvc()
{
    this->clear();
}

StatusCode DybOutputHeaderSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)   
{
    if ( riid == IID_IOutputHeaderSvc )  {
        *ppvInterface = (IOutputHeaderSvc*)this;
    }
    else  {
        return Service::queryInterface(riid, ppvInterface);
    }
    addRef();
    return StatusCode::SUCCESS;
}
 
StatusCode DybOutputHeaderSvc::initialize()
{
    MsgStream log(msgSvc(), name());

    StatusCode sc = Service::initialize();
    if (sc.isFailure()) return sc;

    sc = this->service("IncidentSvc",m_incsvc,true);
    if (sc.isFailure()) {
        log << MSG::ERROR
            << "Failed to get IncidentSvc" << endreq;
        return sc;
    }
    m_incsvc->addListener(this,"EventStoreIncident");

    return sc;
}

StatusCode DybOutputHeaderSvc::finalize()
{
    m_incsvc->removeListener(this,"EventStoreIncident");
    m_incsvc->release();
    m_incsvc = 0;

    return Service::finalize();
}

// StatusCode DybOutputHeaderSvc::reinitialize()
// {
// }

 
std::string DybOutputHeaderSvc::hostr(const HeaderObject& ho)
{
    std::stringstream ss;
    ss << "HeaderObject: @" << (void*)&ho 
       << " name=\"" << ho.name() << "\""
       << " path=\"" << path(ho) << "\""
       << " execNum=" << ho.execNumber()
       << " refCount=" << ho.refCount() 
       << " #inputHeaders=" << ho.inputHeaders().size()
       << " context=\"" << ho.context().AsString() << "\"";
    return ss.str();
}

void DybOutputHeaderSvc::handle(const Incident& incident)
{
    // Through this incident handler the service is notified of
    // new header objects to add and obsolete ones to remove.

    MsgStream log(msgSvc(), name());

    if (incident.type() != "EventStoreIncident") { 
        log << MSG::DEBUG 
            << "Got unknown incident: \"" << incident.type() << "\""
            << endreq;
        return; 
    }

    const EventStoreIncident* esi = dynamic_cast<const EventStoreIncident*>(&incident);
    if (!esi) { 
        log << MSG::DEBUG 
            << "Got right incident (" << incident.type() << ") but does not dynamic cast"
            << endreq;
        return; 
    }
    log << MSG::DEBUG
        << "Handling incident of type " << incident.type()
        << " stored=" << esi->stored()
        << endreq;


    const DataObject* dobj = esi->object();
    if (!dobj) { 
        log << MSG::DEBUG << incident.type() << ": object is null" << endreq;
        return; 
    }

    const HeaderObject* ho = dynamic_cast<const HeaderObject*>(dobj);
    if (!ho) { 
        log << MSG::DEBUG 
            << incident.type() << ": object is not HeaderObject" << endreq;
        return; 
    }

    if (esi->stored()) {
        log << MSG::DEBUG 
            << incident.type() << ": adding: " << hostr(*ho) << endreq;
        size_t siz = ho->inputHeaders().size();
        for (size_t ind = 0; ind < siz; ++ind) {
            const HeaderObject* other_ho = dynamic_cast<const HeaderObject*>(ho->inputHeaders()[ind]);
            log << MSG::DEBUG << "\t" << hostr(*other_ho) << endreq;
        }
        this->add(*ho);
    }
    else {
        log << MSG::DEBUG 
            << incident.type() << ": erasing: " << hostr(*ho) << endreq;
        this->erase(*ho);
    }
}

 
IOutputHeaderSvc::OutputHeaders DybOutputHeaderSvc::get(const IHeader& header) 
{
    MsgStream log(msgSvc(), name());

    OutputHeaderMap::iterator it = find(header);
    return it->second;          // find can not fail
}

DybOutputHeaderSvc::OutputHeaderMap::iterator DybOutputHeaderSvc::find(const IHeader& header)
{
    OutputHeaderMap::iterator it = m_ohmap.find(&header);
    if (it != m_ohmap.end()) {
        return it;
    }

    m_ohmap[&header] = IOutputHeaderSvc::OutputHeaders();
    return m_ohmap.find(&header); // what we just added
}

bool DybOutputHeaderSvc::in(OutputHeaders& oh, const DayaBay::IHeader& header)
{
    size_t size = oh.size();
    for (size_t ind=0; ind<size; ++ind) {
        if (oh[ind] == &header) return true;
    }
    return false;
}

void DybOutputHeaderSvc::removeHeaderName(const HeaderObject& ho)
{
    OutputHeaderNameMap::iterator nit = m_names.find(&ho);
    if (nit != m_names.end()) {
        m_names.erase(nit);
    }
}

void DybOutputHeaderSvc::addHeaderName(const HeaderObject& ho)
{
    IRegistry* registry = ho.registry();
    if (!registry) {
        return;
    }
    std::string hname = registry->identifier();
    m_names[&ho] = hname;
}

void DybOutputHeaderSvc::add(const IHeader& header)
{
    MsgStream log(msgSvc(), name());
    HeaderObject* ho = dynamic_cast<HeaderObject*>(const_cast<IHeader*>(&header));

    if (!ho) {
        log << MSG::ERROR
            << "Failed to cast IHeader @ " << (void*)&header << endreq;
        return;
    }

    addHeaderName(*ho);

    const std::vector<const IHeader*>& inputHeaders = header.inputHeaders();
    if (!inputHeaders.size()) {
        log << MSG::DEBUG << "No input headers: " << hostr(*ho) << endreq;
        return;                 // origin header
    }

    // if (m_ohmap.find(&header) != m_ohmap.end()) {
    //     return;                 // already mapped
    // }

    
    for (size_t ind=0; ind<inputHeaders.size(); ++ind) {
        const IHeader* inhead = inputHeaders[ind];
        OutputHeaderMap::iterator it = find(*inhead);

        if (!in(it->second,header)) {
            it->second.push_back(&header);

            HeaderObject* other_ho = 
                dynamic_cast<HeaderObject*>(const_cast<IHeader*>(it->first));
            addHeaderName(*other_ho);

            log << MSG::DEBUG << "Setting as OutputHeader for: " << hostr(*other_ho) << endreq;
            ho->addRef();
        }
        add(*inhead);           // recurse
    }
}

std::string DybOutputHeaderSvc::path(const DayaBay::IHeader& header)
{
    OutputHeaderNameMap::iterator it = m_names.find(&header);
    if (it == m_names.end()) {
        return "UnknownHeader";
    }
    return it->second;
}

void DybOutputHeaderSvc::erase(const IHeader& header)
{
    MsgStream log(msgSvc(), name());
    HeaderObject* ho = dynamic_cast<HeaderObject*>(const_cast<IHeader*>(&header));

    OutputHeaderMap::iterator it = m_ohmap.find(&header), done = m_ohmap.end();
    if (it == done) {
        log << MSG::DEBUG
            << "Given an IHeader to erase which is not in my map: " << hostr(*ho)
            << endreq;
        return;
    }

    log << MSG::DEBUG
        << "Erasing from output headers map:  " << hostr(*ho) 
        << " " << path(header)
        << endreq;
    m_ohmap.erase(it);

    done = m_ohmap.end();
    for (it = m_ohmap.begin(); it != done; ++it) {
        IOutputHeaderSvc::OutputHeaders newone, &ohs = it->second;
        size_t nohs = ohs.size();
        for (size_t ind = 0; ind < nohs; ++ind) {
            const IHeader* thisone = ohs[ind];
            if (thisone == &header) {
                log << MSG::DEBUG
                    << "Found as output header: " << hostr(*ho)
                    << endreq;
                continue;
            }
            newone.push_back(thisone);
        }
        if (newone.size() < nohs) {
            it->second = newone;
        }
    }


    log << MSG::DEBUG << "Releasing: " << hostr(*ho) << endreq;
    ho->release();
    removeHeaderName(*ho);
}

void DybOutputHeaderSvc::clear()
{
    MsgStream log(msgSvc(), name());
    m_ohmap.clear();
}