dates.hpp

/* don't include this
 * It is included automatically by scalar.hpp and is only
 * separate to ease maintenance!
 */
#ifndef HAVE_TOM__DATES_HPP
#define HAVE_TOM__DATES_HPP
 
#include <tom-util/calendar.hpp>
 
namespace tom {
 
using tom::calendars::greg_year;
using tom::calendars::greg_month;
using tom::calendars::greg_day;
 
class TOM_UTIL_API date_interval_observation;
 
// Date is just an ulong that holds the value of days() for a date.
// subsequent date_intervals will hold ulongs as well that are
// tied to a specific calendar
class TOM_UTIL_API Date : public scalar<unsigned int>
{
public:
    typedef unsigned  int                       value_type;
    typedef tom::value_types::scalar<value_type>    scalar_type;
    typedef tom::value_types::no_data<value_type>   no_data;
    typedef tom::value_types::holiday<value_type>   holiday;
    typedef tom::value_types::non_calc<value_type>  non_calc;
        
    Date(  ) : scalar<value_type>() {   }
    Date( const date_interval_observation & );
    Date( greg_year y, greg_month m, greg_day d );
 
//  Date( const tom::observation &year, const tom::observation &month, const tom::observation &day );
    Date( tom::calendars::date d ) : scalar<value_type>( d.days() ) { }
  // set Date by a date string
  Date(const tom::observation &str_date, const tom::observation &image);    
    
    // set missing type Dates
    Date( tom::value_type d ) : scalar<value_type>( d ) { }
 
    // this maybe dangerous but i'll leave it 4 now...tom mccubbin
    Date( tom::calendars::date_int_type d ) : scalar<value_type> ( d ) { }
    // same as a date_int_type!
    //Date( value_type d ) : scalar<value_type>( d ) { }
 
    // we must implement, but be carefull, as not all observations
    // can logically convert to the internal date representation
    virtual
    observation &
    operator=( const observation &rhs );
 
    
    Date &
    operator=( const date_interval_observation & );
    
    // safe assignment w/out check
    Date &
    operator=( const tom::calendars::date &rhs );
 
    // duh...
    Date &
    operator=( const Date & rhs );
 
    // assign missing types
    Date &
    operator=( tom::value_type t );
    
    Date &
    operator=( value_type t ) {  m_value = t; return *this; }
 
    // print me
    virtual 
    std::ostream & 
    print( std::ostream &os ) const;
 
};
 
// abstract date_interval 
// deriving classes need only fullfill 
class TOM_UTIL_API date_interval_observation : public Date
{
public:
    typedef Date::value_type                        value_type;
    typedef tom::value_types::scalar<value_type>    scalar_type;
    typedef tom::value_types::no_data<value_type>   no_data;
    typedef tom::value_types::holiday<value_type>   holiday;
    typedef tom::value_types::non_calc<value_type>  non_calc;
 
    // constructors
    date_interval_observation(  ) : Date() 
    {   }
    date_interval_observation( tom::value_type d ) : Date( d ) 
    {   }
 
    // d must have been converted using the appropriate calendar
    date_interval_observation( tom::calendars::date_int_type d  ) : Date( d ) 
    {   }
 
    // copy a date_interval_observation
    date_interval_observation( const date_interval_observation & );
        
    // assignment
    virtual 
    date_interval_observation &
    operator=( const date_interval_observation & );
    
    virtual 
    date_interval_observation &
    operator=( const observation & );
 
    virtual 
    date_interval_observation &
    operator=( const tom::Date & );
 
    // these are the additions to the interface
    virtual 
    tom::calendars::calendar & 
    get_calendar() const = 0;
 
    // special overload for virtual operator unsigned long int
    // to adjust from calendar back to natural date.days()
    virtual
    operator unsigned long int() const
    {
        if ( is_normal() )
            return get_calendar()( m_value.value_ ).days();
        else
            return m_value.value_;
    }
    virtual 
    tom::calendars::range & 
    get_range() const;
 
    // print here!  we know what to do w/out
    // worrying about the calendar
    virtual 
    std::ostream & 
    print( std::ostream &os ) const;
 
    virtual 
    bool 
    operator==( const observation & rhs ) const
    {
        scalar_type tmp = cast_observation_<Date::value_type>( rhs );
        if ( tmp.is_normal() )
            return m_value == get_calendar()( tom::calendars::date( tmp.value_ ) );
        else
            return m_value == tmp;
    }
    virtual 
    bool 
    operator!=( const observation & rhs ) const
    {
        return ! ( *this == rhs );  
    }
    
};
 
template <typename CalendarT>
class TOM_UTIL_API date_interval_scalar : public date_interval_observation
{
public:
    typedef     date_interval_observation::value_type       value_type;
    typedef     date_interval_observation::no_data          no_data;
    typedef     date_interval_observation::holiday          holiday;
    typedef     date_interval_observation::non_calc         non_calc;
    typedef     CalendarT                                   calendar_type;
 
