calendar.hpp

#ifndef HAVE_TOM_CALENDAR_HPP
#define HAVE_TOM_CALENDAR_HPP
 
#include <tom-util/defines.hpp>
 
#include <iostream>
#include <string>
#include <memory>
 
// date stuff from boost
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
 
namespace tom {
namespace calendars {
 
typedef boost::gregorian::date::date_int_type       date_int_type;
typedef long                                        wdate_int_type;
typedef boost::gregorian::date_duration             date_duration;
typedef boost::gregorian::greg_month                greg_month;
typedef boost::gregorian::greg_year                 greg_year;
typedef boost::gregorian::greg_day                  greg_day;
typedef boost::gregorian::greg_year_month_day       greg_year_month_day;
typedef boost::gregorian::gregorian_calendar        gregorian_calendar;
 
using boost::gregorian::to_simple_string;
using boost::gregorian::to_iso_extended_string;
using boost::gregorian::from_string;
using boost::gregorian::from_undelimited_string;
using boost::gregorian::day_clock;
using boost::posix_time::ptime;
using boost::posix_time::time_duration;
using boost::posix_time::hours;
using boost::posix_time::minutes;
using boost::posix_time::seconds;
using boost::posix_time::millisec;
 
 
using boost::posix_time::to_simple_string;
using boost::posix_time::to_iso_string;
 
typedef ptime   date_time;
 
// simple wrapper class so we can access the protected
// date::days_ for calendar calculations
class TOM_UTIL_API date : public boost::gregorian::date
{
public:
    date( greg_year y, greg_month m, greg_day d);
 
    date( const date &d ) : boost::gregorian::date(d) { }
    
    date( const boost::gregorian::date &d ) : boost::gregorian::date(d) { }
    
    date( boost::gregorian::greg_year_month_day d ) : boost::gregorian::date(d) { }
    
    date( date_int_type d ) : boost::gregorian::date( 1900,1,1) { days_ = d; }
    
    date_int_type days() const { return days_; }
 
};
 
class TOM_UTIL_API timestamp : public tom::calendars::date
{
public:
 
    timestamp( greg_year y, greg_month m, greg_day d, struct timespec *tspec = nullptr ) : tom::calendars::date(y,m,d)
    {
        if ( tspec ) { m_tspec.tv_sec = tspec->tv_sec; m_tspec.tv_nsec = tspec->tv_nsec; }
        else { m_tspec.tv_sec = m_tspec.tv_nsec = 0; }
    }
 
    timestamp( const timestamp &d, struct timespec *tspec = nullptr  ) : tom::calendars::date(d.days())
    {
        if ( tspec ) { m_tspec.tv_sec = tspec->tv_sec; m_tspec.tv_nsec = tspec->tv_nsec; }
    }
 
    timestamp( const boost::gregorian::date &d, struct timespec *tspec = nullptr  ) : tom::calendars::date(d)
    {
        if ( tspec ) { m_tspec.tv_sec = tspec->tv_sec; m_tspec.tv_nsec = tspec->tv_nsec; }
    }
 
    timestamp( boost::gregorian::greg_year_month_day d, struct timespec *tspec = nullptr ) : tom::calendars::date(d)
    {
        if ( tspec ) { m_tspec.tv_sec = tspec->tv_sec; m_tspec.tv_nsec = tspec->tv_nsec; }
    }
 
    timestamp( date_int_type d, struct timespec *tspec = nullptr ) : tom::calendars::date( 1900,1,1)
    {
        if ( tspec ) { m_tspec.tv_sec = tspec->tv_sec; m_tspec.tv_nsec = tspec->tv_nsec; }
    }
 
