time_scale_converters.hpp

/***************************************************************************
 *                      time_scale_converters.hpp
 *
 *  Sun Jul 18 13:49:19 2004
 *  Copyright   2004    Tom McCubbin
 *  tmccubbin@tomsolutions.com
 ****************************************************************************/
#ifndef HAVE_TOM__TIME_SCALE_CONVERTERS_HPP
#define HAVE_TOM__TIME_SCALE_CONVERTERS_HPP
 
#include <tom-util/defines.hpp>
#include <tom-util/calendar.hpp>
#include <tom-util/scalar.hpp>
#include <tom-util/time_series.hpp>
 
namespace tom {
    
namespace calendars {   
 
class TOM_UTIL_API date_period_converter
{
public:
    date_period_converter( calendar &from, calendar &to )
        : m_from(from), m_to(to) { }
 
    date_int_type next( date_int_type start );
    date_int_type target( date_int_type start ) { return m_to( m_from( start ) ); }
 
protected:
    calendar &m_from;
    calendar &m_to;
};
 
// date_int_type
// date_period_converter::next( date_int_type start )
// {
//  date from_start = m_from( start ); // get end date of start
//  date to_end = m_to( m_to( from_start ) ); // convert to 'to' cal end date
//  date from_end = m_from( m_from( to_end ) ); // and back to from cal date
//  // should point to one PAST the last,
//  // aka: a sentry value, or 
//  // aka: consistent w/ STL end();
//  if ( from_end <= to_end )
//      from_end += date_duration(1);
//  return m_from( from_end );  
// }
 
class aggregator 
{
public:
 
    virtual ~aggregator() { }
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const = 0;
 
};
 
class aggregate_end : public aggregator
{
public:
 
    aggregate_end( bool ignore_missing = true );
    virtual ~aggregate_end();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
 
class aggregate_begin : public aggregator
{
public:
 
    aggregate_begin( bool ignore_missing = true );
    virtual ~aggregate_begin();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
class aggregate_sum : public aggregator
{
public:
 
    aggregate_sum( bool ignore_missing = true );
    virtual ~aggregate_sum();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
class aggregate_avg : public aggregator
{
public:
 
    aggregate_avg( bool ignore_missing = true );
    virtual ~aggregate_avg();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
class aggregate_max : public aggregator
{
public:
 
    aggregate_max( bool ignore_missing = true );
    virtual ~aggregate_max();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
class aggregate_min : public aggregator
{
public:
 
    aggregate_min( bool ignore_missing = true );
    virtual ~aggregate_min();
 
    virtual
    const tom::observation &
    operator()( const date_period &d, const tom::collections::time_series &ts ) const;
 
protected:
    bool m_ignore_missing;
 
};
class time_scale_adapter 
{
public:
 
    class iterator;
    friend class iterator;
 
    class iterator
    {
    public:
        explicit iterator( time_scale_adapter &adapter, date_int_type date );
 
        bool
        operator==( const iterator &iter );
 
        bool
        operator!=( const iterator &iter );
 
        iterator &
        operator++();
 
        iterator
        operator++(int);
 
        observation &
        operator*() const;
 
        const observation *
        operator->() const;
 
        date
        get_date();
 
        date_int_type
        get_date_int();
 
    private:
        iterator();
 
        time_scale_adapter &m_adapter;
        date_int_type   m_date;
    };
    time_scale_adapter( const tom::collections::time_series &ts, 
                        calendar & target_cal, const aggregator &agg );
    time_scale_adapter( calendar & target_cal, const aggregator &agg );
    time_scale_adapter( const aggregator &agg );
 
    iterator
    begin();
 
    iterator
    end();
 
    void
    set_calendar( calendar &cal );
 
    calendar &
    get_calendar( ) const;
 
    const aggregator &
    get_aggregator( ) const;
 
    void
    set_first_date( date d );
 
    date_int_type
    get_first_date_int() const;
 
    date
    get_first_date() const;
 
    void
    set_last_date( date d );
 
    date_int_type
    get_last_date_int() const;
 
    date
    get_last_date() const;
 
    void
    set_time_series( const tom::collections::time_series & ts );
 
    const tom::collections::time_series &
    get_time_series( ) const;
 
private:
    const tom::collections::time_series *   m_ts;
    calendar &                              m_target_cal;
    const aggregator &                      m_aggregator;
 
