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/JNullType.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;
  using JLANG::JNullType;
 
  
  /**
   * Auxiliary base class for function adaptor.
   */
  template<class pF>
  struct JFunctionAdaptorHelper :
    JSharedCounter
  {
    /**
     * Virtual destructor.
     */
    virtual ~JFunctionAdaptorHelper()
    {
      if (detach()) {
        close();
      }
    }
    
 
    /**
     * Check validity.
     *
     * \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;
    }
 
    
    /**
     * Open file.
     *
     * \param  file_name           file name
     */
    void open(const char* file_name)
    {
      reset();
      
      handle = dlopen(file_name, RTLD_LAZY);
 
      if (!handle) {
        THROW(JLANG::JFileOpenException, dlerror());
      }
 
      initialise();
    }
 
 
    /**
     * Close file.
     *
     * Note that the file should remain open as long as the library method is used.
     */
    void close()
    {
      if (handle != NULL) {
        dlclose(handle);
      }
 
      handle = NULL;
    }
    
          
    /**
     * Read function adaptor helper from input stream.
     *
     * \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 file_name, function_name;
      
      if (in >> file_name >> function_name) {
 
        object.open(file_name.c_str());
 
        object.get(function_name.c_str());
      }
      
      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)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  helper              helper
     */
    JFunctionAdaptorHelper(const JFunctionAdaptorHelper& helper) :
      handle  (helper.handle),
      function(helper.function)
    {
      attach(helper);
    }
 
    
    /**
     * Constructor.
     *
     * \param  pf                  pointer to function
     */
    JFunctionAdaptorHelper(pF pf) :
      handle  (NULL),
      function(pf)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  file_name           file name
     * \param  function_name       function name
     */
    JFunctionAdaptorHelper(const char* file_name,
                           const char* function_name) :
      handle  (NULL),
      function(NULL)
    {
      this->open(file_name);
 
      this->get(function_name);
    }
 
 
    /**
     * Get function with given name according to specific protocol.
     *
     * \param  function_name       function name
     */
    void get(const char* function_name)
    {
      function = NULL;
 
      if (handle != NULL) {
      
        dlerror();  // reset errors
      
        function = (pF) dlsym(handle, function_name);
        
        const char* error = dlerror();
        
        if (error != NULL) {
          THROW(JLANG::JFileReadException, error);
        }
        
      } else {
 
        THROW(JLANG::JFileReadException, "Invalid handle.");
      }
    }
    
    void*  handle;
    pF     function;
  };
 
  
  /**
   * Function adaptor.
   */
  template<class JReturn_t = void, class JFirst_t = void, class JSecond_t = void>
  struct JFunctionAdaptor;
 
  
  /**
   * Function adaptor for function with one argument.
   */
  template<class JReturn_t, class JFirst_t>
  struct JFunctionAdaptor<JReturn_t, JFirst_t, void> :
    public JFunctionAdaptorHelper<JReturn_t (*)(JFirst_t)>
  {
    /**
     * Type definition of method.
     */
    typedef JReturn_t (*pF)(JFirst_t);
 
    
    /**
     * Default constructor.
     */
    JFunctionAdaptor() :
      JFunctionAdaptorHelper<pF>()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  adaptor             adaptor
     */
    JFunctionAdaptor(const JFunctionAdaptor& adaptor) :
      JFunctionAdaptorHelper<pF>(adaptor)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  pf                  pointer to function
     */
    JFunctionAdaptor(pF pf) :
      JFunctionAdaptorHelper<pF>(pf)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  file_name           file name
     * \param  function_name       function name
     */
    JFunctionAdaptor(const char* file_name,
                     const char* function_name) :
      JFunctionAdaptorHelper<pF>(file_name, function_name)
    {}
 
    
    /**
     * Function operation.
     *
     * \param  first            first  argument
     * \return                  return value
     */
    JReturn_t operator()(JFirst_t first) const
    {
      return this->function(first);
    }
  };
 
  
  /**
   * Function adaptor for function with two arguments.
   */
  template<class JReturn_t, class JFirst_t, class JSecond_t>
  struct JFunctionAdaptor :
    public JFunctionAdaptorHelper<JReturn_t (*)(JFirst_t, JSecond_t)>
  {
    /**
     * Type definition of method.
     */
    typedef JReturn_t (*pF)(JFirst_t, JSecond_t);
 
    
    /**
     * Default constructor.
     */
    JFunctionAdaptor() :
      JFunctionAdaptorHelper<pF>()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  adaptor             adaptor
     */
    JFunctionAdaptor(const JFunctionAdaptor& adaptor) :
      JFunctionAdaptorHelper<pF>(adaptor)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  pf                  pointer to function
     */
    JFunctionAdaptor(pF pf) :
      JFunctionAdaptorHelper<pF>(pf)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  file_name           file name
     * \param  function_name       function name
     */
    JFunctionAdaptor(const char* file_name,
                     const char* function_name) :
      JFunctionAdaptorHelper<pF>(file_name, function_name)
    {}
 
 
    /**
     * Function operation.
     *
     * \param  first               first  argument
     * \param  second              second argument
     * \return                     return value
     */
    JReturn_t operator()(JFirst_t first, JSecond_t second) const
    {
      return this->function(first, second);
    }
  };
}
 
#endif