    struct timespec
    timespec() const {
        return m_tspec;
    }
protected:
    struct timespec m_tspec {0,0};
 
};
 
// simple wrapper for date_period
// no use other than future expansion
class TOM_UTIL_API date_period : public boost::gregorian::date_period
{
public:
    date_period( date begin, date end ) : boost::gregorian::date_period(begin, end) { }
    date_period( boost::gregorian::date begin, boost::gregorian::date end ) : 
                boost::gregorian::date_period(begin, end) { }
    date_period( date begin, boost::gregorian::date_duration d ) : boost::gregorian::date_period( begin, d) { }
    date_period( const date_period & rhs ) : boost::gregorian::date_period( rhs ) { }
    date_period( const boost::gregorian::date_period & rhs) : boost::gregorian::date_period( rhs ) { }
};
 
class TOM_UTIL_API calendar  
{
public:
    virtual ~calendar(){}
    virtual date_int_type operator()( const date & ) const = 0;
    virtual date operator()( date_int_type ) const = 0;
    virtual date_period get_date_period( const date & ) const = 0;
    virtual date_period get_date_period( date_int_type ) const = 0;
    virtual bool operator==( const calendar &rhs ) const = 0;
    virtual bool operator!=( const calendar &rhs ) const = 0;
    virtual const date &get_first_date( ) const = 0;
    virtual const char *name() const = 0;
};
 
// class to represent a period of time as tied to a calendar
// this class will automatically make date corrections so 
// dates fall from the beginning to the end of the intervals
// as represented by the calendar...
//
// e.g., 
//  range r( monthly_calendar::Instance(), 
//              Date( 2004,5,22 ), Date( 2004, 7, 23 ))
// would represent the range from 2004-May-01 thru 2004-July-31
// because the range adjusts start dates to the 1st date of the 
// interval as determined by the calendar, and the last date to the
// last date of the interval as determined by the calendar.
// 
class TOM_UTIL_API range : public date_period
{
public:
    range( calendar &cal, date start, date end) : 
        date_period( cal.get_date_period( start ).begin(), cal.get_date_period( end ).end() ), 
        m_calendar(cal) {  }
    range( calendar &cal, date_int_type i ) :
        date_period( cal.get_date_period(  i ).begin(), cal.get_date_period( i ).end() + date_duration(1) ) ,
        m_calendar(cal) { }
    range( const range &rhs ) : 
        date_period( rhs.begin(), rhs.end()  ), 
        m_calendar( rhs.m_calendar ) {  }
    range &operator=( const range &rhs )
    {
        this->date_period::operator=( rhs );
        this->m_calendar = rhs.m_calendar;
        return *this;
    }
    ~range() {  }
    const calendar &get_calendar() const { return m_calendar; }
    date get_first_date( ) const { return begin( ); }
    date get_last_date( ) const { return last( ); }
    date get_end_date( ) const { return end( ); }
    date_int_type get_first_date_int( ) const { return m_calendar( begin() ); }
    date_int_type get_last_date_int( ) const { return m_calendar( last() ); }
    
protected:
    calendar & m_calendar;
 
private:
    range();
};
// base class for converter objects
// whose sole purpose handles storing a static
// first_date for the converter
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API converter
{
    static const date first_date;
    inline
    static int get_first_year() { return FIRST_YEAR; }
    inline
    static int get_first_month() { return FIRST_MONTH; }
    inline
    static int get_first_day() { return FIRST_DAY; }
    inline
    static date get_first_date() { return date( FIRST_YEAR, FIRST_MONTH, FIRST_DAY ); }
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
const date converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::first_date = date( FIRST_YEAR, FIRST_MONTH, FIRST_DAY );
 
 
// all the XXX_converters that follow have two basic
// functions:
// operator()( date_int_type ) that returns a Date
// operator()( Date ) that returns a date_int_type
// each corresponding operator() converts to/from 
// integral points and Date(s) for a given calendar.
// e.g., '01 Jan 1850' is date_int_type '1' for the monthly converter
//       and '1' converts back to '31 Jan 1850'
// NOTE: integral intervals convert back to the last day of the 
//       interval.
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API daily_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
 
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
daily_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    return d.days() - this->first_date.days() + 1;
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
daily_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    return date( boost::gregorian::gregorian_calendar::from_day_number( di + this->first_date.days() -1 ));
}
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API business_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
business_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &dd ) const
{
    date d(dd);
    switch (d.day_of_week() )
    {
        case boost::gregorian::Saturday:
            d += date_duration( 2 );
            break;
        case boost::gregorian::Sunday:
            d += date_duration( 1 );
    }
    date_int_type corrected = d.days() - this->first_date.days() + 1;
    int m = corrected % 7;
    if (  m == 5 || m == 6 )
        return 0;
    else
        return corrected - (( corrected / 7 ) * 2);
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
business_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    date_int_type corrected = di * 7;
    date_int_type offset = 1;
    if ( (corrected % 5) % 2 == 1 )
        offset = 2;
    corrected /= 5;
    return date( this->first_date + date_duration( corrected - offset ) );
}
 
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API weekly_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    static const boost::gregorian::date_duration duration;
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
 
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
const date_duration weekly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::duration = date_duration(7);
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
weekly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    date tmp = d;
    while ( tmp.day_of_week() != this->first_date.day_of_week() ) { tmp += date_duration(1); }
    date_duration dd = tmp - this->first_date;
    date_int_type di = dd.days() / duration.days();
    return di + 1;
}
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
weekly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    date_duration reversed = date_duration(date_duration( (di - 1) ).days() * duration.days());
    date tmp = this->first_date;
    tmp += reversed;
    return tmp;
}
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API month_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
 
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
month_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    return ( d.year() - this->first_date.year() ) * 12 + d.month();
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
month_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    unsigned short  mod = di % 12;
    greg_month month( mod == 0 ? 12 : mod );
    
    greg_year year = di / 12 + this->first_date.year() - ( mod == 0 ? 1 : 0 );
    short int day = gregorian_calendar::end_of_month_day( year, month );
    return date ( year, month, day );
}
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API quarterly_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
    static greg_month first_month;
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
greg_month 
quarterly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::first_month = 
quarterly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::first_date.month();
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
quarterly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    date_int_type qtrs =  ( d.year() - this->first_date.year() ) * 4 + 1;
    signed short d_mon = d.month();
    signed short first_qtr = ( first_month / 3 + ( first_month % 3 != 0 ? 1 : 0 ) );
    signed short d_qtr = ( d_mon / 3 + ( d_mon % 3 != 0 ? 1 : 0 ) );
    return qtrs + ( d_qtr - first_qtr );
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
quarterly_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    signed short yr_mod = di % 4;
    signed short mon_mod = yr_mod != 0 ? yr_mod - 1 : 3;
    unsigned int year = (di / 4) + this->first_date.year();
    unsigned short month = first_month + (mon_mod * 3);
    if ( month > 12 ){ month = month - 12; }
    if ( first_month == 3 && yr_mod == 0 ) year--;
    short int day = gregorian_calendar::end_of_month_day( year, month );
    return date ( year, month, day );
}
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API semiannual_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
    static greg_month first_month;
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
greg_month 
semiannual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::first_month = 
semiannual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::first_date.month();
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
semiannual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    date_int_type qtrs =  ( d.year() - this->first_date.year() ) * 2 + 1;
    signed short d_mon = d.month();
    signed short first_qtr = ( first_month / 6 + ( first_month % 6 != 0 ? 1 : 0 ) );
    signed short d_qtr = ( d_mon / 6 + ( d_mon % 6 != 0 ? 1 : 0 ) );
    return qtrs + ( d_qtr - first_qtr);
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
semiannual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    signed short yr_mod = di % 2;
    signed short mon_mod = yr_mod != 0 ? yr_mod -1 : 1;
    unsigned int year = (di / 2) + this->first_date.year();
    unsigned short month = first_month + ( mon_mod * 6 );
    if ( month > 12 ){ month = month - 12; }
    if ( first_month == 6 && yr_mod == 0 ) year--;
    short int day = gregorian_calendar::end_of_month_day( year, month );
    return date ( year, month, day );
}
 
template < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
struct TOM_UTIL_API annual_converter : public converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>
{
    date operator()( date_int_type ) const;
    date_int_type operator()( const date & ) const;
};
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date_int_type 
annual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( const date &d ) const
{
    return d.year() - this->first_date.year() + 1;
}
 
template  < int FIRST_YEAR, int FIRST_MONTH, int FIRST_DAY>
inline
date 
annual_converter<FIRST_YEAR,FIRST_MONTH,FIRST_DAY>::operator()( date_int_type di ) const
{
    greg_year year = di + this->first_date.year() - 1;
    greg_month month = FIRST_MONTH;
    short int day = gregorian_calendar::end_of_month_day( year, month );
    return date ( year, month, day );
}
 
// calendar_impl is the implementation of the calendar
// absttract class, and provides a simple mechanism,
// joined w/ XXX_converters to provide a rich calendar
// system.
template <typename CONVERTER>
class TOM_UTIL_API calendar_impl : public calendar
{
public:
    typedef date::date_int_type date_int_type;
    typedef CONVERTER               converter_type;
 
    static calendar_impl &Instance();       // factory method
 
    virtual date_int_type operator()( const date & ) const;     // map Date to interval
    virtual date operator()( date_int_type ) const;     // map interval to Date
    virtual date_period get_date_period( const date & ) const;
    virtual date_period get_date_period( date_int_type ) const;
    virtual bool operator==( const calendar &rhs ) const;
    virtual bool operator!=( const calendar &rhs ) const;
    virtual const date &get_first_date( ) const;
    virtual const char *name() const;
    
private:
    CONVERTER converter;
    calendar_impl();
 
};
 
