time_series.hpp

#ifndef HAVE_TOM_TSDB_TIME_SERIES_HPP
#define HAVE_TOM_TSDB_TIME_SERIES_HPP
 
#include <tom-util/time_series.hpp>
#include <tom-tsdb/types.hpp>
#include <map>
#include <set>
 
namespace tom {
 
  namespace tsdb {
        
    class datastore;
    class native_calendar_type;
    
    class aggregation_type
    {
    public:
        static
        aggregation_type 
        factory( unsigned short int v )
        {
            if ( ( v >= 1 && v <= 4 ) || 
                 ( v>=7 && v <= 8 ) )
                return aggregation_type(v);
            else
                //throw std::runtime_error( "Invalid aggregation_type." );
                return aggregation_type(1);
        }
        static
        aggregation_type 
        begin() { return aggregation_type(1); }
 
        static
        aggregation_type 
        end() { return aggregation_type(2); }
 
        static
        aggregation_type 
        averaged() { return aggregation_type(3); }
 
        static
        aggregation_type 
        summed() { return aggregation_type(4); }
 
        static
        aggregation_type 
        high() { return aggregation_type(7); }
 
        static
        aggregation_type 
        low() { return aggregation_type(8); }
        
        unsigned short int
        value() const { return m_value; }
        
        const char *
        name() const 
        {
            switch( value() )
            {
            case 1:
                return "Begin";
            case 2:
                return "End";
            case 3:
                return "Averaged";
            case 4:
                return "Summed";
            case 7:
                return "High";
            case 8:
                return "Low";
            default:
                return "Unknown";
            }
        }
        bool
        operator==( const aggregation_type &rhs )
        {  
            if ( rhs.value() == m_value )
                return true;
                
            return false;   
        }
        bool
        operator!=( const aggregation_type &rhs )
        {
            return ! ( *this == rhs );  
        }
    private:    
        aggregation_type();
        aggregation_type( unsigned short int v ) :
            m_value( v ) { }
        unsigned short int m_value;
    };
    class alias_set :
                public std::set<tom::string, std::less<tom::string> >
    {
    public:
        typedef std::set<
                            tom::string, 
                            std::less<tom::string>
                            >           
                                                parent_type;
        typedef parent_type::iterator           iterator;
        typedef parent_type::const_iterator const_iterator;
        
        alias_set() : m_changed(false) { }
        
        template <typename IteratorT>
        alias_set( IteratorT begin, IteratorT end ) : 
            parent_type( begin, end ), m_changed(false) { }
        
        alias_set( const alias_set &rhs ) : 
                    parent_type(rhs), m_changed( rhs.m_changed ) { }
            
        alias_set &
        operator=( const alias_set &rhs )
        {
            clear();
            insert( rhs.begin(), rhs.end() );
            m_changed = rhs.m_changed;
            return *this;
        }
        bool
        operator==( const alias_set &rhs )
        {
            // same size & size > 0
            if ( size() > 0 && size() == rhs.size() )
                return std::equal( begin(), end(), rhs.begin() );
 
            // different sizes must be different
            else if ( size() != rhs.size() )
                return false;
            
            // both must be empty sets to reach here
            return true;
        }
        bool
        operator!=( const alias_set &rhs )
        {
            return ! ( *this == rhs );  
        }
        virtual ~alias_set() { }
        
        // allow no non-const iterators, or someone could
        // change an alias value, and the persistence side
        // of things wouldn't know.  This would be confusing
        // to users...
        const_iterator 
        begin() const { return this->parent_type::begin(); }
 
        const_iterator 
        end() const { return this->parent_type::end(); }
        
        bool
        add( const char * );
        
        bool
        add( const tom::observation & );
        
        bool
        add( const tom::string & );
        
        bool
        remove( const char * );
 
        bool
        remove( const tom::observation & );
 
        bool
        remove( const tom::string & );
        
        bool
        changed( ) const;
        
        void
        clear( ) { m_changed = true; this->parent_type::clear(); }
        
    protected:
        bool m_changed;
 
    };
 
    class TOM_UTIL_API time_series : public tom::collections::time_series
    {
    public:
 
        // struct to keep track of attributes for time-series that
        // don't yet exist
        typedef std::map< tom::string, tom::string > attribute_map_t;
        typedef std::set< tom::string > attribute_set_t;
        
