---

DLLClassManager.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/ApplicationMgr/DLLClassManager.cpp,v 1.1.1.3 2001/04/18 18:32:48 tlindner Exp $

// Include files
#include "GaudiKernel/IFactory.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/ICnvManager.h"
#include "GaudiKernel/IObjManager.h"
#include "GaudiKernel/IAlgFactory.h"
#include "GaudiKernel/ISvcFactory.h"
#include "GaudiKernel/ICnvFactory.h"
#include "GaudiKernel/FactoryTable.h"
#include "GaudiKernel/ObjectFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "DLLClassManager.h"
#include "GaudiKernel/System.h"

#include <iostream>

typedef std::pair<FactoryTable::EntryList*,FactoryTable::EntryList*> TableObject;
class DllTableSpace : public std::map< std::string, TableObject >  {
public:
  DllTableSpace();
  virtual ~DllTableSpace();
  void addDll(const std::string& key, FactoryTable::EntryList* list);
  FactoryTable::EntryList* shadow(TableObject& key);
};

DllTableSpace::DllTableSpace()   {
}

DllTableSpace::~DllTableSpace()   {
  for ( iterator i = begin(); i != end(); i++ )   {
    FactoryTable::EntryList* tab    = (*i).second.first;
    tab->erase(tab->begin(), tab->end());
    delete tab;
    tab = (*i).second.second;
    tab->erase(tab->begin(), tab->end());
    delete tab;
    (*i).second.first = (*i).second.second = 0;
  }
  erase(begin(), end());
}

FactoryTable::EntryList* DllTableSpace::shadow(TableObject& obj)    {
  obj.second->erase(obj.second->begin(), obj.second->end());
  for( FactoryTable::EntryList::iterator it = obj.first->begin(); it != obj.first->end(); it++ ) {
    obj.second->push_back(*it);
  }
  return obj.second;
}

void DllTableSpace::addDll(const std::string& key, FactoryTable::EntryList* list)   {
  FactoryTable::EntryList* tab    = new FactoryTable::EntryList(list->begin(), list->end());
  FactoryTable::EntryList* shadow = new FactoryTable::EntryList();
  this->insert(value_type(key, TableObject(tab, shadow)));
}

static DllTableSpace s_dllTableSpace;

// default creator
DLLClassManager::DLLClassManager( ISvcLocator* svclocator ) {
  m_svclocator = svclocator;
  m_msgsvc     = 0;
  m_algmanager = 0;
  m_svcmanager = 0;
  m_cnvmanager = 0;
  m_objmanager = 0;
  m_refcount   = 1;
}

// virtual destructor
DLLClassManager::~DLLClassManager() {
}

// implementation of IClassManager::declareFactory
StatusCode DLLClassManager::declareFactory( const IFactory& factory ) {
  // We need to find out what type of factory we are dealing
  StatusCode     sc;
  IFactory& fact = const_cast<IFactory&>(factory);

  IAlgFactory* algfactory = 0;
  sc = fact.queryInterface( IID_IAlgFactory, (void**)&algfactory );
  if( sc.isSuccess() ) {
    if( m_algmanager == 0 ) {
      sc = m_svclocator->queryInterface( IID_IAlgManager, (void**)&m_algmanager );
      if( sc.isFailure() ) return sc;
    }
//PM    std::cout << algfactory->algType() << std::endl;
    return m_algmanager->declareAlgFactory( *algfactory, algfactory->algType() );
  }

  ISvcFactory* svcfactory = 0;
  sc = fact.queryInterface( IID_ISvcFactory, (void**)&svcfactory );
  if( sc.isSuccess() ) {
    if( m_svcmanager == 0 ) {
      sc = m_svclocator->queryInterface( IID_ISvcManager, (void**)&m_svcmanager );
      if( sc.isFailure() ) return sc;
    }
//PM    std::cout << svcfactory->svcType() << std::endl;
    return m_svcmanager->declareSvcFactory( *svcfactory, svcfactory->svcType() );
  }

  ICnvFactory* cnvfactory = 0;
  sc = fact.queryInterface( IID_ICnvFactory, (void**)&cnvfactory );
  if( sc.isSuccess() ) {
    if( m_cnvmanager == 0 ) {
      sc = m_svclocator->queryInterface( IID_ICnvManager, (void**)&m_cnvmanager );
      if( sc.isFailure() ) return sc;
    }
    return m_cnvmanager->declareCnvFactory( *cnvfactory );
  }

  // Everything which is not an algorithm, converter or service goes to the default manager
  if( m_objmanager == 0 ) {
    sc = m_svclocator->queryInterface( IID_IObjManager, (void**)&m_objmanager );
    if( sc.isFailure() ) return sc;
  }
  return m_objmanager->declareObjFactory( factory );
}