    // constructors
    date_interval_scalar(  ) : date_interval_observation() 
    {   }
    date_interval_scalar( tom::calendars::date d ) : 
            date_interval_observation( calendar_type::Instance()(d) ) 
    {   }
    date_interval_scalar( const tom::Date &d );
    date_interval_scalar( calendars::greg_year y,calendars::greg_month m, calendars::greg_day d ) :
            date_interval_observation( calendar_type::Instance()( calendars::date( y,m,d) ) )
    {   }
    date_interval_scalar( tom::value_type d ) : date_interval_observation( d ) 
    {   }
    
    // this seems like bad policy...do we trust them to 
    // pass valid date_int_types???
    date_interval_scalar( value_type d ) 
    { 
        m_value = d;
    }
 
    // copy constructors
    date_interval_scalar( const observation & );
    date_interval_scalar( const date_interval_scalar & );
 
    template <typename CalendarTp>
    date_interval_scalar( const date_interval_scalar<CalendarTp> & );
 
    date_interval_scalar &
    clone() const
    {
        return *new date_interval_scalar( *this );
    }
 
    // asignment operators
    // not dangerous...may result in ND though
    virtual
    date_interval_observation &
    operator=( const observation &rhs );
 
    date_interval_scalar &
    operator=( const date_interval_scalar & );
 
    template <typename CalendarTp>
    date_interval_scalar &
    operator=( const date_interval_scalar<CalendarTp> & );
 
    date_interval_scalar &
    operator=( const Date & );
 
    date_interval_scalar &
    operator=( const tom::calendars::date &rhs );
 
    // not a good idea!  lets axe this one...   
    date_interval_scalar &
    operator=( const value_type &rhs );
    
    date_interval_scalar &
    operator=( tom::value_type t );
 
    virtual 
    tom::calendars::calendar & 
    get_calendar() const { return calendar_type::Instance(); }
 
