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