connection.hpp

#ifndef HAVE_TOM_TSDB_CONNECTION_HPP
#define HAVE_TOM_TSDB_CONNECTION_HPP
 
#include <tom-util/scalar.hpp>
#include <tom-tsdb/smart_pointers.hpp>
#include <tom-tsdb/runtime_metrics.hpp>
 
#include <vector>
 
namespace tom {
 
  class observation;
  
  namespace tsdb {
 
    class TOM_UTIL_API session;
    class TOM_UTIL_API datastore;
    class TOM_UTIL_API access_mode;
 
    class TOM_UTIL_API datastore_meta_data
    {
    public:
        datastore_meta_data() { }
        datastore_meta_data( const tom::String &path ) : m_path(path) { }
        virtual ~datastore_meta_data() { }
        const tom::String &
        path() const { return m_path; }
        
    protected:
        tom::String m_path; 
    };
    typedef std::vector< datastore_meta_data >  datastore_meta_data_vec;
    
    class TOM_UTIL_API connection 
    {
    public:
        virtual ~connection() { }
 
        virtual
        const datastore_meta_data_vec &
        get_datastores_meta_data( ) const = 0;
        
        //datastore &
        tom::tsdb::datastore_sptr
        get_datastore( const char *name, const access_mode &mode );
        
        virtual 
        //datastore &
        tom::tsdb::datastore_sptr
        get_datastore( const observation &name, const access_mode &mode  ) = 0;
        
        void
        delete_datastore( const char *name );
        
        virtual
        void
        delete_datastore( const observation &name ) = 0;
        
        virtual
        tom::tsdb::session &
        get_session( ) = 0;
 
        const lock_metrics &
        get_lock_metrics() {
            populate_lock_metrics(m_lock_metrics);
            return m_lock_metrics;
        }
 
 
    protected:
        virtual
        void
        populate_lock_metrics( lock_metrics & lock_mets ) = 0;
 
        connection() { }
 
    private:
        tom::tsdb::lock_metrics m_lock_metrics;
    };
 
  } // end tsdb namespace
 
} // end tom namespace
 
#endif