In This Package:

UserDataCnv.cc

Go to the documentation of this file.

#include "UserDataCnv.h"
#include "PerBaseEvent/HeaderObjectCnv.h"
#include "RootIOSvc/RootIOUserData.h"
#include "RootIOSvc/RootIOUserDataProxy.h"

using namespace DayaBay;
using namespace std;

UserDataCnv::UserDataCnv(ISvcLocator* svc)
    : RootIOTypedCnv<PerHeaderObject,UserDataHeader>("PerHeaderObject",
                                                     classID(),svc)
{
}

UserDataCnv::~UserDataCnv()
{
}


StatusCode UserDataCnv::PerToTran(const PerHeaderObject& perobj,
                                  DayaBay::UserDataHeader& tranobj)
{
    MsgStream log(msgSvc(), "UserDataCnv::PerToTran");
    StatusCode sc = HeaderObjectCnv::toTran(perobj,tranobj);
    if(sc.isFailure()) return sc;

    // Convert user-defined data
    tranobj.clearData();

    RootIOUserData ud;
    RootIOUserData::ProxyCollection& proxies = ud.input(m_ris->path());
    RootIOUserData::ProxyCollection::iterator pit, pdone = proxies.end();
    log << MSG::DEBUG 
        << "got " << proxies.size() << " proxies from "
        << m_ris->path() << " for input" << endreq;

    for (pit = proxies.begin(); pit != pdone; ++pit) {
        RootIOUserDataProxy* proxy = pit->second;

        const std::string& typeName = proxy->cppType(); 
        const std::string& varName = proxy->varName(); 

        // handle supported types
        UserData* userdata = 0;
        if (typeName == "int") {
            userdata = new UserInt(varName, proxy->value<int>());
        }
        else if (typeName == "float") {
            userdata = new UserFloat(varName, proxy->value<float>());
        }
        else if (typeName == "vector<int>") {
            userdata = new UserIntArray(varName, proxy->value< std::vector<int> >());
        }
        else if (typeName == "vector<float>") {
            userdata = new UserFloatArray(varName, proxy->value< std::vector<float> >());
        }
        else {
            log << MSG::ERROR
                << "got unknown POD type: \"" << typeName
                << "\" for user data \"" << varName
                << "\" skipping."
                << endreq;
            return StatusCode::FAILURE;
        }
        tranobj.data().push_back(userdata);
    }
    return StatusCode::SUCCESS;
}

StatusCode UserDataCnv::TranToPer(const DayaBay::UserDataHeader& udh,
                                  PerHeaderObject& perobj)
{
    MsgStream log(msgSvc(), "UserDataCnv::TranToPer");
    std::string tespath = udh.registry()->identifier();

    RootIOUserData ud;
    RootIOUserData::ProxyCollection& proxies = ud.output(tespath);

    log << MSG::DEBUG 
        << "got " << proxies.size() << " proxies from "
        << tespath << " for output" << endreq;

    StatusCode sc;

    if (!proxies.size()) {
        log << MSG::DEBUG << "No proxies for " 
            << tespath << " initializing" << endreq;
        sc = this->InitializeProxies(udh, proxies);
        if (sc.isFailure()) return sc;
    }

    sc = HeaderObjectCnv::toPer(udh,perobj);
    if (sc.isFailure()) return sc;

    const UserDataHeader::UserDataList& datalist = udh.data();

    for (size_t ind=0; ind < datalist.size(); ++ind) {
        const UserData* data = datalist[ind];

        const std::string& varName = data->name();

        RootIOUserDataProxy* proxy = proxies[varName];

        if (!proxy) {
            log << MSG::ERROR << "Failed to find proxy: " << varName
                << "    "
                << "Make sure you set all user data variables for every event!"
                << endreq;
            return StatusCode::FAILURE;
        }
      
        const std::string& cppType = proxy->cppType();

        log << MSG::DEBUG 
            << "Proxy: name:" << varName << " and type:" << cppType
            << endreq;

        switch (data->type()) {

        case UserData::Float:
            proxy->value<float>() = dynamic_cast<const UserFloat*>(data)->value();
            break;

        case UserData::Int:
            proxy->value<int>() = dynamic_cast<const UserInt*>(data)->value();
            break;


        case UserData::FloatArray:
            proxy->value< vector<float> >() = dynamic_cast<const UserFloatArray*>(data)->value();
            break;

        case UserData::IntArray:
            proxy->value< vector<int> >() = dynamic_cast<const UserIntArray*>(data)->value();
            break;

        default:
            log << MSG::ERROR
                << "unknown type: " << data->type() 
                << " for user data \"" << varName << "\""
                << endreq;
            return StatusCode::FAILURE;
            break;
        }
    }

    return StatusCode::SUCCESS;
}

StatusCode UserDataCnv::fillRepRefs(IOpaqueAddress*, DataObject* dobj) {
  
    MsgStream log(msgSvc(), "UserDataCnv::fillRepRefs");
    UserDataHeader* header = dynamic_cast<UserDataHeader*>(dobj);

    log << MSG::DEBUG
        << "Saving links to " << header->inputHeaders().size() 
        << " input headers" << endreq;
  
    StatusCode sc = HeaderObjectCnv::fillPer(m_rioSvc,*header,*m_perOutObj);

    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }
  
    return sc;
}

StatusCode UserDataCnv::fillObjRefs(IOpaqueAddress*, DataObject* dobj) {
    MsgStream log(msgSvc(), "UserDataCnv::fillObjRefs");
    HeaderObject* hobj = dynamic_cast<HeaderObject*>(dobj);

    StatusCode sc = HeaderObjectCnv::fillTran(m_rioSvc,*m_perInObj,*hobj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }
  
    log << MSG::DEBUG
        << "Restored links to " << hobj->inputHeaders().size() 
        << " input headers" << endreq;
  
    return sc;
}


StatusCode UserDataCnv::InitializeProxies(const DayaBay::UserDataHeader& udh,
                                          RootIOUserData::ProxyCollection& proxies)
{
    // Setup any required proxies for output
    MsgStream log(msgSvc(), "UserDataCnv::InitializeProxies");
    log << MSG::DEBUG << "Initializing dynamic branches" << endreq;

    const UserDataHeader::UserDataList& datalist = udh.data();

    for (size_t ind=0; ind < datalist.size(); ++ind) {
        const UserData* userdata = datalist[ind];

        const std::string& varName = userdata->name();

        log << MSG::DEBUG 
            << "\tprocessing user data: " << varName 
            << " type: " << userdata->type()
            << endreq;

        RootIOUserDataProxy* proxy = 0;
        switch (userdata->type()) {

        case UserData::Int:
            proxy = new RootIOUserDataProxy(varName,"int",
                                            (char*)new int);
            break;

        case UserData::Float:
            proxy = new RootIOUserDataProxy(varName,"float",
                                            (char*)new float);
            break;

        case UserData::IntArray:
            proxy = new RootIOUserDataProxy(varName,"vector<int>",
                                            (char*)new vector<int>);
            break;

        case UserData::FloatArray:
            proxy = new RootIOUserDataProxy(varName,"vector<float>",
                                            (char*)new vector<float>);
            break;

        default:
            log << MSG::ERROR << "         unknown type: " << userdata->type() << endreq;
            return StatusCode::FAILURE;
            break;
        }
        proxies[varName] = proxy;
    }
    return StatusCode::SUCCESS;
}

---