DLL.cpp

Go to the documentation of this file.

// $Id: $
// Include files

#include "ProcDataBase.h"
#include "Element.h"
#include "Processus.h"

// local
#include "DLL.h"

//-----------------------------------------------------------------------------
// Implementation file for class : DLL
//
// 2006-10-24 :
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
DLL::DLL( ) :
m_handle (0)
{
}
//=============================================================================
// Destructor
//=============================================================================
DLL::~DLL() {}

//=========================================================================
//
//=========================================================================
bool DLL::containsObject ( std::string name ) {
  std::vector<identification>::const_iterator iter;
  for ( iter=m_listElements.begin() ;
        iter!=m_listElements.end() ;
        ++iter ) {
    if ( 0==name.compare( iter->first ) ){
      return true;
    }
  }
  for ( iter=m_listProcessus.begin() ;
        iter!=m_listProcessus.end() ;
        ++iter ) {
    if ( 0==name.compare( iter->first ) ){
      return true;
    }
  }
  return false;
}


//=========================================================================
//
//=========================================================================
std::vector<std::string> DLL::objectList ( ) {
  std::vector<std::string> list;
  std::vector<identification>::const_iterator iter;
  for ( iter=m_listElements.begin() ;
        iter!=m_listElements.end() ;
        ++iter ) {
    list.push_back ( iter->first );
  }
  for ( iter=m_listProcessus.begin() ;
        iter!=m_listProcessus.end() ;
        ++iter ) {
    list.push_back ( iter->first );
  }
  return list;
}

//=========================================================================
//
//=========================================================================
void DLL::print ( ) {
  char line [100];
  info("Symbols found in dll "+name()+": "+
         itos(m_listElements.size())+" Element(s) - "+
         itos(m_listProcessus.size())+" Processus.");
  std::vector<identification>::const_iterator iter;
  if ( m_listElements.size()>0 ) {
    sprintf(line,"============================================================================================");
    info(line,"DLL::print");
    sprintf(line ,"Element                    Description");
    info(line,"DLL::print");
    for ( iter=m_listElements.begin() ;
      iter!=m_listElements.end() ;
      ++iter ) {
      sprintf(line," %25s %65s ",
          iter->first.c_str(),
          iter->second.c_str());
      info(std::string(line),"DLL::print");
    }
  }
  if ( m_listProcessus.size() > 0 ) {
    sprintf(line,"============================================================================================");
    info(line,"DLL::print");
    sprintf (line ,"Processus                 Target Type");
    info(line,"DLL::print");
    for ( iter=m_listProcessus.begin() ;
      iter!=m_listProcessus.end() ;
      ++iter ) {
      sprintf(line," %25s %25s  ",
          iter->first.c_str(),
          application()->procDb()->processus(iter->first)->type().c_str()
          //        application()->procDb()->processus(iter->first)->title().c_str()
          );
      info(std::string(line),"DLL::print");
    }
  }
  sprintf(line,"============================================================================================");
  info(line,"DLL::print");
}


//=========================================================================
//
//=========================================================================
StatusCode DLL::load ( std::string library ) {
  typedef Element* (*func) ();
#ifdef WIN32
  m_handle = LoadLibrary ((library+std::string(".dll")).c_str());
#else
  m_handle = dlopen( (std::string("lib")+library+std::string(".so")).c_str() , RTLD_LAZY );
#endif
  if ( NULL != m_handle ) {

    // get entry point
    setName(library);
    DLL::EntryPoint entryPoint;
#ifdef WIN32
    entryPoint = (DLL::EntryPoint)GetProcAddress(m_handle,
                                                 (library+std::string("_dll")).c_str());
#else
    entryPoint = (DLL::EntryPoint)dlsym(m_handle,
                                       (library+std::string("_dll")).c_str());
#endif
    if ( !entryPoint ) {
      warning("No entry point found in library "+library+".","DLL::load");
      // could not find entry point
#ifdef WIN32
      FreeLibrary( m_handle );
#else
      dlclose( m_handle );
#endif
      warning("Could not load dll entry point "+name(),"DLL::load");
      return StatusCode::FAILURE;
    }
    else {
      debug("Entry point found in library "+library+".","DLL::load");
      // entry point found : load list of objects
      entryPoint ( this );
      // check if we can find constructors/destructors
      if ( init().isFailure() ) {
    info("Could not find Constructors/Destructors in library "+
         library+".","DLL::load");
        return StatusCode::FAILURE;
      }
      print();
      return StatusCode::SUCCESS;
    }
  }
  else {
    warning("No handle on library "+library+".","DLL::load");
  }
  return StatusCode::FAILURE;
}