template <typename CONVERTER>
calendar_impl<CONVERTER>::calendar_impl() { }
/*
template <typename CONVERTER>
inline
const char *
calendar_impl<CONVERTER>::name() const
{
    // this is a bogus function to lookup
    // calendar instances and return a name
    return lookup_name( this );
}
*/
template <typename CONVERTER>
inline
bool 
calendar_impl<CONVERTER>::operator==( const calendar &rhs ) const
{
    // we are singletons, so if memory address equals
    // we are the same guy! (or gal)
    if ( this == & rhs )
        return true;
    else
        return false;
}
 
template <typename CONVERTER>
inline
bool 
calendar_impl<CONVERTER>::operator!=( const calendar &rhs ) const
{
    if ( *this == rhs )
        return false;
    else
        return true;
}
template <typename CONVERTER>
inline
const date &
calendar_impl<CONVERTER>::get_first_date( ) const
{ 
    return CONVERTER::first_date;
}
 
template <typename CONVERTER>
inline
calendar_impl<CONVERTER> &
calendar_impl<CONVERTER>::Instance() 
{ 
    static calendar_impl calendar;
    return calendar;
}
template <typename CONVERTER>
inline
date_int_type
calendar_impl<CONVERTER>::operator()( const date &d ) const
{ 
    return converter (d);
}
template <typename CONVERTER>
inline
date
calendar_impl<CONVERTER>::operator()( date_int_type d ) const
{ 
    return converter (d);
}
template <typename CONVERTER>
inline
date_period
calendar_impl<CONVERTER>::get_date_period( date_int_type d ) const
{ 
    date end = converter (d);
    date prev = converter( d -1 );
    // return date_period( static_cast<tom::calendars::date>(prev + date_duration(1)), 
    //                  static_cast<tom::calendars::date>(end + date_duration(1)) );
    return date_period( prev + date_duration(1), end + date_duration(1) );
}
template <typename CONVERTER>
inline
date_period
calendar_impl<CONVERTER>::get_date_period( const date &d ) const
{ 
    date_int_type end_date_int = converter (d);
    date end = converter ( end_date_int );
    date prev = converter ( end_date_int -1 );
    return date_period( prev + date_duration(1), end + date_duration(1) );
}
// the dates for each calendar were chosen to align
// our date_ints for the calendar with those of FAME.
// This was done to aid in migration from FAME.
// These dates can easily be adjusted back to January
// 1400, and extend until the year 10,000 without impacting
// the behavior of the calendars
//
// NOTE:  However, once data has been indexed to date_ints
//        using these dates, they must be reindexed if the
//        calendar base date is changed.  Hence, the calendar
//        first date should be persisted for date_ints, series,
//        or databases, depending on the implementation.
typedef calendar_impl< daily_converter<1850,1,1> >          timestamp_calendar;
typedef calendar_impl< daily_converter<1401,1,1> >          ordinal_calendar;
typedef calendar_impl< daily_converter<1850,1,1> >          daily_calendar;
typedef calendar_impl< business_converter<1850,1,1> >       business_calendar;
typedef calendar_impl< weekly_converter<1850,1,7> >         weekly_monday_calendar;
typedef calendar_impl< weekly_converter<1850,1,8> >         weekly_tuesday_calendar;
typedef calendar_impl< weekly_converter<1850,1,9> >         weekly_wednesday_calendar;
typedef calendar_impl< weekly_converter<1850,1,10> >        weekly_thursday_calendar;
typedef calendar_impl< weekly_converter<1850,1,11> >        weekly_friday_calendar;
typedef calendar_impl< weekly_converter<1850,1,12> >        weekly_saturday_calendar;
typedef calendar_impl< weekly_converter<1850,1,13> >        weekly_sunday_calendar;
typedef calendar_impl< month_converter<1850,1,31> >         monthly_calendar;
typedef calendar_impl< quarterly_converter<1850,4,30> >     quarterly_october_calendar;
typedef calendar_impl< quarterly_converter<1850,5,31> >     quarterly_november_calendar;
typedef calendar_impl< quarterly_converter<1850,3,31> >     quarterly_december_calendar;
typedef calendar_impl< semiannual_converter<1850,7,31> >    semiannual_july_calendar;
typedef calendar_impl< semiannual_converter<1850,8,31> >    semiannual_august_calendar;
typedef calendar_impl< semiannual_converter<1850,9,30> >    semiannual_september_calendar;
typedef calendar_impl< semiannual_converter<1850,10,31> >   semiannual_october_calendar;
typedef calendar_impl< semiannual_converter<1850,11,30> >   semiannual_november_calendar;
typedef calendar_impl< semiannual_converter<1850,6,30> >    semiannual_december_calendar;
typedef calendar_impl< annual_converter<1851,1,31> >        annual_january_calendar;
typedef calendar_impl< annual_converter<1851,2,28> >        annual_february_calendar;
typedef calendar_impl< annual_converter<1851,3,31> >        annual_march_calendar;
typedef calendar_impl< annual_converter<1851,4,30> >        annual_april_calendar;
typedef calendar_impl< annual_converter<1851,5,31> >        annual_may_calendar;
typedef calendar_impl< annual_converter<1851,6,30> >        annual_june_calendar;
typedef calendar_impl< annual_converter<1851,7,31> >        annual_july_calendar;
typedef calendar_impl< annual_converter<1851,8,31> >        annual_august_calendar;
typedef calendar_impl< annual_converter<1851,9,30> >        annual_september_calendar;
typedef calendar_impl< annual_converter<1851,10,31> >       annual_october_calendar;
typedef calendar_impl< annual_converter<1851,11,30> >       annual_november_calendar;
typedef calendar_impl< annual_converter<1850,12,31> >       annual_december_calendar;
 
