sparse_series.hpp

#ifndef HAVE_TOM_TSDB_SPARSE_SERIES_HPP
#define HAVE_TOM_TSDB_SPARSE_SERIES_HPP
 
#include <tom-tsdb/time_series.hpp>
#include <tom-util/sparse_series.hpp>
 
namespace tom {
 
  namespace tsdb {
 
    using tom::calendars::date;
    
    /* Bogus inheritance structure share same ancestor...we need a slight redesign
     * i think...
     */
    class TOM_UTIL_API sparse_series :  public virtual tom::tsdb::time_series
    {
    public:
        virtual ~sparse_series() { }
        
        virtual
        void
        set_ignore_missing_values( bool b ) = 0;
        
        virtual
        bool
        get_ignore_missing_values( ) const = 0;
        
        virtual
        void
        set_ignore_same_values( bool b ) = 0;
        
        virtual
        bool
        get_ignore_same_values() const = 0;
        
        virtual
        void
        set_fill_forward( bool b ) = 0;
        
        virtual
        bool
        get_fill_forward( ) const = 0;
        
    };
    
    namespace collections {
 
        template <typename T, typename NATIVE_TYPE>
        class TOM_UTIL_API sparse_series : public tom::tsdb::sparse_series
        {
        public:
            typedef typename T::value_type      value_type;
    
            sparse_series( tom::calendars::calendar &cal, datastore &ds, const observation &name,
                        aggregation_type );
 
            sparse_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>
            sparse_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,
                        IteratorT begin, IteratorT end );
 
            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 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 true; }
 
            virtual
            void
            set_ignore_missing_values( bool b )
            { m_data.set_ignore_missing_values( b ); }
            
            virtual
            bool
            get_ignore_missing_values( ) const 
            { return m_data.get_ignore_missing_values( ); }
            
            virtual
            void
            set_ignore_same_values( bool b )
            { m_data.set_ignore_same_values( b ); }
            
            virtual
            bool
            get_ignore_same_values() const
            { return m_data.get_ignore_same_values( ); }
 
            virtual
            void
            set_fill_forward( bool b )
            { m_data.set_fill_forward( b ); }
            
            virtual
            bool
            get_fill_forward( ) const
            { return m_data.get_fill_forward( ); }
 
            virtual
            tom::calendars::date_int_type
            get_first_dirty_date_int() const
            { return m_data.get_first_date_int(); }
            
            virtual
            tom::calendars::date_int_type
            get_last_dirty_date_int() const
            { return m_data.get_last_date_int(); }
 
            // maybe this should throw because 
            // sparse series must be serialized, or accessed
            // with an iterator
            virtual 
            const void *
            get_raw_data() const { return NULL; }
        
        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;
            tom::collections::sparse_series_impl<T> m_data;
            
        };
 
        template <typename T, typename NATIVE_TYPE>
        sparse_series<T,NATIVE_TYPE>::sparse_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_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE>
        sparse_series<T,NATIVE_TYPE>::sparse_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_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE>
        template <typename IteratorT>
        sparse_series<T,NATIVE_TYPE>::sparse_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,
                                                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,begin,end)
        {   
            //m_name.to_upper();
        }
        template <typename T, typename NATIVE_TYPE> 
        aggregation_type 
        sparse_series<T,NATIVE_TYPE>::get_aggregation_type() const
        {
            return m_agg_type;          
        }
        template <typename T, typename NATIVE_TYPE> 
        void 
        sparse_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 &
        sparse_series<T,NATIVE_TYPE>::get_observation( const tom::calendars::date_int_type d ) const
        { return m_data.get_observation( d );    }
    
        template <typename T, typename NATIVE_TYPE> 
        const tom::observation &
        sparse_series<T,NATIVE_TYPE>::get_observation( const tom::calendars::date d ) const
        { return m_data.get_observation( d );    }
    
        template <typename T, typename NATIVE_TYPE>
        void
        sparse_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date_int_type d, const tom::observation & val )
        { 
            m_data.set_observation( d, val );    
        }
    
        template <typename T, typename NATIVE_TYPE>
        void
        sparse_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date_int_type d, const tom::Date & val )
        {   
            m_data.set_observation( d, val );    
        }
 
        template <typename T, typename NATIVE_TYPE>
        void
        sparse_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date d, const tom::Date & val )
        { 
            m_data.set_observation( d, val );    
        }
 
        template <typename T, typename NATIVE_TYPE>
        void
        sparse_series<T,NATIVE_TYPE>::set_observation( const tom::calendars::date d, const tom::observation & val )
        { 
            m_data.set_observation( d, val );    
        }
 
        template <typename T, typename NATIVE_TYPE>
            const tom::observation & 
        sparse_series<T,NATIVE_TYPE>::operator[ ](  const tom::calendars::date_int_type d ) const   
        { return m_data[ d ];    }
    
        template <typename T, typename NATIVE_TYPE>
        tom::observation & 
        sparse_series<T,NATIVE_TYPE>::operator[ ](  const tom::calendars::date_int_type d   )   
        { return m_data[ d ]; }
    
        template <typename T, typename NATIVE_TYPE>
            const tom::observation & 
        sparse_series<T,NATIVE_TYPE>::operator[ ] ( const tom::calendars::date d ) const    
        { return m_data[ d ];    }
    
        template <typename T, typename NATIVE_TYPE>
        tom::observation & 
        sparse_series<T,NATIVE_TYPE>::operator[ ] ( const tom::calendars::date d    )   
            { return m_data[ d ];   }
    
    
        template <typename T, typename NATIVE_TYPE>
        std::ostream &
        sparse_series<T,NATIVE_TYPE>::print( std::ostream &os ) const
        { return m_data.print( os ); }
    
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::calendar & 
        sparse_series<T,NATIVE_TYPE>::get_calendar( )  const
        { return m_data.get_calendar();  }
 
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type 
        sparse_series<T,NATIVE_TYPE>::get_first_date_int() const
        {
            return m_data.get_first_date_int();
        }
        
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::calendars::date_int_type 
        sparse_series<T,NATIVE_TYPE>::get_last_date_int() const
        {
            return m_data.get_last_date_int();
        }
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::collections::time_series_iterator &
        sparse_series<T,NATIVE_TYPE>::begin() const
        {
            return m_data.begin();  
        }
                
        //virtual 
        template <typename T, typename NATIVE_TYPE>
        tom::collections::time_series_iterator &
        sparse_series<T,NATIVE_TYPE>::end() const
        {
            return m_data.end();    
        }
        
    } // end collections namespace 
        
  } // end tsdb namespace
 
} // end tom namespace
 
#endif /*HAVE_TOM_TSDB_SPARSE_SERIES_HPP*/