//=========================================================================
//
//=========================================================================
StatusCode DLL::init (  ) {
  bool initOk = true;
  std::vector<identification>::const_iterator iter;
  for ( iter=m_listElements.begin() ;
        iter!=m_listElements.end() ;
        ++iter ) {
    ConstructorElement constructor;
    DestructorElement destructor;
#ifdef WIN32
    constructor = (ConstructorElement)GetProcAddress(m_handle,
                                                     (iter->first+
                                                      std::string("_create")).c_str());
    destructor = (DestructorElement)GetProcAddress(m_handle,
                                                   (iter->first+
                                                    std::string("_destroy")).c_str());
#else
    constructor = (ConstructorElement)dlsym(m_handle,
                                           (iter->first+
                                           std::string("_create")).c_str());
    destructor = (DestructorElement)dlsym(m_handle,
                                         (iter->first+
                                         std::string("_destroy")).c_str());
#endif
    if ( 0 == constructor) {
      warning("Could not find constructor of "+iter->first+std::string(" (_create)"),"DLL::init");
      initOk=false;
    }
    if ( 0 == destructor) {
      warning("Could not find destructor of "+iter->first+std::string(" (_destroy)"),"DLL::init");
      initOk=false;
    }
    if (initOk) {
      m_elementConstructors.push_back( constructor );
      m_elementDestructors.push_back( destructor );
    }
  }
  if (!initOk){
    return StatusCode::FAILURE;
  }

  initOk=true;
  for ( iter=m_listProcessus.begin() ;
        iter!=m_listProcessus.end() ;
        ++iter ) {
    ConstructorProcessus constructor;
    DestructorProcessus destructor;
#ifdef WIN32
    constructor = (ConstructorProcessus)GetProcAddress(m_handle,
                                                       (iter->first+
                                                        std::string("_create")).c_str());
    destructor = (DestructorProcessus)GetProcAddress(m_handle,
                                                     (iter->first+
                                                      std::string("_destroy")).c_str());
#else
    constructor = (ConstructorProcessus)dlsym(m_handle,
                                             (iter->first+
                                             std::string("_create")).c_str());
    destructor = (DestructorProcessus)dlsym(m_handle,
                                           (iter->first+
                                           std::string("_destroy")).c_str());
#endif
    if ( 0 == constructor) {
      warning("Could not find constructor of "+iter->first,"DLL::init");
      initOk=false;
    }
    if ( 0 == destructor) {
      warning("Could not find destructor of "+iter->first,"DLL::init");
      initOk=false;
    }
    if (initOk){
      m_processusConstructors.push_back( constructor );
      m_processusDestructors.push_back( destructor );
      // create the corresponding processus in the database
      Processus* proc = createProcessus ( iter->first );
      if ( 0==proc ){
        initOk=false;
      }
      else {
        application()->procDb()->add( proc);
      }
    }
  }
  if (!initOk){
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode DLL::unload ( ) {
  if ( NULL != m_handle ){
#ifdef WIN32
    FreeLibrary( m_handle );
#else
    dlclose( m_handle );
#endif
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

//=========================================================================
//
//=========================================================================
Element* DLL::createElement ( std::string name ) {
  std::vector<identification>::const_iterator iter;
  std::vector<ConstructorElement>::const_iterator constructor=m_elementConstructors.begin();
  for ( iter=m_listElements.begin() ;
        iter!=m_listElements.end() ;
        ++iter ) {
    if ( 0==name.compare(iter->first) ){
      Element *element = (*constructor)() ;
      element->setDllName(this->name());
      return ( element );
    }
    constructor++;
  }
  return NULL;
}

//=========================================================================
//
//=========================================================================
Processus* DLL::createProcessus ( std::string name ) {
  std::vector<identification>::const_iterator iter;
  std::vector<ConstructorProcessus>::const_iterator constructor=m_processusConstructors.begin();
  for ( iter=m_listProcessus.begin() ;
        iter!=m_listProcessus.end() ;
        ++iter ) {
    if ( 0==name.compare(iter->first) ){
      Processus *processus=(*constructor)();
      processus->setDllName(this->name());
      return ( processus );
    }
    constructor++;
  }
  return NULL;
}

//=========================================================================
//
//=========================================================================
StatusCode DLL::destroy ( Element *ptr ) {
  std::vector<identification>::const_iterator iter;
  std::vector<DestructorElement>::const_iterator destructor=m_elementDestructors.begin();
  for ( iter=m_listElements.begin() ;
        iter!=m_listElements.end() ;
        ++iter ) {
    if ( 0==(ptr->type()).compare(iter->first) ){
      ( (*destructor)( ptr ) );
      return StatusCode::SUCCESS;
    }
    destructor++;
  }
  return StatusCode::FAILURE;
}

//=========================================================================
//
//=========================================================================
StatusCode DLL::destroy ( Processus *ptr ) {
  std::vector<identification>::const_iterator iter;
  std::vector<DestructorProcessus>::const_iterator destructor=m_processusDestructors.begin();
  for ( iter=m_listProcessus.begin() ;
        iter!=m_listProcessus.end() ;
        ++iter ) {
    if ( 0==(ptr->type()).compare(iter->first) ){
      ( (*destructor)( ptr ) );
      return StatusCode::SUCCESS;
    }
    destructor++;
  }
  return StatusCode::FAILURE;
}

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