// aliases for common DateIntervals
typedef weekly_friday_calendar                  weekly_calendar;
typedef quarterly_december_calendar             quarterly_calendar;
typedef semiannual_december_calendar            semiannual_calendar;
typedef annual_december_calendar                annual_calendar;
 
namespace { // anonymous namespace for helpers
 
    // The following are helpers to map string names to calendar instances
    // this is good for all kind of human interaction :)
    template <typename COLLECTION_T>
    COLLECTION_T *
    populate_calendar_map(  );
    
    inline
    const char *
    lookup_name( const tom::calendars::calendar *cal )
    {
        typedef std::map< const tom::calendars::calendar *, const char *>  map_t;
        static std::unique_ptr<map_t> map( populate_calendar_map<map_t>() );
        map_t::const_iterator it = map->find( cal );
        if ( it != map->end() )
            return it->second;
        else
            return "Unknown";
    }
    template <typename COLLECTION_T>
    inline
    COLLECTION_T *
    populate_calendar_map(  )
    {
        typedef typename COLLECTION_T::value_type  value_type;
        static value_type items[] = {
            value_type( &ordinal_calendar::Instance(), "Ordinal" ),
            value_type( &daily_calendar::Instance(), "Daily" ),
            value_type( &business_calendar::Instance(), "Business" ),
            value_type( &weekly_monday_calendar::Instance(), "Weekly(Mon)" ),
            value_type( &weekly_tuesday_calendar::Instance(), "Weekly(Tue)" ),
            value_type( &weekly_wednesday_calendar::Instance(), "Weekly(Wed)" ),
            value_type( &weekly_thursday_calendar::Instance(), "Weekly(Thu)" ),
            value_type( &weekly_friday_calendar::Instance(), "Weekly(Fri)" ),
            value_type( &weekly_saturday_calendar::Instance(), "Weekly(Sat)" ),
            value_type( &weekly_sunday_calendar::Instance(), "Weekly(Sun)" ),
            value_type( &monthly_calendar::Instance(), "Monthly" ),
            value_type( &quarterly_october_calendar::Instance(), "Quarterly(Oct)" ),
            value_type( &quarterly_november_calendar::Instance(), "Quarterly(Nov)" ),
            value_type( &quarterly_december_calendar::Instance(), "Quarterly(Dec)" ),
            value_type( &semiannual_july_calendar::Instance(), "Semiannual(Jul)" ),
            value_type( &semiannual_august_calendar::Instance(), "Semiannual(Aug)" ),
            value_type( &semiannual_september_calendar::Instance(), "Semiannual(Sep)" ),
            value_type( &semiannual_october_calendar::Instance(), "Semiannual(Oct)" ),
            value_type( &semiannual_november_calendar::Instance(), "Semiannual(Nov)" ),
            value_type( &semiannual_december_calendar::Instance(), "Semiannual(Dec)" ),
            value_type( &annual_january_calendar::Instance(), "Annual(Jan)" ),
            value_type( &annual_february_calendar::Instance(), "Annual(Feb)" ),
            value_type( &annual_march_calendar::Instance(), "Annual(Mar)" ),
            value_type( &annual_april_calendar::Instance(), "Annual(Apr)" ),
            value_type( &annual_may_calendar::Instance(), "Annual(May)" ),
            value_type( &annual_june_calendar::Instance(), "Annual(Jun)" ),
            value_type( &annual_july_calendar::Instance(), "Annual(Jul)" ),
            value_type( &annual_august_calendar::Instance(), "Annual(Aug)" ),
            value_type( &annual_september_calendar::Instance(), "Annual(Sep)" ),
            value_type( &annual_october_calendar::Instance(), "Annual(Oct)" ),
            value_type( &annual_november_calendar::Instance(), "Annual(Nov)" ),
            value_type( &annual_december_calendar::Instance(), "Annual(Dec)" )
        };
        COLLECTION_T *result = new COLLECTION_T( items, items + 
                                ( sizeof(items) / sizeof( value_type ) ) );
        return result;
    }
    } // end anonymous namespace
 
    template <typename CONVERTER>
    inline
    const char *
    calendar_impl<CONVERTER>::name() const
    {
        // this is a bogus function to lookup
        // calendar instances and return a name
        return lookup_name( this );
    }
 
  } // end calendars namespace
} // end tom namespace
 
#endif