    date_int_type                           m_begin;
    date_int_type                           m_end;
};
 
template <class aggregator_type, bool ignore_missing = true>
class time_scale_adapter_impl
{
public:
 
    class iterator;
    friend class iterator;
 
    class iterator
    {
    public:
        explicit iterator( time_scale_adapter_impl &adapter, date_int_type date ) :
            m_adapter( adapter ), m_date( date ) 
        { }
 
        bool
        operator==( const iterator &iter )
        {
            if ( m_date == iter.m_date  && 
                 m_adapter.m_ts == iter.m_adapter.m_ts )
                return true;
 
            return false;
        }
        bool
        operator!=( const iterator &iter )
        {
            return !( *this == iter );
        }
        iterator &
        operator++()
        {
            ++m_date;
            return *this;
        }
        iterator
        operator++(int)
        {
            date_int_type tmp = m_date;
            ++m_date;
            return iterator( m_adapter, tmp );
        }
        observation &
        operator*() const
        {
            if ( m_adapter.m_ts == NULL )
                throw std::runtime_error( "No time_series set for time_scale_adapter!" );
            
            return m_adapter.m_aggregator( m_adapter.m_target_cal.get_date_period( m_date ), *m_adapter.m_ts ).clone();
        }
        const observation *
        operator->() const
        {
            if ( m_adapter.m_ts == NULL )
                throw std::runtime_error( "No time_series set for time_scale_adapter!" );
            
            return & m_adapter.m_aggregator( m_adapter.m_target_cal.get_date_period( m_date ), *m_adapter.m_ts );
        }
        date
        get_date()
        {
            return m_adapter.get_calendar()( m_date );
        }
        date_int_type
        get_date_int()
        {
            return m_date;
        }
    private:
        iterator();
 
        time_scale_adapter_impl &m_adapter;
        date_int_type   m_date;
    };
    time_scale_adapter_impl( const tom::collections::time_series &ts, 
                            calendar & target_cal ) :
        m_ts( &ts ), m_target_cal( target_cal ), m_aggregator( ignore_missing )
    {
        m_begin = m_target_cal( m_ts->get_first_date() );
        m_end = m_target_cal( m_ts->get_last_date() ) + 1;
    }
    time_scale_adapter_impl( calendar & target_cal ) :
        m_ts( NULL ), m_target_cal( target_cal ), m_aggregator( ignore_missing )
    {
        m_begin = 0;
        m_end = 0;
    }
    time_scale_adapter_impl( ) :
        m_ts( NULL ), m_target_cal ( business_calendar::Instance() ), 
        m_aggregator( ignore_missing )
    {
        m_begin = 0;
        m_end = 0;
    }
    iterator
    begin() 
    {
        return iterator( *this, m_begin );
    }
    iterator
    end()
    {
        return iterator( *this, m_end );
    }
    void
    set_calendar( calendar &cal )
    {
        m_target_cal = cal;
    }
    calendar &
    get_calendar( ) const
    {
        return m_target_cal;
    }
    void
    set_first_date( date d )
    {
        m_begin = m_target_cal( d );
    }
    date_int_type
    get_first_date_int() const
    {
        return m_begin;
    }
    date
    get_first_date() const
    {
        return m_target_cal( m_begin );
    }
    void
    set_last_date( date d ) 
    {
        m_end = m_target_cal( d );
    }
    date_int_type
    get_last_date_int() const
    {
        return m_end;
    }
    date
    get_last_date() const
    {
        return m_target_cal( m_end );
    }
    void
    set_time_series( const tom::collections::time_series & ts )
    {
        m_ts = &ts;
        m_begin = m_target_cal( m_ts->get_first_date() );
        m_end = m_target_cal( m_ts->get_last_date() ) + 1;
    }
    const tom::collections::time_series &
    get_time_series( ) const
    {
        if ( m_ts == NULL )
            throw std::runtime_error( "No time_series set for time_scale_adapter!" );
 
        return *m_ts;
    }
 
private:
    const tom::collections::time_series *   m_ts;
    calendar &                              m_target_cal;
    aggregator_type                         m_aggregator;
 
    date_int_type                           m_begin;
    date_int_type                           m_end;
};
 
} // end calendars namespace
} // end tom namespace
 
#endif