RootIOTypedCnv.h

Go to the documentation of this file.

#ifndef ROOTIOTYPEDCNV_H
#define ROOTIOTYPEDCNV_H

#include "RootIOSvc/RootIOBaseCnv.h"
#include "RootIOSvc/RootIOAddress.h"
#include "RootIOSvc/RootOutputStream.h"
#include "RootIOSvc/RootInputStream.h"

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

#include "TClass.h"             // debug

#include <string>

template<class PerType, class TranType>
class RootIOTypedCnv : public RootIOBaseCnv
{
protected:
    std::string m_perclassName;
    PerType *m_perInObj, *m_perOutObj;

public:
    RootIOTypedCnv(std::string class_name, const CLID& clid, ISvcLocator* svc) 
        : RootIOBaseCnv(clid,svc)
        , m_perclassName(class_name)
        , m_perInObj(new PerType)
        , m_perOutObj(new PerType)
    {
        m_perOutObj->clID = m_perInObj->clID = TranType::classID(); 
    }

    virtual ~RootIOTypedCnv() {
        MsgStream log(msgSvc(), m_perclassName + "Cnv");
        log << MSG::DEBUG << "converter for " 
            << m_perclassName << " destructing" << endreq;
    }
          
    PerType& getPerInputObject() { return *m_perInObj; }
    PerType& getPerOutputObject() { return *m_perOutObj; }
    
    const RootIOBaseObject* getBaseInputObject() { return m_perInObj; }
    const RootIOBaseObject* getBaseOutputObject() { return m_perOutObj; }

    virtual StatusCode PerToTran(const PerType& pobj, TranType& tobj) = 0;

    virtual StatusCode TranToPer(const TranType& tobj, PerType& pobj) = 0;



    virtual StatusCode TranObjectToPerObject(DataObject& dat, 
                                             const RootOutputAddress& /*roa*/) 
    {
        MsgStream log(msgSvc(), m_perclassName + "Cnv");
        TranType* tranobj = dynamic_cast<TranType*>(&dat);
        if (!tranobj) {
            log << MSG::ERROR
                << "Given a DataObject which does not corespond to "
                << m_perclassName << " at location "
                << dat.registry()->identifier()
                << endreq;
            return StatusCode::FAILURE;
        }
        
        // Delegate actual copying to subclass.
        return this->TranToPer(*tranobj,*m_perOutObj);
    }

    virtual StatusCode PerObjectToTranObject(DataObject*& dat) {
        MsgStream log(msgSvc(), m_perclassName + "Cnv");
        TranType* tranobj = new TranType;
        StatusCode sc = this->PerToTran(*m_perInObj,*tranobj);
        if (sc.isFailure()) {
            delete tranobj;
            dat = 0;
            return sc;
        }
        dat = tranobj;

        log << MSG::DEBUG << "Converted " << m_perclassName << endreq;

        return sc;
    }
    
    virtual RootInputStream* makeInputStream(const RootInputAddress& ria) {
        RootInputStream* ris = 
            new RootInputStream(&m_perInObj, ria.tespath(), ria.branchname());

        MsgStream log(msgSvc(), m_perclassName + "Cnv");
        log << MSG::DEBUG
            << "Made input stream for " << ria.tespath()
            << endreq;
        return ris;
    }

    virtual RootOutputStream* makeOutputStream(const RootOutputAddress& ria) {
        MsgStream log(msgSvc(), m_perclassName + "Cnv");
        log << MSG::DEBUG
            << "Making output stream with class " << m_perclassName 
            << " and tespath " << ria.tespath()
            << " and branchname " << ria.branchname()
            << endreq;

        return new RootOutputStream((void*)&m_perOutObj,m_perclassName.c_str(),
                                    ria.tespath(),ria.branchname());
    }
};

#endif  // ROOTIOTYPEDCNV_H