module_loader.hpp

#ifndef HAVE_TOM__MODULE_LOADER_HPP
#define HAVE_TOM__MODULE_LOADER_HPP
 
#include <tom-util/defines.hpp>
#include <tom-util/exceptions.hpp>
#include <tom-util/scalar.hpp>
 
#include <string>
#include <map>
#include <vector>
#include <dirent.h>
 
namespace tom {
    
class TOM_UTIL_API dynamic_library
{
public:
    typedef void *  dynlib_t;
    
    dynamic_library ();
    dynamic_library (const tom::string & name);
    dynamic_library (const dynamic_library &);
    ~dynamic_library ();
    dynamic_library & operator= (const dynamic_library &);
 
    const tom::string & name () const
    {
        return m_name;
    }
 
    template < typename Rt > 
    Rt loadSymbol (const tom::string & name);
 
private:
    void *
    load_symbol( const tom::string & name );
    
    tom::string m_name;
    dynlib_t m_handle;
 
};
 
class TOM_UTIL_API module_loader
{
public:
    typedef std::vector < tom::string  > module_list;
    typedef module_list::const_iterator module_list_iterator;
 
    typedef std::map < tom::string, dynamic_library >module_map_type;
    typedef module_map_type::const_iterator const_iterator;
    typedef module_map_type::iterator iterator;
    typedef module_map_type::key_type key_type;
    typedef module_map_type::value_type value_type;
 
    module_loader (const tom::string & directory);
    virtual ~ module_loader ();
 
    unsigned int 
    count () const
    {
        return m_modules.size ();
    }
    const_iterator 
    begin () const
    {
        return m_modules.begin ();
    }
    iterator 
    begin ()
    {
        return m_modules.begin ();
    }
    const_iterator 
    end () const
    {
        return m_modules.end ();
    }
    iterator 
    end ()
    {
        return m_modules.end ();
    }
 
protected:
    virtual 
    dynamic_library * 
    load (const tom::string & module);
 
    virtual 
    void 
    unload (const tom::string & module);
 
    module_list_iterator 
    first_module () const
    {
        return m_module_list.begin ();
    }
    module_list_iterator 
    last_module () const
    {
        return m_module_list.end ();
    }
 
    tom::string m_directory;
    module_map_type m_modules;
    module_list m_module_list;
 
private:
    module_loader ();
 
    void 
    init ();
 
};
 
class TOM_UTIL_API standard_module_loader:public module_loader
{
public:
    standard_module_loader (const tom::string & directory);
    virtual ~ standard_module_loader ();
 
protected:
 
private:
 
};
 
template < typename Rt >
Rt 
dynamic_library::loadSymbol (const tom::string & name)
{
    return static_cast<Rt>( load_symbol(name) );
}
 
} // end tom namespace
 
#endif