DLLMgr.cpp

Go to the documentation of this file.

// $Id: $
// Include files 

#include "DLL.h"
#include "Element.h"
#include "Processus.h"

// local
#include "DLLMgr.h"

//-----------------------------------------------------------------------------
// Implementation file for class : DLLMgr
//
// 2006-10-25 : 
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
DLLMgr::DLLMgr(  ) {

}
//=============================================================================
// Destructor
//=============================================================================
DLLMgr::~DLLMgr() {} 


//=========================================================================
//  
//=========================================================================
StatusCode DLLMgr::load ( std::string library ) {
  // load library
  info("Loading dll "+library+".","DLLMgr::load");

  DLL *mydll = new DLL ();
  // look if we can load the library
  if ( mydll->load ( library ).isSuccess() ){
    info("Library "+library+" loaded.");
    // look for duplication of library
    if ( 0!=dll(library) ){
      warning("DLL "+library+" already loaded. Cannot load library.","DLLMgr::loadDLL");
      delete mydll;
      return StatusCode::FAILURE;
    }
    // look for duplication of objects
    std::vector<std::string> list = mydll->objectList();
    std::vector<DLL*>::const_iterator iter ;
    std::vector<std::string>::const_iterator objs ;
    for ( objs=list.begin() ; 
          objs!=list.end()  ;
          ++objs ) {
      for ( iter = m_dlls.begin() ; 
            iter != m_dlls.end() ; 
            ++iter ) {
        if ( (*iter)->containsObject( *objs ) ){
          warning("The DLL "+library+" contains an object ("+
                 (*objs) +" which has already been loaded from "+
                 (*iter)->name()+". Cannot load library.",
          "DLLMgr::loadDLL");
          delete mydll;
          return StatusCode::FAILURE;
        }
      }
    }
     // everything is ok. definitely keep the new library in the manager     
     m_dlls.push_back ( mydll );
     return StatusCode::SUCCESS;
   }
   // could not even find the library
   warning("The DLL "+library+" could not be properly loaded.","DLLMgr::loadDLL");
   delete mydll;
   return StatusCode::FAILURE;
}

//=========================================================================
//  
//=========================================================================
StatusCode DLLMgr::unload ( std::string lib ) {
  std::vector<DLL*>::iterator dlltoremove;
  std::vector<DLL*>::iterator iter ;
  for ( iter = m_dlls.begin() ; 
        iter != m_dlls.end()  ; 
        ++iter ) {
    if ( 0==lib.compare((*iter)->name()) ) {
      (*iter)->unload();
      dlltoremove = iter;
    }
    delete *dlltoremove;
    m_dlls.erase(dlltoremove);
  }
  return NULL;
}

//=========================================================================
//  
//=========================================================================
DLL* DLLMgr::libraryOfObject ( std::string obj ) {
  std::vector<DLL*>::const_iterator iter ;
  for ( iter = m_dlls.begin() ; 
        iter != m_dlls.end()  ; 
        ++iter ) {
    if ( (*iter)->containsObject( obj ) ){
      return (*iter);
    }
  }
  return NULL;
}

//=========================================================================
//  
//=========================================================================
DLL* DLLMgr::dll ( std::string lib ) {
  std::vector<DLL*>::const_iterator iter ;
  for ( iter = m_dlls.begin() ; 
        iter != m_dlls.end()  ; 
        ++iter ) {
    if ( 0==lib.compare( (*iter)->name() ) ){
      return (*iter);
    }
  }
  return NULL;
}

//=========================================================================
//  
//=========================================================================
Element* DLLMgr::createElement ( std::string name ) {
  DLL* lib = libraryOfObject(name);
  if ( 0!=lib ){
    return lib->createElement( name );
  }
  return NULL;
}

//=========================================================================
//  
//=========================================================================
Processus* DLLMgr::createProcessus ( std::string name ) {
  DLL* lib = libraryOfObject(name);
  if ( 0!=lib ){
    return lib->createProcessus( name );
  }
  return NULL;
}

//=========================================================================
//  
//=========================================================================
StatusCode DLLMgr::destroy ( Element* element ) {
  DLL* mydll = libraryOfObject( element->type () );
  if ( 0 != mydll ) {
    mydll->destroy(element);
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

//=========================================================================
//  
//=========================================================================
StatusCode DLLMgr::destroy ( Processus *proc ) {
  DLL* mydll = libraryOfObject(proc->type());
  if ( 0 != mydll ) {
    mydll->destroy(proc);
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

//=========================================================================
//  
//=========================================================================
void DLLMgr::print()
{
  std::vector<DLL*>::iterator iter ;
  for ( iter = m_dlls.begin() ; 
        iter != m_dlls.end()  ; 
        ++iter ) {(*iter)->print();}
}

//=============================================================================