// implementation of IClassManager::loadModule 
StatusCode DLLClassManager::loadModule( const std::string& module ) {
  // Access the message service if not yet done already
  if( m_msgsvc == 0 ) {
    m_svclocator->getService( "MessageSvc", IID_IMessageSvc, (IInterface*&)m_msgsvc );
  }
  MsgStream log(m_msgsvc, "DllClassManager");

  std::string mod = module=="" ? System::moduleNameFull() : module;
  if( module == "NONE" ) return StatusCode::SUCCESS;

  FactoryTable::EntryList* elist = 0;
  DllTableSpace::iterator tabIt = s_dllTableSpace.find(mod);
  if ( tabIt != s_dllTableSpace.end() )    {
    elist = s_dllTableSpace.shadow((*tabIt).second);
  }
  else if ( module.length() == 0) {
    //  A empty module name means current module
    elist = FactoryTable::instance()->getEntries();
    if ( 0 != elist ) s_dllTableSpace.addDll(mod, elist);
  }
  else {
    void* libHandle = 0;
    StatusCode status = System::loadDynamicLib( module, &libHandle);
    if ( status.isSuccess() )   {
      FactoryTable::GetFunction func;
      status = System::getProcedureByName(libHandle, "getFactoryEntries", (System::Creator*)&func);
      if ( status.isSuccess() )   {
        elist = (func)();
        if ( 0 != elist ) s_dllTableSpace.addDll(mod, elist);
      }
      else    {
        // Entry point not found in DLL library
        log << MSG::ERROR << "Not found entry point" << endreq;
        return StatusCode::FAILURE;      
      }
    }
    else    {
      // DLL library not loaded
      log << MSG::ERROR << "Not found DLL " << module << endreq;
      return StatusCode::FAILURE; 
    }
  }
  if( elist == 0 ) return StatusCode::FAILURE;

  long num = 0;
  for( FactoryTable::EntryList::iterator it = elist->begin(); it != elist->end(); it++ ) {
    if( m_msgsvc ) {
      log << MSG::DEBUG << "Found factory " << (*it)->ident() << endreq;
    }
    declareFactory( *(*it) );
    num++;
  }
  if( m_msgsvc ) {
    log << MSG::INFO << "Loaded " << num << " factories from module "
      << ( (module == "")? System::moduleNameFull() : module ) << endreq;
  }

  // Clear the factoy table to get ready for next Module load
  elist->erase( elist->begin(), elist->end() );
  return StatusCode::SUCCESS;
}
  
// implmentation of IInterface::addRef
unsigned long DLLClassManager::addRef() {
  m_refcount++;
        return m_refcount;
}
  
// implmentation of IInterface::release
unsigned long DLLClassManager::release() {
  m_refcount--;
  if( m_refcount <= 0) {
    delete this;
  }
  return m_refcount;
}
  
// implementation of IInterface::queryInterface
StatusCode DLLClassManager::queryInterface(const IID& iid, void** pinterface) {
  if( iid == IID_IInterface ) {  
    *pinterface = (IInterface*)this;
  } 
  else if ( iid == IID_IClassManager ) {
    *pinterface = (IClassManager*)this;
  } 
  else if ( iid == IID_IInterface ) {
    *pinterface = (IInterface*)this;
  } 
  else {
    return StatusCode::FAILURE;
  }
  addRef();
  return StatusCode::SUCCESS;
}

---