/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/RawDataCnvBase/RawDataCnvBase-01-00-03/src/RawDataCnvSvc.cxx

Go to the documentation of this file.

#include "GaudiKernel/SmartDataPtr.h" 
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/MsgStream.h"

#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/GenericAddress.h"

#include "RawDataCnvBase/RawDataBaseCnv.h"
#include "RawDataCnvBase/RawDataCnvSvc.h"
#include "EventModel/EventModel.h"
#include <iostream>

static const InterfaceID IID_IRawDataCnvSvc("IRawDataCnvSvc", 1 , 0); 

// RCS Id for identification of object version
// static const char* rcsid = "$Id: RawDataCnvSvc.cxx,v 1.12 2011/02/17 01:14:23 maqm Exp $";

RawDataCnvSvc::RawDataCnvSvc(const std::string& name, ISvcLocator* svc, long storageType)
: ConversionSvc(name, svc, storageType)              
{
}

StatusCode RawDataCnvSvc::initialize()     {
    // Purpose and Method:  Setup Converter Service.
    //   Associate RawDataCnvSvc with the EventDataSvc
    //   Associate the list of known converters with this RawDataCnvSvc.

    MsgStream log(messageService(), name());
 
    StatusCode iret;
    StatusCode status = ConversionSvc::initialize();
    if ( status.isSuccess() )   {

        IDataProviderSvc *pIDP = 0;
        // Set event data service
        status = service("EventDataSvc", pIDP, true);
        if ( status.isSuccess() )   {
            status = setDataProvider ( pIDP );
        }
        else    {
            return status;
        }

        // Add converters to the service 
        status = addConverters();
        if ( !status.isSuccess() )   {
          log << MSG::ERROR << "Unable to add converters to the service" << endreq;
          return status;
        }

        // Now we have to configure the map of leaves
        // Which should contain the association of converters with 
        // paths on the TDS
        for (LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )   {
            std::string path = (*k).first;
            for (LeafMap::iterator j = m_leaves.begin(); j != m_leaves.end(); j++ )   {
                std::string pp = (*j).first.substr(0, (*j).first.rfind("/"));
                if ( path == pp && path != (*j).first )   {
                    (*k).second->push_back((*j).second);
                }
            }
        }
        
    }

    return status;
}

StatusCode RawDataCnvSvc::finalize()     {
    StatusCode status = ConversionSvc::finalize();
    for (LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )   {
        delete (*k).second;
    }
    m_leaves.erase(m_leaves.begin(), m_leaves.end());
    return status;
}

StatusCode RawDataCnvSvc::declareObject(const IRawDataCnvSvc::Leaf& leaf)   {
    // Purpose and Method:  Callback from each of the individual converters that allows
    //  association of TDS path and converter.
    Leaf* ll = new Leaf(leaf);
    std::pair<LeafMap::iterator, bool> p = m_leaves.insert(LeafMap::value_type( leaf.path, ll) );
    if( p.second )    {
        return StatusCode::SUCCESS;
    }
    delete ll;
    return StatusCode::FAILURE;
}

StatusCode RawDataCnvSvc::updateServiceState(IOpaqueAddress* pAddress)    {
    
    // not sure about the use of recid or bank...
    MsgStream log(msgSvc(), name());
    
    StatusCode status = INVALID_ADDRESS;
    IRegistry* ent = pAddress->registry();

    if ( 0 != ent )   {
      SmartIF<IDataManagerSvc> iaddrReg( dataProvider());
 //       if ( 0 != iaddrReg )   {
      status = StatusCode::SUCCESS;
      std::string path = ent->identifier();

      LeafMap::iterator itm = m_leaves.find(path);
      if ( itm != m_leaves.end() ) {
        IRawDataCnvSvc::Leaf* leaf = (*itm).second;
        if ( 0 != leaf )    {
          //ipar[0] = leaf->userParameter;
          for ( Leaf::iterator il = leaf->begin(); il != leaf->end(); il++ )   {
            IOpaqueAddress* newAddr = 0;
            unsigned long ipars[2] = {0, 0}; //{(*il)->userParameter, new_rid};
            const std::string spars[2] = {"", ""}; //{par[0], (*il)->bank};
            /* fix for Gaidi V16r4  -- Weidong Li 2005.10.25 
            StatusCode ir =
              addressCreator()->createAddress(storageType, 
                                              (*il)->clid, 
                                              spars, 
                                              ipars,
                                              newAddr);
            */
            StatusCode ir = createAddress(repSvcType(), 
                                              (*il)->clid, 
                                              spars, 
                                              ipars,
                                              newAddr);
            if ( ir.isSuccess() )   {
              ir = iaddrReg->registerAddress((*il)->path, newAddr);            
              if ( !ir.isSuccess() )    {
                newAddr->release();
                status = ir;
              }
            }
          }
        }
      }
    }
    else  {
       status = NO_INTERFACE;
    }
    
    return status;
}

StatusCode RawDataCnvSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)  {
    if ( IID_IRawDataCnvSvc == riid )  {
        *ppvInterface = (IRawDataCnvSvc*)this;
    }
    else  {
        // Interface is not directly availible: try out a base class
        return ConversionSvc::queryInterface(riid, ppvInterface);
    }
    addRef();
    return StatusCode::SUCCESS;
}

StatusCode RawDataCnvSvc::createAddress(long storageType,
                                        const CLID& clid,
                                        const std::string*, 
                                        const unsigned long*,
                                        IOpaqueAddress*& refpAddress) 
{
    MsgStream log( msgSvc(), name() );
    
    if (storageType != repSvcType() ) {
        log << MSG::ERROR << "bad storage type" << storageType << endreq;
        return StatusCode::FAILURE;
    }

    refpAddress = new GenericAddress(storageType,
                                     clid,
                                     "",  
                                     "",
                                     0);

    return StatusCode::SUCCESS;
}

StatusCode RawDataCnvSvc::createAddress(long storageType,
                                        const CLID& clid,
                                        const std::string&,
                                        IOpaqueAddress*& refpAddress)
{
  return createAddress(storageType, clid, NULL, NULL, refpAddress);
}

---