engine.hpp

#ifndef HAVE_TOM_TSDB_ENGINE_HPP
#define HAVE_TOM_TSDB_ENGINE_HPP
 
#include <exception>
#include <map>
#include <vector>
#include <memory>
#include <tom-util/scalar.hpp>
#include <tom-util/module_loader.hpp>
#include <tom-util/logger.hpp>
#include <tom-tsdb/smart_pointers.hpp>
#include <boost/shared_ptr.hpp>
 
 
namespace tom { 
    class xml_doc;
}
 
namespace tom {
 
  namespace tsdb {
 
    class session;
    class provider;
    class screening_manager;
 
    class repository_meta_data
    {
    public:
        repository_meta_data( ) { }
        repository_meta_data(   const tom::String & name, 
                                const tom::String & module, 
                                const tom::String & descr ) :
            m_name( name.value() ), m_module( module.value() ), m_descr( descr ) { }
        virtual ~repository_meta_data( ) { }
 
        const tom::string &
        name() const { return m_name; }
 
        const tom::string &
        module() const { return m_module; }
 
        const tom::string &
        description() const { return m_descr; }
        
    protected:
        tom::string m_name;
        tom::string m_module;
        tom::string m_descr;
        
    };
    typedef std::vector< repository_meta_data > repository_meta_data_vec;
 
    class engine
    {
    public:
         
        static
        engine &
        Instance();
 
        static
        void
        use_screening_dbs( bool use ){ s_use_screening_dbs = use; }
 
        void
        update_screening_dbs();
 
        static
        bool
        use_screening_dbs() { return s_use_screening_dbs; }
 
        const repository_meta_data_vec &
        get_repositories_meta_data( ) const;
        
        // get the session for the default provider as spec'd in the env config file
        session_sptr
        get_session( );
 
        session_sptr
        get_session( const tom::observation &name );
 
        session_sptr
        get_session( const char *name )
        {
            return get_session( tom::String( name ) );
        }
 
        provider &
        get_provider( );
 
        provider &
        get_provider( const tom::observation &name );
 
        provider &
        get_provider( const char *name )
        {
            return get_provider( tom::String(name) );
        }
        static
        const char *
        version( );
 
    public: // leave this class public...it is helpful
        // customized module_loader for loading on demand req'd providers...
        class module_loader : public tom::module_loader
        {
        public:
            // load modules searching dir for modules
            module_loader( const tom::String dir );
            ~module_loader();
            
            // load module if necc, init, and return provider
            provider &
            get_provider( const tom::observation &name );
 
        private:
            // retrieve provider dynamic_library
            dynamic_library *
            get_provider_module( const tom::observation &name );
 
            typedef std::map< tom::string, boost::shared_ptr<provider> >        provider_map_t;
            typedef provider_map_t::const_iterator          const_iterator;
            typedef provider_map_t::iterator            iterator;
 
            provider_map_t m_providers;
        };
 
    protected:
 
        // get module name for provider
        tom::String
        get_module_name( const tom::observation &name );
 
        repository_meta_data_vec    m_repository_names;     // list of repositories
        tom::String                 m_default_provider;     // default backend if none chosen
        tom::String                 m_module_dir;           // directory to find provider modules
        tom::xml_doc *              m_config;               // ptr to tom::env config file
        tom::logger *               m_logger;
        module_loader *             m_module_loader;        // module loader to load provider modules...
        screening_manager *         m_screening_mgr { nullptr };
        static bool                 s_use_screening_dbs;
    private:
        engine( );
    public: // for pybind11 until i find a fix
        ~engine( );
    };
 
    class NoTimeSeriesDbDefinedException : public std::runtime_error
    {
    public:
        NoTimeSeriesDbDefinedException() throw () : 
        std::runtime_error( "No Time-Series Db Defined Exception" ){ };
    };
 
    class NoTimeSeriesDbDefaultProviderException : public std::runtime_error
    {
    public:
        NoTimeSeriesDbDefaultProviderException() throw () :
        std::runtime_error( "No Time-Series Db Default Provider Exception" ) { };
    };
 
    class ProviderModuleDirectoryUndefinedException : public std::runtime_error
    {
    public:
        ProviderModuleDirectoryUndefinedException() throw () :
        std::runtime_error( "Provider Module Directory Undefined Exception" ) { };
    };
    class ProviderModuleUndefinedException : public std::runtime_error
    {
    public:
        ProviderModuleUndefinedException() throw () :
        std::runtime_error( "Provider Module Undefined Exception" ) { };
    };
    class ProviderModuleInvalidException : public std::runtime_error
    {
    public:
        ProviderModuleInvalidException() throw () :
        std::runtime_error( "Provider Module Invalid Exception" ) { };
    };
    class ProviderModuleVersionException : public std::runtime_error
    {
    public:
        ProviderModuleVersionException() throw () :
        std::runtime_error( "Provider Module Version Exception" ) { };
    };
 
  } // end tsdb namespace
 
} // end tom namespace
 
#endif