DLL.h

Go to the documentation of this file.

// $Id: $
#ifndef INC_DLL_H 
#define INC_DLL_H 1

// Include files
#include <string>
#include <vector>

#ifndef WIN32
#include <unistd.h>
#include <dlfcn.h>
#else
#include "windows.h"
#include <direct.h>
#endif

// CATKernel
#include "StatusCode.h"
#include "Tools.h"
#include "Element.h"
#include "Processus.h"

#define DECLARE_DLL(x) \
extern "C" void x##_dll( DLL* dll ) 

#define DECLARE_ELEMENT(x,y) \
  dll->addElement   (#x,#y); 

#define DECLARE_PROCESSUS(x,y) \
  dll->addProcessus   (#x,#y); 

#define DECLARE_OBJECT(x,y) \
  dll->addObject   (#x,#y); 
/*
#define FACTORY(type,x) \
extern "C" type##* x##_create() { \
  return (new x) ; \
} \
extern "C" void x##_destroy(type##* p) { \
  delete p; \
} 
*/
#define FACTORY(type,x) \
extern "C" type* x##_create() { \
  return (new x) ; \
} \
extern "C" void x##_destroy(type* p) { \
  delete p; \
} 

class DLL {

public: 

#ifdef WIN32
  typedef HMODULE ImageHandle;
#else 
  typedef void* ImageHandle;
#endif

  typedef void (*EntryPoint) (DLL*);

  typedef Element*   (*ConstructorElement)   ( );
  typedef void (*DestructorElement)   (Element*);
  typedef Processus* (*ConstructorProcessus) ( );
  typedef void (*DestructorProcessus) (Processus*);
  typedef Object* (*ConstructorObject) ( );
  typedef void (*DestructorObject) (Object*);

  typedef std::pair<std::string,std::string> identification;
  typedef std::vector<identification> listOfElements ;
  typedef std::vector<identification> listOfProcessus ;
  typedef std::vector<identification> listOfObjects ;

  DLL( ); 

  virtual ~DLL( ); 

  StatusCode load ( std::string );

  StatusCode unload ( );

  void setName (std::string name) {
    m_name = name;
  }

  std::string name () {
    return m_name;
  }

  listOfElements listElements () {
    return m_listElements;
  }

  listOfProcessus listProcessus () {
    return m_listProcessus;
  }

  listOfObjects listObjects () {
    return m_listObjects;
  }

  void addElement( std::string element , 
                   std::string description = std::string ("") )
  {
    identification id ( element , description );
    m_listElements.push_back( id );
  }

  void addProcessus( std::string proc , 
             std::string description = std::string ("") )
    {
    identification id ( proc , description ); 
    m_listProcessus.push_back( id );
  }

  void addObject( std::string proc , 
          std::string description = std::string ("") )
    {
    identification id ( proc , description ); 
    m_listObjects.push_back( id );
  }

  bool containsObject ( std::string );

  std::vector<std::string> objectList ( );

  StatusCode init () ;

  Element* createElement (std::string );

  Processus* createProcessus (std::string );

  Object* createObject (std::string );
  
  StatusCode destroy ( Element* );

  StatusCode destroy ( Processus* );
  
  StatusCode destroy ( Object* );
  
  void print();

protected:

private:
  MsgSvc      m_log ;
  std::string        m_name;
  ImageHandle        m_handle;
  listOfElements     m_listElements;
  listOfProcessus    m_listProcessus;
  listOfObjects      m_listObjects;
  std::vector<ConstructorElement>   m_elementConstructors;
  std::vector<DestructorElement>    m_elementDestructors;
  std::vector<ConstructorProcessus> m_processusConstructors;
  std::vector<DestructorProcessus>  m_processusDestructors;
  std::vector<ConstructorObject>    m_objectConstructors;
  std::vector<DestructorObject>     m_objectDestructors;

  void msg     ( std::string mymsg ) { m_log.msgSvc (MsgSvc::NONE    , mymsg, m_name ); }
  void verbose ( std::string mymsg ) { m_log.msgSvc (MsgSvc::VERBOSE , mymsg, m_name ); }
  void debug   ( std::string mymsg ) { m_log.msgSvc (MsgSvc::DEBUG   , mymsg, m_name ); }
  void info    ( std::string mymsg ) { m_log.msgSvc (MsgSvc::INFO    , mymsg, m_name ); }
  void warning ( std::string mymsg ) { m_log.msgSvc (MsgSvc::WARNING , mymsg, m_name ); }
  void fatal   ( std::string mymsg ) { m_log.msgSvc (MsgSvc::FATAL   , mymsg, m_name ); }

  void msg     ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::NONE    , mymsg, name ); }
  void verbose ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::VERBOSE , mymsg, name ); }
  void debug   ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::DEBUG   , mymsg, name ); }
  void info    ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::INFO    , mymsg, name ); }
  void warning ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::WARNING , mymsg, name ); }
  void fatal   ( std::string mymsg , std::string name ) { m_log.msgSvc (MsgSvc::FATAL   , mymsg, name ); }
 
};
#endif // INC_DLL_H