    static const date_interval_scalar HAS_NO_DATA;
    static const date_interval_scalar HOLIDAY;
    static const date_interval_scalar NON_CALC;
    
};
 
 
typedef date_interval_scalar< tom::calendars::daily_calendar >                  DateIntervalDaily;
typedef date_interval_scalar< tom::calendars::business_calendar >               DateIntervalBusiness;
typedef date_interval_scalar< tom::calendars::weekly_monday_calendar>           DateIntervalWeeklyMonday;
typedef date_interval_scalar< tom::calendars::weekly_tuesday_calendar>          DateIntervalWeeklyTuesday;
typedef date_interval_scalar< tom::calendars::weekly_wednesday_calendar>        DateIntervalWeeklyWednesday;
typedef date_interval_scalar< tom::calendars::weekly_thursday_calendar>         DateIntervalWeeklyThursday;
typedef date_interval_scalar< tom::calendars::weekly_friday_calendar>           DateIntervalWeeklyFriday;
typedef date_interval_scalar< tom::calendars::weekly_saturday_calendar>         DateIntervalWeeklySaturday;
typedef date_interval_scalar< tom::calendars::weekly_sunday_calendar>           DateIntervalWeeklySunday;
typedef date_interval_scalar< tom::calendars::monthly_calendar >                DateIntervalMonthly;
typedef date_interval_scalar< tom::calendars::quarterly_october_calendar>       DateIntervalQuarterlyOctober;
typedef date_interval_scalar< tom::calendars::quarterly_november_calendar>      DateIntervalQuarterlyNovember;
typedef date_interval_scalar< tom::calendars::quarterly_december_calendar>      DateIntervalQuarterlyDecember;
typedef date_interval_scalar< tom::calendars::semiannual_july_calendar>         DateIntervalSemiannualJuly;
typedef date_interval_scalar< tom::calendars::semiannual_august_calendar>       DateIntervalSemiannualAugust;
typedef date_interval_scalar< tom::calendars::semiannual_september_calendar>    DateIntervalSemiannualSeptember;
typedef date_interval_scalar< tom::calendars::semiannual_october_calendar>      DateIntervalSemiannualOctober;
typedef date_interval_scalar< tom::calendars::semiannual_november_calendar>     DateIntervalSemiannualNovember;
typedef date_interval_scalar< tom::calendars::semiannual_december_calendar>     DateIntervalSemiannualDecember;
typedef date_interval_scalar< tom::calendars::annual_january_calendar>          DateIntervalAnnualJanuary;
typedef date_interval_scalar< tom::calendars::annual_february_calendar>         DateIntervalAnnualFebruary;
typedef date_interval_scalar< tom::calendars::annual_march_calendar>            DateIntervalAnnualMarch;
typedef date_interval_scalar< tom::calendars::annual_april_calendar>            DateIntervalAnnualApril;
typedef date_interval_scalar< tom::calendars::annual_may_calendar>              DateIntervalAnnualMay;
typedef date_interval_scalar< tom::calendars::annual_june_calendar>             DateIntervalAnnualJune;
typedef date_interval_scalar< tom::calendars::annual_july_calendar>             DateIntervalAnnualJuly;
typedef date_interval_scalar< tom::calendars::annual_august_calendar>           DateIntervalAnnualAugust;
typedef date_interval_scalar< tom::calendars::annual_september_calendar>        DateIntervalAnnualSeptember;
typedef date_interval_scalar< tom::calendars::annual_october_calendar>          DateIntervalAnnualOctober;
typedef date_interval_scalar< tom::calendars::annual_november_calendar>         DateIntervalAnnualNovember;
typedef date_interval_scalar< tom::calendars::annual_december_calendar>         DateIntervalAnnualDecember;
 
// aliases for common DateIntervals
typedef DateIntervalWeeklyFriday                                                DateIntervalWeekly;
typedef DateIntervalQuarterlyDecember                                           DateIntervalQuarterly;
typedef DateIntervalSemiannualDecember                                          DateIntervalSemiannual;
typedef DateIntervalAnnualDecember                                              DateIntervalAnnual;
 
 
template <typename CalendarT>
date_interval_scalar<CalendarT>::date_interval_scalar( const tom::Date &d )
{
    if ( d.is_normal() )
        // why use operator unsigned long?
        // because that offers the Date, or derivative to adjust the value 
        // from the calendar, back to the normal Date int!
        m_value = calendar_type::Instance()(  tom::calendars::date( d.operator unsigned long() ) );
    else
        m_value = d.value();    
}
template <typename CalendarT>
date_interval_scalar<CalendarT>::date_interval_scalar( const observation & rhs )
{
    m_value = cast_observation_<typename date_interval_scalar<CalendarT>::value_type> ( rhs );
    if ( this->is_normal() )
        m_value = this->get_calendar()( tom::calendars::date( m_value.value() ) );
    
}
template <typename CalendarT>
date_interval_scalar<CalendarT>::date_interval_scalar( const date_interval_scalar &rhs )
{
    m_value = rhs.value();  
}
template <typename CalendarT>
template <typename CalendarTp>
date_interval_scalar<CalendarT>::date_interval_scalar( const date_interval_scalar<CalendarTp> &rhs )
{
    if ( rhs.is_normal() )
        // this adjusts for differnt calendars
        m_value = get_calendar()( rhs.get_calendar() ( rhs.value() ) );
    else
        m_value = rhs.value();
}
 
template <typename CalendarT>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( const date_interval_scalar & rhs )
{
    m_value = rhs.value();
    return *this;
}
 
template <typename CalendarT>
template <typename CalendarTp>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( const date_interval_scalar<CalendarTp> & rhs)
{
    if ( rhs.is_normal() )
        m_value = get_calendar()( rhs.get_calendar()( rhs.value() ) );
    else
        m_value = rhs.value();
    return *this;   
}
 
template <typename CalendarT>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( const tom::calendars::date &rhs )
{
    m_value = get_calendar()( rhs );
    return *this;
}
template <typename CalendarT>
inline
date_interval_observation &
date_interval_scalar<CalendarT>::operator=( const observation &rhs )
{
    // warning:  this is inplace for date_interval_observations
    //      and should be avoided.  Strings, Floats, Doubles,
    //          and others probably won't asign as expected!
    m_value = rhs.operator value_type();
    
    // lets adjust for the calendar
    m_value = this->get_calendar()( tom::calendars::date( m_value.value() ) );
    return *this;
}
template <typename CalendarT>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( const value_type &rhs )
{
    // it assumed that if you pass the underlying
    // value_type that is has been adjusted by
    // the calendar...this operator is mainly
    // needed for initializing from persisted 
    // data!  Programmers should really use another
    // operator!!!
    this->Date::operator=( rhs );
    return *this;
}
template <typename CalendarT>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( tom::value_type t )
{
    this->Date::operator=( t );
    return *this;
}
template <typename CalendarT>
inline
date_interval_scalar<CalendarT> &
date_interval_scalar<CalendarT>::operator=( const Date & rhs )
{
    if ( rhs.is_normal() )
        m_value = get_calendar()( tom::calendars::date( rhs.value() ) );
    else
        m_value = rhs.value();
    return *this;   
}
 
template <typename CalendarT>
const date_interval_scalar<CalendarT> 
date_interval_scalar<CalendarT>::HAS_NO_DATA( tom::value_type::no_data() );
 
template <typename CalendarT>
const date_interval_scalar<CalendarT> 
date_interval_scalar<CalendarT>::HOLIDAY( tom::value_type::holiday() );
 
template <typename CalendarT>
const date_interval_scalar<CalendarT> 
date_interval_scalar<CalendarT>::NON_CALC( tom::value_type::non_calc() );
 
 
} // end tom namespace
 
#endif