---

Bootstrap.cpp

Go to the documentation of this file.

//$Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/Bootstrap.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $

#include <iostream>

#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/FactoryTable.h"


#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/IFactory.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IClassManager.h"
#include "GaudiKernel/ISvcFactory.h"
#include "GaudiKernel/IAlgFactory.h"
#include "GaudiKernel/IAuditorFactory.h"


//-----------------------------------------------------------------------------------------
IAppMgrUI* Gaudi::createApplicationMgr(const std::string& dllname,
                                       const std::string& factname)
//-----------------------------------------------------------------------------------------
{
  // Allow not for multiple AppManagers: If already instantiated then just return it
  static IAppMgrUI* appmgr_instance = createApplicationMgrEx(dllname, factname);
  return appmgr_instance;
}

//-----------------------------------------------------------------------------------------
IAppMgrUI* Gaudi::createApplicationMgrEx(const std::string& dllname,
                                         const std::string& factname)
//-----------------------------------------------------------------------------------------
{
  StatusCode     status;
  IInterface*    iif;
  IAppMgrUI*     iappmgr;
  IClassManager* iclassmgr;

  // Create an instance of the application Manager
  iif = Gaudi::createInstance( "ApplicationMgr", factname, dllname );
  if( iif == 0 ) {
    return 0;
  }
  // Locate few interfaces of the Application Manager
  status = iif->queryInterface( IID_IAppMgrUI, (void**)&iappmgr );
  if( status.isFailure() ) {
    return 0;
  }
  status = iif->queryInterface( IID_IClassManager, (void**)&iclassmgr );
  if( status.isFailure() ) {
    return 0;
  }

  // Declare factories in the local executable
/*
  FactoryTable::EntryList* elist = FactoryTable::instance()->getEntries();
  if( elist != 0) {
    for( FactoryTable::EntryList::iterator it = elist->begin(); it != elist->end(); it++ ) {
      //std::cout << "Found factory for " << (*it)->ident() << " in local module" << std::endl;
      iclassmgr->declareFactory( *(*it) );
    }
    // Clear the FactoryTable to be prepare for next module to load
    FactoryTable::instance()->clearTable();
  }
*/
  return iappmgr;
}

//-----------------------------------------------------------------------------------------
ISvcLocator* Gaudi::svcLocator()
//-----------------------------------------------------------------------------------------
{
  static ISvcLocator* svcloc_instance = 0;
  if( svcloc_instance ) return svcloc_instance;

  IAppMgrUI* iappmgr = createApplicationMgr();
  if( iappmgr ) {
    StatusCode sc = iappmgr->queryInterface( IID_ISvcLocator, (void**)&svcloc_instance );
    if( sc.isSuccess() ) {
      return svcloc_instance;
    }
  }
  return 0;
}

//-----------------------------------------------------------------------------------------
IInterface* Gaudi::createInstance( const std::string& name, 
                                                const std::string& factname, 
                                                const std::string& dllname)
//-----------------------------------------------------------------------------------------
{
  IFactory*  iif;
  IAlgFactory* ialgfact;
  IAuditorFactory* iaudfact;
  ISvcFactory* isvcfact;

  iif = const_cast<IFactory*>( Gaudi::getFactory( factname, dllname ) );
  if( iif == 0 ) {
    return 0;
  }

  if( iif->queryInterface( IID_IAlgFactory, (void**)&ialgfact ).isSuccess() ) {
    return (IInterface*)(ialgfact->instantiate( name, 0 ));
  }
  else if( iif->queryInterface( IID_IAuditorFactory, (void**)&iaudfact ).isSuccess() ) {
    return (IInterface*)(iaudfact->instantiate( name, 0 ));
  }
  else if ( iif->queryInterface( IID_ISvcFactory, (void**)&isvcfact ).isSuccess() ) {
    return (IInterface*)(isvcfact->instantiate( name, 0 ));
  }
  else {
    return iif->instantiate( 0 );
  }
}

class ShadowEntry    {
public:
  std::string dllName;
  std::string facName;
  IFactory*   fac;
public:
  ShadowEntry() {
  }
  ShadowEntry(const std::string& d, const std::string& n, const IFactory* f)     {
    dllName = d;
    facName = n;
    fac     = const_cast<IFactory*>(f);
  }
  ShadowEntry(const ShadowEntry& copy)   {
    dllName = copy.dllName;
    facName = copy.facName;
    fac     = copy.fac;
  }
  ShadowEntry& operator=(const ShadowEntry& copy)   {
    dllName = copy.dllName;
    facName = copy.facName;
    fac     = copy.fac;
    return *this;
  }
};

//-----------------------------------------------------------------------------------------
const IFactory* Gaudi::getFactory(const std::string& factname, const std::string& dllname)
//-----------------------------------------------------------------------------------------
{
  StatusCode status;
  void* libHandle = 0;
  FactoryTable::EntryList* elist = 0;
  static std::vector<ShadowEntry> s_shadow;

  // Try first to look in the shadows
  for ( std::vector<ShadowEntry>::iterator sit = s_shadow.begin(); sit != s_shadow.end(); sit++)    {
    if ( (*sit).dllName == dllname && (*sit).facName == factname && 0 != (*sit).fac )    {
      return (*sit).fac;
    }
  }

  // Try fisrt to look in the local FactoryTable
  elist = FactoryTable::instance()->getEntries();    
  for( FactoryTable::EntryList::iterator it = elist->begin(); it != elist->end(); it++ ) {
    if( factname == (*it)->ident() ) {
      s_shadow.push_back(ShadowEntry(dllname, factname, (*it)));
      return (*it);
    }
  }

  elist = 0;

  status = System::loadDynamicLib( dllname, &libHandle);
  if ( status.isSuccess() )   {
    FactoryTable::GetFunction func;
    status = System::getProcedureByName(libHandle, "getFactoryEntries", (System::Creator*)&func);
    if ( status.isSuccess() )   {
      elist = (func)();
    }
    else {
      // Entry point not found in DLL library
      std::cout << "Gaudi::Bootstrap: Not found entry point" << std::endl;
      return 0;      
    }
  }
  else  {
    // DLL library not loaded. Try in the local module
    std::cout << "Gaudi::Bootstrap: Not found DLL " << dllname << std::endl;
    return 0; 
  }

  if( elist != 0) {
    for( FactoryTable::EntryList::iterator it = elist->begin(); it != elist->end(); it++ ) {
      if( factname == (*it)->ident() ) {
        s_shadow.push_back(ShadowEntry(dllname, factname, (*it)));
        return (*it);
      }
    }
    std::cout << "Gaudi::Bootstrap: Factory with name " << factname << "not found in DLL" << std::endl;
    return 0;
  }
  else {
    std::cout << "Gaudi::Bootstrap: FactoryTable not found in DLL" << std::endl;
    return 0;
  }
}

---