In This Package:

RootIOFileStateSvc.cc

Go to the documentation of this file.

#include "RootIOSvc/RootIOFileStateSvc.h"

#include "RootIOSvc/RootIOIncident.h"

#include "GaudiKernel/IIncidentSvc.h"

#include <algorithm>

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

RootIOFileStateSvc::~RootIOFileStateSvc()
{
}
    
StatusCode RootIOFileStateSvc::initialize()
{
    MsgStream log(msgSvc(), "RootIOFileStateSvc");

    StatusCode sc = this->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,"RootIOIncident");

    return sc;
}

StatusCode RootIOFileStateSvc::finalize()
{
    m_incsvc->removeListener(this,"RootIOIncident");
    m_incsvc->release();

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

StatusCode RootIOFileStateSvc::queryInterface(const InterfaceID& riid, void** ppint)
{
    if (IRootIOFileStateSvc::interfaceID().versionMatch(riid)) {
        *ppint = (IRootIOFileStateSvc*)this;
        this->addRef();
        return StatusCode::SUCCESS;
    }
    return this->Service::queryInterface(riid,ppint);
}

void RootIOFileStateSvc::handle(const Incident& incident)
{
    MsgStream log(msgSvc(), "RootIOFileStateSvc");

    // Handle the incident in a trivial manner

    const RootIOIncident* rioinc = dynamic_cast<const RootIOIncident*>(&incident);
    if (!rioinc) {
        log << MSG::WARNING
            << "Ignoring unexpected incident not of class RootIOIncident" 
            << endreq;
        return;
    }
    
    if (rioinc->state() == RootIOIncident::opened_output) {
        std::string fn = rioinc->filename();
        log << MSG::DEBUG
            << "Adding opened output \"" << fn
            << "\" to " << m_open.size() << " others"
            << endreq;
        m_open.push_back(fn);
        return;
    }

    if (rioinc->state() == RootIOIncident::closed_output) {
        std::string fn = rioinc->filename();
        log << MSG::DEBUG
            << "Adding closed output \"" << fn
            << "\" to " << m_closed.size() << " others"
            << endreq;
        m_closed.push_back(fn);


        std::list<std::string>::iterator it = std::find(m_open.begin(),m_open.end(),fn);
        if (it != m_open.end()) {
            m_open.erase(it);
            log << MSG::DEBUG
                << "Erased \"" << *it << "\" from open list, " << m_open.size() << " left" 
                << endreq;
        }
    }
}

IRootIOFileStateSvc::FileList_t RootIOFileStateSvc::closedOutput()
{
    return FileList_t(m_closed.begin(),m_closed.end());
}

IRootIOFileStateSvc::FileList_t RootIOFileStateSvc::openOutput()
{
    return FileList_t(m_open.begin(),m_open.end());
}

---