        // callback function to populate time-series w/ data 
        // This may be used by implementations of time-series
        // (such as time_series_impl<> below )
        // to allow back-ends to register callbacks for
        // lazy eval when getting time-series
        typedef bool (tom::tsdb::datastore::*populate_data_func)(   
                                            tom::collections::time_series & ts,
                                            const tom::string & name,
                                            tom::tsdb::native_data_type data_t, 
                                            tom::calendars::calendar & cal,
                                            tom::calendars::date_int_type from, 
                                            tom::calendars::date_int_type to 
                                            );
 
        // this is useful mainly for datastore implementations that
        // need to update create/modify time-stamps when saving time_series
        friend class ::tom::tsdb::datastore;
        
        time_series() : m_alias_set_touched(false) { }
        virtual ~time_series() { }
        virtual const tom::string &get_name() const = 0;
        
        virtual tom::tsdb::datastore & get_datastore() const = 0;
        virtual const values::data_type & get_data_type() const = 0;
        virtual aggregation_type get_aggregation_type() const = 0;
        virtual void set_aggregation_type( aggregation_type ) = 0;
        virtual void save( bool overwrite = false );
        virtual alias_set &get_alias_set();
        virtual const alias_set &get_alias_set() const;
 
        // this is for internal use...
        // The purpose is to return a pointer to the beginning 
        // of the data-space for time-series to avoid serialization
        // or other reasons (optimized algos?)...
        // This may(should) go away in the future so
        // consider it deprecated since the beginning of time!
        // you've been warned.
        virtual 
        const void *
        get_raw_data() const = 0;
                
        virtual 
        const tom::calendars::date_time &
        get_create_date_time() const = 0;
 
        virtual 
        const tom::calendars::date_time &
        get_modify_date_time() const = 0;
 
        bool
        operator==( const time_series &rhs ) const;
        
        bool
        operator!=( const time_series &rhs ) const;
        
        bool
        alias_set_touched() const;
        
        size_t
        get_dropped_aliases( alias_set &dropped ) const;
        
        size_t
        get_added_aliases( alias_set &added ) const;
 
        const tom::String &
        get_attribute( const char *att_name, bool check_datastore = true ) const
          { return get_attribute( tom::String( att_name ), check_datastore ); }
                
        const tom::String &
        get_attribute( const tom::observation &att_name, bool check_datastore = true ) const
          { return get_attribute( tom::String( att_name ) ); }
 
        const tom::String &
        get_attribute( const tom::String &att_name, bool check_datastore = true ) const;
        
        void
        set_attribute(  const char *att_name, 
                        const char *att_value )
          { return set_attribute( tom::String( att_name ), tom::String( att_value ) ); }
                
        void
        set_attribute(  const tom::observation &att_name,
                        const tom::observation &att_value )
          { return set_attribute( tom::String( att_name ), tom::String( att_value ) ); }
 
        void
        set_attribute( const tom::String &att_name, 
                        const tom::String &att_value );
 
        virtual
        bool
        is_sparse_series() const = 0;
        
        virtual
        tom::calendars::date_int_type
        get_first_dirty_date_int() const = 0;
        
        virtual
        tom::calendars::date_int_type
        get_last_dirty_date_int() const = 0;
 
         virtual
         bool
         exists() const;
         
         virtual
         const attribute_set_t &
         get_changed_attribute_names() const { return m_changed_attributes; }
         
    protected:
        bool
        populate_alias_set() const;
 
        virtual 
        void
        set_create_date_time(const tom::calendars::date_time &) = 0;
 
        virtual 
        void
        set_modify_date_time(const tom::calendars::date_time &) = 0;
        
        // mutable because we lazy init alias_sets
        // and a const method may need to populate these
        mutable bool        m_alias_set_touched;
        mutable alias_set   m_alias_set;        
        mutable alias_set   m_original_alias_set;
        mutable attribute_map_t     m_attributes;
        attribute_set_t     m_changed_attributes;
    };
    namespace collections {
        
        template <typename T, typename NATIVE_TYPE>
        class TOM_UTIL_API time_series : public tom::tsdb::time_series
        {
        public:
            typedef typename T::value_type      value_type;
    
            time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type );
 
            time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type, const tom::calendars::date_time &created,
                        const tom::calendars::date_time &modified );
 
