---

ConversionSvc.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/GaudiKernel/ConversionSvc.h,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
#ifndef GAUDIKERNEL_CONVERSIONSVC_H
#define GAUDIKERNEL_CONVERSIONSVC_H 1

// Include files
#include <vector>
#include <algorithm>
#include <functional>
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IAddressCreator.h"

// forward declarations
class ICnvManager;
class IAddrFactory;
template <class TYPE,class ARG> class SvcFactory2;

class ConversionSvc  : public Service, 
                       virtual public IConversionSvc,
                       virtual public IAddressCreator
{
  friend class SvcFactory2<ConversionSvc,unsigned char>;
protected:
  class ContextEntry {
    IConverter*     m_converter;
    IOpaqueAddress* m_address;
    DataObject*     m_object;
  public:
    ContextEntry(IConverter* cnv, IOpaqueAddress* addr, DataObject* obj)  {
      m_converter  = cnv;
      m_address    = addr;
      m_object     = obj;
    }
    ContextEntry(const ContextEntry& copy)  {
      m_converter  = copy.m_converter;
      m_address    = copy.m_address;
      m_object     = copy.m_object;
    }  
    virtual ~ContextEntry()  {
    }
    IConverter*      converter()  {
      return m_converter;
    }
    IOpaqueAddress*& address()  {
      return m_address;
    }
    DataObject*&     object()   {
      return m_object;
    }
  };
  typedef std::vector<ContextEntry> Context;
public:
  class WorkerEntry {
  private:
    CLID        m_class;
    IConverter* m_converter;
  public:
    WorkerEntry(const CLID& cl, IConverter* cnv) 
      : m_class(cl), m_converter(cnv)       {
    }
    WorkerEntry(const WorkerEntry& copy)
      : m_class(copy.m_class), m_converter(copy.m_converter)    {
    }
    WorkerEntry& operator = (const WorkerEntry& copy)   {
      m_class     = copy.m_class;
      m_converter = copy.m_converter;
      return *this;
    }
    virtual ~WorkerEntry()  {
    }
    IConverter*     converter()  {
      return m_converter;
    }
    const CLID&     clID()  const {
      return m_class;
    }
  };
  typedef std::vector<WorkerEntry> Workers;

  class CnvTest : public std::unary_function<WorkerEntry, bool>   {
  protected:
    const CLID m_test;
  public:
    CnvTest(const CLID& test) : m_test(test)    {
    }
    virtual ~CnvTest()    {
    }
    bool operator()( const WorkerEntry& testee )  {
        return (m_test == testee.clID()) ? true : false;
    }
  };

public:

  virtual StatusCode initialize();

  virtual StatusCode finalize();

  virtual unsigned char repSvcType() const;

  virtual StatusCode updateServiceState(IOpaqueAddress* pAddress);

  virtual StatusCode createObj(IOpaqueAddress* pAddress, DataObject*& refpObject);

  virtual StatusCode updateObj(IOpaqueAddress* pAddress, DataObject* pObject);

  virtual StatusCode updateReps(IDataSelector* pSelector);

  virtual StatusCode createReps(IDataSelector* pSelector);

  virtual StatusCode setStore(IDataProviderSvc* pStore);

  virtual StatusCode addConverter(IConverter* pConverter);

  virtual StatusCode addConverter(const ICnvFactory& refFactory);

  virtual StatusCode removeConverter(const CLID& clid);

  virtual StatusCode connectOutput(const std::string& outputFile);

  virtual StatusCode createAddress(const GenericLinkBase & link, 
                                   const std::string& dbName, 
                                   const std::string& contName, 
                                   const std::string& objName, 
                                   IOpaqueAddress*& refpAddress);
  virtual StatusCode createAddress(unsigned char type, 
                                   const CLID& classId,
                                   const std::string& dbName, 
                                   const std::string& contName, 
                                   int seqId,
                                   IOpaqueAddress*& refpAddress);
  virtual StatusCode setAddressCreator(IAddressCreator* creator);

  ConversionSvc(const std::string& name, ISvcLocator* svc, unsigned char type);

  virtual StatusCode queryInterface(const IID& riid, void** ppvInterface);

protected:
  virtual ~ConversionSvc();

  virtual IConverter* converter(const CLID& wanted_class);

  virtual const ICnvFactory* findCnvFactory(const CLID& wanted);

  virtual StatusCode initializeConverter(IConverter* cnv);

  virtual IConverter* createConverter(const ICnvFactory& fac);

  virtual IAddressCreator* addressCreator()   {
    return m_addressCreator;
  }

  virtual void setAddressFactory(const IAddrFactory* pAddrFactory)    {
    m_addressFactory = pAddrFactory;
  }
  ICnvManager* cnvManager()    {
    return m_cnvManager;
  }

protected:
  IDataProviderSvc*   m_dataSvc;
  ICnvManager*        m_cnvManager;
  IAddressCreator*    m_addressCreator;
  unsigned char       m_type;
  const IAddrFactory* m_addressFactory;
  Workers*            m_workers;
};
#endif // GAUDIKERNEL_CONVERSIONSVC_H

---