In This Package:

RawDataConSvc.cc

Go to the documentation of this file.

#include <utility>
#include <iostream>
#include "GaudiKernel/SvcFactory.h"
//wm/#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/RegistryEntry.h"

#include "RawDataIO/RawReadoutHeaderCnv.h"
#include "RawDataIO/RawDataObjectCnv.h"
#include "RawDataAddress.h"

#include "RawEventHeaderCnv.h"
#include "RawDataConSvc.h"

using namespace std;

extern const long RAWDATA_StorageType;

RawDataConSvc::RawDataConSvc(const string& name, ISvcLocator* svc)
      : ConversionSvc(name, svc, RAWDATA_StorageType)
      , m_log(msgSvc(), name)
{
   m_log << MSG::DEBUG << "constructor" << endreq;
}

StatusCode RawDataConSvc::initialize()
{
   m_log << MSG::DEBUG << "initialize()" << endreq;
   StatusCode iret;
   StatusCode status = ConversionSvc::initialize();
   if (status.isSuccess()) {
      IDataProviderSvc *pIDP = 0;
      status = service("EventDataSvc", pIDP, true);
      if (status.isSuccess()) {
         status = setDataProvider(pIDP);
      } else return status;

      status = addConverters();
      if (!status.isSuccess()) {
         m_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 (map<string, Leaf*>::iterator k = m_leaves.begin(); k != m_leaves.end(); k++) {
         string path = (*k).first;
         m_log << MSG::DEBUG << path <<endreq;
         for (map<string, Leaf*>::iterator j = m_leaves.begin(); j != m_leaves.end(); j++) {
            string pp = (*j).first.substr(0, (*j).first.rfind("/"));
            m_log << MSG::DEBUG << pp <<endreq;
            if (path == pp && path != (*j).first)(*k).second->push_back((*j).second);       
         }
      }
   }
   return status;
}

StatusCode RawDataConSvc::finalize()
{
   m_log << MSG::DEBUG << "finalize()" << endreq;
   StatusCode status = ConversionSvc::finalize();
   for (map<string, Leaf*>::iterator k = m_leaves.begin(); k != m_leaves.end(); k++) {
      delete(*k).second;
   }
   m_leaves.erase(m_leaves.begin(), m_leaves.end());

   if (status.isFailure()) {
      m_log << MSG::ERROR << "Unable to finalize service " << endreq;
      return status;
   }
   return StatusCode::SUCCESS;
}


StatusCode RawDataConSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)
{
   m_log << MSG::DEBUG << "queryInterface()" << endreq;
   if (IID_IRawDataConSvc.versionMatch(riid)) {
      *ppvInterface = (IRawDataConSvc*)this;
   } else {
      // Interface is not directly availible: try out a base class
      return ConversionSvc::queryInterface(riid, ppvInterface);
   }
   addRef();
   return StatusCode::SUCCESS;
}

StatusCode RawDataConSvc::declareObject(const IRawDataConSvc::Leaf& leaf)
{
  m_log << MSG::DEBUG << "declareObject() " << leaf.path << endreq;
   // Purpose and Method:  Callback from each of the individual converters that allows
   // association of TDS path and converter.
   Leaf* ll = new Leaf(leaf);
   pair<map<string, Leaf*>::iterator, bool> p = m_leaves.insert(map<string, Leaf*>::value_type(leaf.path, ll));
   if (p.second) return StatusCode::SUCCESS;
   else return StatusCode::FAILURE;
   delete ll;
}

StatusCode RawDataConSvc::createAddress(long storageType,
      const CLID& clid,
      const string*,
      const unsigned long*,
      IOpaqueAddress*& refpAddr)
{
   m_log << MSG::DEBUG << "createAddress(storageType=" << storageType << ", CLID=" << clid << ", IOpaqueAddress*=" << refpAddr << ")" << endreq;
   if (storageType != repSvcType()) {
      m_log << MSG::ERROR << "bad storage type" << storageType << endreq;
      return StatusCode::FAILURE;
   }

   refpAddr = new RawDataAddress(clid, "", "");

   return StatusCode::SUCCESS;
}

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

StatusCode RawDataConSvc::addConverters()
{
   m_log << MSG::DEBUG << "addConverters(): RawReadoutHeaderCnv" << endreq;
   declareObject(IRawDataConSvc::Leaf("/Event", RawDataObjectCnv::classID()));
   declareObject(IRawDataConSvc::Leaf("/Event/Readout", RawDataObjectCnv::classID()));
   declareObject(IRawDataConSvc::Leaf("/Event/Readout/ReadoutHeader", RawReadoutHeaderCnv::classID()));
   declareObject(IRawDataConSvc::Leaf("/Event/Raw", RawDataObjectCnv::classID()));
   declareObject(IRawDataConSvc::Leaf("/Event/Raw/RawEventHeader", RawEventHeaderCnv::classID()));
   return StatusCode::SUCCESS;
}


StatusCode RawDataConSvc::updateServiceState(IOpaqueAddress* pAddress)
{

   m_log << MSG::DEBUG << "updateServiceState(" << pAddress << ")" << endreq;
   StatusCode status = INVALID_ADDRESS;
   IRegistry* ent = pAddress->registry();
   if (0 != ent)   {
      SmartIF<IDataManagerSvc> iaddrReg(IID_IDataManagerSvc, dataProvider());
      status = StatusCode::SUCCESS;
      std::string path = ent->identifier();
      m_log << MSG::DEBUG << "... for path: " << path << endreq;
      map<string, Leaf*>::iterator itm = m_leaves.find(path);
      if (itm != m_leaves.end()) {
         IRawDataConSvc::Leaf* leaf = (*itm).second;
         if (0 != leaf)    {
            for (Leaf::iterator il = leaf->begin(); il != leaf->end(); il++)   {
               IOpaqueAddress* newAddr = 0;
               unsigned long ipars[2] = {0, 0};
               const std::string spars[2] = {"", ""};
               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;
}

---