PoolDbCnvFactory.h

Go to the documentation of this file.

// $Id: PoolDbCnvFactory.h,v 1.3 2006/11/22 18:10:43 hmd Exp $
//====================================================================
//      IPoolDbCnvFactory and PoolDbCnvFactory definition
//--------------------------------------------------------------------
//
//      Author     : M.Frank
//====================================================================
#ifndef POOLDB_POOLDBCNVFACTORY_H
#define POOLDB_POOLDBCNVFACTORY_H 1
#include "GaudiKernel/ICnvFactory.h"
#include "GaudiKernel/FactoryTable.h"
#include "GaudiKernel/System.h"
#include "StorageSvc/DbType.h"

// Interface ID ( interface id, major version, minor version) 
static const InterfaceID IID_IPoolDbCnvFactory("IPoolDbCnvFactory", 2 , 0); 

class IPoolDbCnvFactory : virtual public IInterface   {
public:
  static const InterfaceID& interfaceID() { return IID_IPoolDbCnvFactory; }
  virtual IConverter* instantiate(long typ,
                                  const CLID& clid, 
                                  ISvcLocator *svcloc )  const = 0;
};

template <class ConcreteConverter, int i>
class PoolDbCnvFactory : virtual public ICnvFactory,
                         virtual public IPoolDbCnvFactory   
{
  mutable std::string m_typeName;
public:
  typedef ConcreteConverter converter_t;

  PoolDbCnvFactory()  {
    m_typeName = "";
    FactoryTable::instance()->addFactory( this );
  }
  virtual ~PoolDbCnvFactory()  {  }
  virtual const std::string& typeName()  const    {
    // The name MUST be set here, not in the constructor.
    // At construction time it is not yet clear if we run from
    // an executable or a DLL.
    if ( m_typeName == "" )  {
      if ( System::moduleType() == System::SHAREDLIB )  {
        m_typeName  = System::moduleName();
        m_typeName += ":";
      }
      // Get the class name using the RTTI. 
      m_typeName += System::typeinfoName( typeid(ConcreteConverter) );
    }
    return m_typeName;
  }
  virtual const CLID& objType()  const;
  virtual const long repSvcType()   const
  {    return pool::POOL_StorageType.type();  }
  virtual unsigned long addRef()  const     {     return 1;           }
  virtual unsigned long release()   const   {     return 1;           }
  virtual const std::string& ident() const  {     return typeName();  }
  // IInterface implementation
  virtual unsigned long addRef()            {     return 1;           }
  virtual unsigned long release()           {     return 1;           }

  virtual StatusCode queryInterface(const InterfaceID& riid, void** ppISvc)   {
          if ( IID_IPoolDbCnvFactory == riid )   {
      *ppISvc = (IPoolDbCnvFactory *) this;
    }
          else if( IID_ICnvFactory == riid )    {
        *ppISvc = (ICnvFactory*) this;
    }
          else if ( IID_IFactory == riid )     {
          *ppISvc = (IFactory *) this;
    }
    else if ( IID_IInterface == riid )    {
        *ppISvc = (IInterface *) this;
    }
          else    {
                  return StatusCode::FAILURE;
    }
    addRef();
          return StatusCode::SUCCESS;
  }

  virtual IConverter* instantiate(long typ,
                                  const CLID& /* clid */, 
                                  ISvcLocator *svcloc)  const
  {    return new ConcreteConverter(typ, svcloc);  }

  virtual IConverter* instantiate( ISvcLocator* /* svcloc */ )  const
  {    return 0;  }

  virtual IInterface* instantiate( IInterface* /* parent */ ) const
  {    return 0;  }

};
#endif    // POOLDB_POOLDBCNVFACTORY_H