JFunctionAdaptor.hh

Go to the documentation of this file.

#ifndef __JEEP__JFUNCTIONADAPTOR__
#define __JEEP__JFUNCTIONADAPTOR__
 
#include <istream>
#include <ostream>
#include <string>
#include <dlfcn.h>
 
#include "JLang/JException.hh"
#include "JLang/JSharedCounter.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JEEP {}
namespace JPP { using namespace JEEP; }
 
namespace JEEP {
 
  using JLANG::JSharedCounter;
  using JLANG::JFileOpenException;
  using JLANG::JFileReadException;
 
 
  /**
   * Auxiliary base class for function adaptor.
   *
   * Note that the dynamic load library internally maintains link counts for the file handles.
   */
  template<class __pF__>
  struct JFunctionAdaptorHelper :
    JSharedCounter
  {
    /**
     * Separation character between library file name and function name.
     */
    static const char SEPARATOR = ':';
 
    
    /**
     * Virtual destructor.
     */
    virtual ~JFunctionAdaptorHelper()
    {
      reset();
    }
    
 
    /**
     * Check validity of function.
     *
     * \return                     true if valid function; else false
     */
    bool is_valid() const
    {
      return (function != NULL);
    }
    
 
    /**
     * Reset function adaptor helper.
     */
    void reset()
    {
      if (detach()) {
        close();
      }
      
      function = NULL;
    }
    
 
    /**
     * Set function.
     *
     * \param  pf                  pointer to function
     */
    void set(__pF__ pf)
    {
      reset();
      
      function = pf;
    }
 
 
    /**
     * Get function with given name according to specific protocol.
     *
     * \param  symbol              function name
     */
    void get(const char* symbol)
    {
      function = NULL;
 
      if (handle != NULL) {
 
        dlerror();                 // reset errors
 
        function = (__pF__) dlsym(handle, symbol);
 
        const char* error = dlerror();
 
        if (error != NULL) {
          THROW(JFileReadException, error);
        }
 
      } else {
 
        THROW(JFileReadException, "Invalid handle.");
      }
    }
    
 
    /**
     * Check if shared library file is open.
     *
     * \return                     true if open; else false
     */
    bool is_open() const
    {
      return (handle != NULL);
    }
 
    
    /**
     * Open file.
     *
     * \param  file_name           file name
     */
    void open(const char* file_name)
    {
      reset();
      
      handle = dlopen(file_name, RTLD_LOCAL | RTLD_LAZY);
 
      if (!handle) {
        THROW(JFileOpenException, dlerror());
      }
 
      initialise();
    }
 
 
    /**
     * Close file.
     *
     * Note that the file should remain open as long as the library function is used.
     */
    void close()
    {
      if (handle != NULL) {
        dlclose(handle);
        dlclose(handle);
      }
 
      handle = NULL;
    }
    
          
    /**
     * Load function from shared library.
     *
     * \param  libso               file name
     * \param  symbol              function name
     */
    void load(const std::string& libso, const std::string& symbol)
    {
      this->libso  = libso;
      this->symbol = symbol;
 
      reload();
    }
    
          
    /**
     * Reload function from shared library.
     */
    void reload()
    {
      open(libso.c_str());
 
      get(symbol.c_str());
    }
 
 
    /**
     * Read function adaptor helper from input stream.
     *
     * The input format should be conform <tt><file name>[</tt>SEPARATOR<tt><symbol>]</tt>.
     *
     * \param  in                  input stream
     * \param  object              function adaptor helper
     * \return                     input stream
     */
    friend std::istream& operator>>(std::istream& in, JFunctionAdaptorHelper& object)
    {
      using namespace std;
 
      object.reset();
 
      string buffer;
 
      if (in >> buffer) {
      
        const string::size_type pos = buffer.rfind(SEPARATOR);
 
        if (pos != string::npos) {
 
          object.libso  = buffer.substr(0,pos);
          object.symbol = buffer.substr(pos+1);
 
        } else {
 
          object.libso  = buffer;
        }
 
        object.reload();
      }
      
      return in;
    }
    
          
    /**
     * Write function adaptor helper to output stream.
     *
     * \param  out                 output stream
     * \param  object              function adaptor helper
     * \return                     output stream
     */
    friend std::ostream& operator<<(std::ostream& out, const JFunctionAdaptorHelper& object)
    {
      return out;
    }
 
  protected:
    /**
     * Default constructor.
     */
    JFunctionAdaptorHelper() :
      handle  (NULL),
      function(NULL)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  pf                  pointer to function
     */
    JFunctionAdaptorHelper(__pF__ pf) :
      handle  (NULL),
      function(pf)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  libso               file name
     * \param  symbol              function name
     */
    JFunctionAdaptorHelper(const std::string& libso,
                           const std::string& symbol) :
      handle  (NULL),
      function(NULL)
    {
      this->load(libso, symbol);
    }
 
 
    /**
     * Copy constructor.
     *
     * \param  helper              helper
     */
    JFunctionAdaptorHelper(const JFunctionAdaptorHelper& helper) :
      handle  (helper.handle),
      function(helper.function),
      libso   (helper.libso),
      symbol  (helper.symbol)
    {
      if (is_open()) {
        attach(helper);
      }
    }
    
    void*       handle;
    __pF__      function;
    std::string libso;
    std::string symbol;
  };
 
  
  /**
   * Function adaptor.
   */
  template<class JReturn_t = void, class ...Args>
  struct JFunctionAdaptor :
    public JFunctionAdaptorHelper<JReturn_t (*)(Args...)>
  {
    /**
     * Type definition of method.
     */
    typedef JReturn_t (*pF)(Args...);
 
    
    /**
     * Default constructor.
     */
    JFunctionAdaptor() :
      JFunctionAdaptorHelper<pF>()
    {}
 
    
    /**
     * Constructor.
     *
     * \param  pf                  pointer to function
     */
    JFunctionAdaptor(pF pf) :
      JFunctionAdaptorHelper<pF>(pf)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  libso               file name
     * \param  symbol              function name
     */
    JFunctionAdaptor(const std::string& libso,
                     const std::string& symbol) :
      JFunctionAdaptorHelper<pF>(libso, symbol)
    {}
 
    
    /**
     * Function operation.
     *
     * \param  args                arguments
     * \return                     return value
     */
    JReturn_t operator()(Args... args) const
    {
      return this->function(args...);
    }
  };
}
 
#endif