            template <typename IteratorT>
            time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type agg_t, const tom::calendars::date_time &created,
                        const tom::calendars::date_time &modified,
                        tom::calendars::date_int_type start, 
                        IteratorT begin, IteratorT end );
 
 
            // create it and register a populate data call back
            // that is, we can create the ts w/ out reading the real data
            // but as soon as someone calls the get_observation() family of 
            // calls, the populate_data_func is called to populate the timeseries
            time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type agg_t, const tom::calendars::date_time &created,
                        const tom::calendars::date_time &modified,
                        tom::calendars::date_int_type start, 
                        tom::calendars::date_int_type end,
                        populate_data_func );
 
            virtual datastore & get_datastore() const { return m_ds; }
            virtual const values::data_type & get_data_type() const { return NATIVE_TYPE::Instance(); }
            virtual aggregation_type get_aggregation_type() const;
            virtual void set_aggregation_type( aggregation_type );
            
            virtual const tom::string &get_name() const{ return m_name; }
 
            virtual 
            tom::collections::time_series_iterator &
            begin() const;
            
            virtual 
            tom::collections::time_series_iterator &
            end() const;
 
            virtual const tom::observation &get_observation( const tom::calendars::date_int_type d ) const;
            virtual const tom::observation &get_observation( const tom::calendars::date d ) const;
            virtual void set_observation( const tom::calendars::date_int_type d, const tom::observation & val );
            virtual void set_observation( const tom::calendars::date d, const tom::observation & val );
            virtual void set_observation( tom::calendars::date_int_type d, const tom::Date & );
            virtual void set_observation( tom::calendars::date d, const tom::Date & );
            virtual const tom::observation & operator[ ](  const tom::calendars::date_int_type d ) const;
            virtual tom::observation & operator[ ](  const tom::calendars::date_int_type d );
            virtual const tom::observation & operator[ ] ( const tom::calendars::date d ) const;
            virtual tom::observation & operator[ ] ( const tom::calendars::date d );
            virtual tom::calendars::date_int_type get_first_date_int() const;
            virtual tom::calendars::date_int_type get_last_date_int() const;
 
            virtual
            tom::calendars::date_int_type
            get_first_dirty_date_int() const;
            
            virtual
            tom::calendars::date_int_type
            get_last_dirty_date_int() const;
 
 
            virtual std::ostream &print( std::ostream & ) const;
            virtual tom::calendars::calendar & get_calendar( )  const;
 
            virtual 
            const tom::calendars::date_time &
            get_create_date_time() const { return m_create_date_time; }
 
            virtual 
            const tom::calendars::date_time &
            get_modify_date_time() const { return m_modify_date_time; }
 
            virtual
            bool
            is_sparse_series() const{ return false; }
 
            virtual 
            const void *
            get_raw_data() const 
            {
                // force lazy init if needed
                if ( m_populate_data_func != NULL ) 
                    get_observation( get_last_date_int() );
                return m_data.data(); 
            }
 
        protected:
            virtual 
            void
            set_create_date_time(const tom::calendars::date_time &d)
            {
                m_create_date_time = d;
            }
            virtual 
            void
            set_modify_date_time(const tom::calendars::date_time &d)
            {
                m_modify_date_time = d;
            }
 
            aggregation_type                        m_agg_type;
            datastore &                             m_ds;
            tom::string                             m_name;
            tom::calendars::date_time               m_create_date_time;
            tom::calendars::date_time               m_modify_date_time;
            
            // must be mutable if get_observation() const
            // might trigger callback and modification of m_data
            mutable tom::collections::time_series_impl<T>   m_data;
 
            tom::calendars::date_int_type           m_l_first_date_int;
            tom::calendars::date_int_type           m_l_last_date_int;
            tom::calendars::date_int_type           m_first_dirty_date_int;
            tom::calendars::date_int_type           m_last_dirty_date_int;
            
            mutable populate_data_func              m_populate_data_func;
                
        };
 
        template <typename T, typename NATIVE_TYPE>
        time_series<T,NATIVE_TYPE>::time_series( tom::calendars::calendar &cal, datastore &ds, 
                                const observation &name, aggregation_type agg_t ) :
            m_agg_type(agg_t), m_ds(ds), m_name( String( name ).value() ), m_data(cal),
            m_l_first_date_int( 0 ), m_l_last_date_int(0),
            m_first_dirty_date_int( 0 ), m_last_dirty_date_int( 0 ),
            m_populate_data_func(0)
        {
            //m_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE>
        time_series<T,NATIVE_TYPE>::time_series( tom::calendars::calendar &cal, datastore &ds, 
                                const observation &name, aggregation_type agg_t,
                                const tom::calendars::date_time &created,
                                const tom::calendars::date_time &modified ) :
            m_agg_type(agg_t), m_ds(ds), m_name( String( name ).value() ), 
            m_create_date_time( created ), m_modify_date_time( modified ), m_data(cal),
            m_l_first_date_int( 0 ), m_l_last_date_int(0),
            m_first_dirty_date_int( 0 ), m_last_dirty_date_int( 0 ),
            m_populate_data_func(0)
        {
            //m_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE>
        template <typename IteratorT>
        time_series<T,NATIVE_TYPE>::time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                                                aggregation_type agg_t, 
                                                const tom::calendars::date_time &created,
                                                const tom::calendars::date_time &modified,
                                                tom::calendars::date_int_type start,
                                                IteratorT begin, IteratorT end ) :
            m_agg_type(agg_t), m_ds(ds), m_name( String(name).value() ), m_create_date_time( created ), 
            m_modify_date_time( modified ), m_data(cal,cal(start), begin,end),
            m_l_first_date_int( 0 ), m_l_last_date_int(0),
            m_first_dirty_date_int( 0 ), m_last_dirty_date_int( 0 ),
            m_populate_data_func(0)
        {   
            //m_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE>
        time_series<T,NATIVE_TYPE>::time_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type agg_t, const tom::calendars::date_time &created,
                        const tom::calendars::date_time &modified,
                        tom::calendars::date_int_type start, 
                        tom::calendars::date_int_type end,
                        populate_data_func callback ) :
            m_agg_type(agg_t), m_ds(ds), m_name( String(name).value() ), m_create_date_time( created ), 
            m_modify_date_time( modified ), m_data(cal),
            m_l_first_date_int( start ), m_l_last_date_int(end),
            m_first_dirty_date_int( 0 ), m_last_dirty_date_int( 0 ),
            m_populate_data_func( callback )
        {   
            //m_name.to_upper();
        }
                        
 
        template <typename T, typename NATIVE_TYPE> 
        aggregation_type 
        time_series<T,NATIVE_TYPE>::get_aggregation_type() const
        {
            return m_agg_type;          
        }
        template <typename T, typename NATIVE_TYPE> 
        void 
        time_series<T,NATIVE_TYPE>::set_aggregation_type( aggregation_type agg_t )
        {
            m_agg_type = agg_t;
        }
 
        template <typename T, typename NATIVE_TYPE> 
        const tom::observation &
        time_series<T,NATIVE_TYPE>::get_observation( const tom::calendars::date_int_type d ) const
        {
            if ( m_populate_data_func != NULL )
            {
                // call callback function
                if ( (m_ds.*m_populate_data_func)( m_data, m_name,
                                            tom::tsdb::native_data_type::factory( NATIVE_TYPE::Instance().id() ),
                                            get_calendar(),
                                            static_cast<tom::calendars::date_int_type> (m_l_first_date_int),
                                            static_cast<tom::calendars::date_int_type>(m_l_last_date_int )) )                                       
                    m_populate_data_func = NULL;
            }
            return m_data.get_observation( d );  
        }
    
        template <typename T, typename NATIVE_TYPE> 
        const tom::observation &
        time_series<T,NATIVE_TYPE>::get_observation( const tom::calendars::date d ) const
        { 
            return this->get_observation( get_calendar()( d ) ); //m_data.get_observation( d );  
        }
    
        template <typename T, typename NATIVE_TYPE>
        void
        time_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date_int_type d, const tom::observation & val )
        {
            if ( m_first_dirty_date_int != 0 && d < m_first_dirty_date_int )
                m_first_dirty_date_int = d;
 
            if ( d > m_last_dirty_date_int )
                m_last_dirty_date_int = d;
                
            m_data.set_observation( d, val );    
        }
        template <typename T, typename NATIVE_TYPE>
        void 
        time_series<T,NATIVE_TYPE>::set_observation( tom::calendars::date_int_type d, const tom::Date &v )
        {
            if ( m_first_dirty_date_int != 0 && d < m_first_dirty_date_int )
                m_first_dirty_date_int = d;
 
            if ( d > m_last_dirty_date_int )
                m_last_dirty_date_int = d;
                
            m_data.set_observation( d, v );         
        }
        template <typename T, typename NATIVE_TYPE>
        void 
        time_series<T,NATIVE_TYPE>::set_observation( tom::calendars::date d, const tom::Date &v )
        {
            set_observation( get_calendar()(d), v );    
        }
    
        template <typename T, typename NATIVE_TYPE>
        void
        time_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date d, const tom::observation & val )
        { 
            this->set_observation( get_calendar()( d ), val ); //m_data.set_observation( d, val );   
        }
    
        template <typename T, typename NATIVE_TYPE>
        const tom::observation & 
        time_series<T,NATIVE_TYPE>::operator[ ](  const tom::calendars::date_int_type d ) const 
        { 
            return this->get_observation(d); //m_data[ d ];  
        }
        //TODO: this is a memory leak...change it!  
        template <typename T, typename NATIVE_TYPE>
        tom::observation & 
        time_series<T,NATIVE_TYPE>::operator[ ](  const tom::calendars::date_int_type d     )   
        { 
            return this->get_observation(d).clone(); //m_data[ d ]; 
        }
    
        template <typename T, typename NATIVE_TYPE>
        const tom::observation & 
        time_series<T,NATIVE_TYPE>::operator[ ] ( const tom::calendars::date d ) const  
        { 
            return this->get_observation(d); //m_data[ d ];  
        }
    
        template <typename T, typename NATIVE_TYPE>
        tom::observation & 
        time_series<T,NATIVE_TYPE>::operator[ ] ( const tom::calendars::date d  )   
        { 
            return this->get_observation(d).clone(); //m_data[ d ];     
        }
    
    
        template <typename T, typename NATIVE_TYPE>
        std::ostream &
        time_series<T,NATIVE_TYPE>::print( std::ostream &os ) const
        { 
            // force lazy init if needed
            if ( m_populate_data_func != NULL ) 
                get_observation( get_last_date_int() );
 
            return m_data.print( os ); 
        }
    
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::calendar & 
        time_series<T,NATIVE_TYPE>::get_calendar( )  const
        { return m_data.get_calendar();  }
 
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type 
        time_series<T,NATIVE_TYPE>::get_first_date_int() const
        {
            tom::calendars::date_int_type fd = m_data.get_first_date_int();
 
            if ( m_populate_data_func == NULL ) // m_data holds all data
                return fd;
 
            else // m_data only holds new data
            {
                if ( m_l_first_date_int != 0 && fd != 0 )
                    return m_l_first_date_int < fd ? m_l_first_date_int : fd;
                else if ( m_l_first_date_int != 0 )
                    return m_l_first_date_int;  
                else
                    return fd;
            }
        }
        
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type 
        time_series<T,NATIVE_TYPE>::get_last_date_int() const
        {
            tom::calendars::date_int_type ld = m_data.get_last_date_int();
            if ( m_populate_data_func == NULL ) // m_data holds all data
                return ld;
 
            else // m_data only holds new data
            {
                if ( m_l_last_date_int != 0 && m_l_last_date_int > ld )
                    return m_l_last_date_int; // no data added after original last date
 
                else
                    return ld;
            }
        }
        //virtual
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type
        time_series<T,NATIVE_TYPE>::get_first_dirty_date_int() const
        {
            return m_first_dirty_date_int;
        }
            
        //virtual
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type
        time_series<T,NATIVE_TYPE>::get_last_dirty_date_int() const
        {
            return m_last_dirty_date_int;           
        }
 
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::collections::time_series_iterator &
        time_series<T,NATIVE_TYPE>::begin() const
        {
            return m_data.begin();  
        }
                
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::collections::time_series_iterator &
        time_series<T,NATIVE_TYPE>::end() const
        {
            return m_data.end();    
        }
        
    } // end collections namespace 
 
  } // end tsdb namespace
 
} // end tom namespace
 
    TOM_UTIL_API    
    inline
    std::ostream &
    operator<<( std::ostream &os, const tom::tsdb::time_series &ts )
    {
        return ts.print( os );  
    }
 
#endif