Boost-Graph
view release on metacpan or search on metacpan
include/boost/date_time/date_iterator.hpp
include/boost/date_time/date_names_put.hpp
include/boost/date_time/date_parsing.hpp
include/boost/date_time/dst_rules.hpp
include/boost/date_time/dst_transition_generators.hpp
include/boost/date_time/filetime_functions.hpp
include/boost/date_time/format_date_parser.hpp
include/boost/date_time/gregorian/conversion.hpp
include/boost/date_time/gregorian/formatters.hpp
include/boost/date_time/gregorian/formatters_limited.hpp
include/boost/date_time/gregorian/greg_calendar.hpp
include/boost/date_time/gregorian/greg_date.hpp
include/boost/date_time/gregorian/greg_day.hpp
include/boost/date_time/gregorian/greg_day_of_year.hpp
include/boost/date_time/gregorian/greg_duration.hpp
include/boost/date_time/gregorian/greg_duration_types.hpp
include/boost/date_time/gregorian/greg_facet.hpp
include/boost/date_time/gregorian/greg_month.hpp
include/boost/date_time/gregorian/greg_serialize.hpp
include/boost/date_time/gregorian/greg_weekday.hpp
include/boost/date_time/gregorian/greg_year.hpp
include/boost/date_time/gregorian/greg_ymd.hpp
include/boost/date_time/gregorian/gregorian.hpp
include/boost/date_time/gregorian/gregorian_io.hpp
include/boost/date_time/gregorian/gregorian_types.hpp
include/boost/date_time/gregorian/parsers.hpp
include/boost/date_time/gregorian_calendar.hpp
include/boost/date_time/gregorian_calendar.ipp
include/boost/date_time/int_adapter.hpp
include/boost/date_time/iso_format.hpp
include/boost/date_time/local_time/conversion.hpp
include/boost/date_time/local_time/custom_time_zone.hpp
include/boost/date_time/local_time/date_duration_operators.hpp
include/boost/date_time/local_time/dst_transition_day_rules.hpp
include/boost/date_time/local_time/local_date_time.hpp
include/boost/date_time/local_time/local_time.hpp
include/boost/date_time/local_time/local_time_io.hpp
include/boost/date_time/local_time/local_time_types.hpp
include/boost/date_time/adjust_functors.hpp view on Meta::CPAN
d.year();
return duration_type(-f_);
}
private:
int f_;
};
//! Provides calculation to find next nth month given a date
/*! This adjustment function provides the logic for 'month-based'
* advancement on a ymd based calendar. The policy it uses
* to handle the non existant end of month days is to back
* up to the last day of the month. Also, if the starting
* date is the last day of a month, this functor will attempt
* to adjust to the end of the month.
*/
template<class date_type>
class month_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type cal_type;
typedef typename cal_type::ymd_type ymd_type;
typedef typename cal_type::day_type day_type;
month_functor(int f) : f_(f), origDayOfMonth_(0) {}
duration_type get_offset(const date_type& d) const
{
ymd_type ymd(d.year_month_day());
if (origDayOfMonth_ == 0) {
origDayOfMonth_ = ymd.day;
day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
include/boost/date_time/adjust_functors.hpp view on Meta::CPAN
mutable short origDayOfMonth_;
};
//! Functor to iterate a over weeks
template<class date_type>
class week_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type calendar_type;
week_functor(int f) : f_(f) {}
duration_type get_offset(const date_type& d) const
{
// why is 'd' a parameter???
// fix compiler warnings
d.year();
return duration_type(f_*calendar_type::days_in_week());
}
duration_type get_neg_offset(const date_type& d) const
{
// fix compiler warnings
d.year();
return duration_type(-f_*calendar_type::days_in_week());
}
private:
int f_;
};
//! Functor to iterate by a year adjusting for leap years
template<class date_type>
class year_functor
{
public:
include/boost/date_time/date.hpp view on Meta::CPAN
that is based on a year-month-day system such as the gregorian
or iso systems. It provides basic operations to enable calculation
and comparisons.
<b>Theory</b>
This date representation fundamentally departs from the C tm struct
approach. The goal for this type is to provide efficient date
operations (add, subtract) and storage (minimize space to represent)
in a concrete class. Thus, the date uses a count internally to
represent a particular date. The calendar parameter defines
the policies for converting the the year-month-day and internal
counted form here. Applications that need to perform heavy
formatting of the same date repeatedly will perform better
by using the year-month-day representation.
Internally the date uses a day number to represent the date.
This is a monotonic time representation. This representation
allows for fast comparison as well as simplifying
the creation of writing numeric operations. Essentially, the
internal day number is like adjusted julian day. The adjustment
is determined by the Epoch date which is represented as day 1 of
the calendar. Day 0 is reserved for negative infinity so that
any actual date is automatically greater than negative infinity.
When a date is constructed from a date or formatted for output,
the appropriate conversions are applied to create the year, month,
day representations.
*/
template<class T, class calendar, class duration_type_>
class date : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T date_type;
typedef calendar calendar_type;
typedef typename calendar::date_traits_type traits_type;
typedef duration_type_ duration_type;
typedef typename calendar::year_type year_type;
typedef typename calendar::month_type month_type;
typedef typename calendar::day_type day_type;
typedef typename calendar::ymd_type ymd_type;
typedef typename calendar::date_rep_type date_rep_type;
typedef typename calendar::date_int_type date_int_type;
typedef typename calendar::day_of_week_type day_of_week_type;
date(year_type y, month_type m, day_type d)
: days_(calendar::day_number(ymd_type(y, m, d)))
{}
date(const ymd_type& ymd)
: days_(calendar::day_number(ymd))
{}
//let the compiler write copy, assignment, and destructor
year_type year() const
{
ymd_type ymd = calendar::from_day_number(days_);
return ymd.year;
}
month_type month() const
{
ymd_type ymd = calendar::from_day_number(days_);
return ymd.month;
}
day_type day() const
{
ymd_type ymd = calendar::from_day_number(days_);
return ymd.day;
}
day_of_week_type day_of_week() const
{
ymd_type ymd = calendar::from_day_number(days_);
return calendar::day_of_week(ymd);
}
ymd_type year_month_day() const
{
return calendar::from_day_number(days_);
}
bool operator<(const date_type& rhs) const
{
return days_ < rhs.days_;
}
bool operator==(const date_type& rhs) const
{
return days_ == rhs.days_;
}
//! check to see if date is a special value
include/boost/date_time/date_facet.hpp view on Meta::CPAN
*
* Default month format == %b
* Default weekday format == %a
*/
template <class date_type,
class CharT,
class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
class date_facet : public std::locale::facet {
public:
typedef typename date_type::duration_type duration_type;
// greg_weekday is gregorian_calendar::day_of_week_type
typedef typename date_type::day_of_week_type day_of_week_type;
typedef typename date_type::day_type day_type;
typedef typename date_type::month_type month_type;
typedef boost::date_time::period<date_type,duration_type> period_type;
typedef std::basic_string<CharT> string_type;
typedef CharT char_type;
typedef boost::date_time::period_formatter<CharT> period_formatter_type;
typedef boost::date_time::special_values_formatter<CharT> special_values_formatter_type;
typedef std::vector<std::basic_string<CharT> > input_collection_type;
// used for the output of the date_generators
include/boost/date_time/date_facet.hpp view on Meta::CPAN
//! Input facet
template <class date_type,
class CharT,
class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
class date_input_facet : public std::locale::facet {
public:
typedef typename date_type::duration_type duration_type;
// greg_weekday is gregorian_calendar::day_of_week_type
typedef typename date_type::day_of_week_type day_of_week_type;
typedef typename date_type::day_type day_type;
typedef typename date_type::month_type month_type;
typedef typename date_type::year_type year_type;
typedef boost::date_time::period<date_type,duration_type> period_type;
typedef std::basic_string<CharT> string_type;
typedef CharT char_type;
typedef boost::date_time::period_parser<date_type, CharT> period_parser_type;
typedef special_values_parser<date_type,CharT> special_values_parser_type;
typedef std::vector<std::basic_string<CharT> > input_collection_type;
include/boost/date_time/date_generators.hpp view on Meta::CPAN
//! Base class for all generators that take a year and produce a date.
/*! This class is a base class for polymorphic function objects that take
a year and produce a concrete date.
@param date_type The type representing a date. This type must
export a calender_type which defines a year_type.
*/
template<class date_type>
class year_based_generator
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::year_type year_type;
year_based_generator() {};
virtual ~year_based_generator() {};
virtual date_type get_date(year_type y) const = 0;
//! Returns a string for use in a POSIX time_zone string
virtual std::string to_string() const =0;
};
//! Generates a date by applying the year to the given month and day.
/*!
Example usage:
include/boost/date_time/date_generators.hpp view on Meta::CPAN
partial_date pd2(70);
date d = pd.get_date(2002); //2002-Jan-01
date d2 = pd2.get_date(2002); //2002-Mar-10
@endcode
\ingroup date_alg
*/
template<class date_type>
class partial_date : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_type day_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
typedef typename duration_type::duration_rep duration_rep;
partial_date(day_type d, month_type m) :
day_(d),
month_(m)
{}
//! Partial date created from number of days into year. Range 1-366
/*! Allowable values range from 1 to 366. 1=Jan1, 366=Dec31. If argument
* exceeds range, partial_date will be created with closest in-range value.
* 60 will always be Feb29, if get_date() is called with a non-leap year
include/boost/date_time/date_generators.hpp view on Meta::CPAN
* instantiated with Feb-29, has get_date called with a non-leap year.
* Example:
* @code
* partial_date pd(29, Feb);
* pd.get_date(2003); // throws invalid_argument exception
* pg.get_date(2000); // returns 2000-2-29
* @endcode
*/
date_type get_date(year_type y) const
{
if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
std::stringstream ss("");
ss << "No Feb 29th in given year of " << y << ".";
throw std::invalid_argument(ss.str());
//return date_type(1,1,1); // should never reach
} else {
return date_type(y, month_, day_);
}
}
date_type operator()(year_type y) const
{
include/boost/date_time/date_generators.hpp view on Meta::CPAN
* and then we can add the length of a week until we get
* to the 'nth kday'. There are probably more efficient
* algorithms based on using a mod 7, but this one works
* reasonably well for basic applications.
* \ingroup date_alg
*/
template<class date_type>
class nth_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
enum week_num {first=1, second, third, fourth, fifth};
nth_kday_of_month(week_num week_no,
day_of_week_type dow,
month_type m) :
month_(m),
wn_(week_no),
dow_(dow)
{}
//! Return a concrete date when provided with a year specific year.
include/boost/date_time/date_generators.hpp view on Meta::CPAN
BOOST_DATE_TIME_DECL const char* nth_as_str(int n);
//! Useful generator functor for finding holidays and daylight savings
/*! Similar to nth_kday_of_month, but requires less paramters
* \ingroup date_alg
*/
template<class date_type>
class first_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
//!Specify the first 'Sunday' in 'April' spec
/*!@param dow The day of week, eg: Sunday, Monday, etc
* @param m The month of the year, eg: Jan, Feb, Mar, etc
*/
first_kday_of_month(day_of_week_type dow, month_type m) :
month_(m),
dow_(dow)
{}
//! Return a concrete date when provided with a year specific year.
include/boost/date_time/date_generators.hpp view on Meta::CPAN
/*! Useful generator functor for finding holidays and daylight savings
* Get the last day of the month and then calculate the difference
* to the last previous day.
* @param date_type A date class that exports day_of_week, month_type, etc.
* \ingroup date_alg
*/
template<class date_type>
class last_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
//!Specify the date spec like last 'Sunday' in 'April' spec
/*!@param dow The day of week, eg: Sunday, Monday, etc
* @param m The month of the year, eg: Jan, Feb, Mar, etc
*/
last_kday_of_month(day_of_week_type dow, month_type m) :
month_(m),
dow_(dow)
{}
//! Return a concrete date when provided with a year specific year.
date_type get_date(year_type year) const
{
date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
duration_type one_day(1);
while (dow_ != d.day_of_week()) {
d = d - one_day;
}
return d;
}
// added for streaming
month_type month() const
{
return month_;
include/boost/date_time/date_generators.hpp view on Meta::CPAN
typedef boost::date_time::first_kday_after<date> firstkdayafter;
firstkdayafter fkaf(Monday);
fkaf.get_date(date(2002,Feb,1));
@endcode
* \ingroup date_alg
*/
template<class date_type>
class first_kday_after
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_after(day_of_week_type dow) :
dow_(dow)
{}
//! Return next kday given.
date_type get_date(date_type start_day) const
{
duration_type one_day(1);
date_type d = start_day + one_day;
while (dow_ != d.day_of_week()) {
include/boost/date_time/date_generators.hpp view on Meta::CPAN
typedef boost::date_time::first_kday_before<date> firstkdaybefore;
firstkdaybefore fkbf(Monday);
fkbf.get_date(date(2002,Feb,1));
@endcode
* \ingroup date_alg
*/
template<class date_type>
class first_kday_before
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_before(day_of_week_type dow) :
dow_(dow)
{}
//! Return next kday given.
date_type get_date(date_type start_day) const
{
duration_type one_day(1);
date_type d = start_day - one_day;
while (dow_ != d.day_of_week()) {
include/boost/date_time/date_iterator.hpp view on Meta::CPAN
/*! This class provides the skeleton for the creation of iterators.
* New and interesting interators can be created by plugging in a new
* function that derives the next value from the current state.
* generation of various types of -based information.
*
* <b>Template Parameters</b>
*
* <b>date_type</b>
*
* The date_type is a concrete date_type. The date_type must
* define a duration_type and a calendar_type.
*/
template<class date_type>
class date_itr_base {
// works, but benefit unclear at the moment
// class date_itr_base : public std::iterator<std::input_iterator_tag,
// date_type, void, void, void>{
public:
typedef typename date_type::duration_type duration_type;
typedef date_type value_type;
typedef std::input_iterator_tag iterator_category;
include/boost/date_time/dst_rules.hpp view on Meta::CPAN
* dst_start_offset_minutes - number of minutes from start of day to transition off of dst -- 180 (or 3:00 am) is typical for E.U.
* dst_length_minutes - number of minutes that dst shifts clock
*/
template<class date_type,
class time_duration_type,
class dst_traits>
class dst_calc_engine
{
public:
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
//! Calculates if the given local time is dst or not
/*! Determines if the time is really in DST or not. Also checks for
* invalid and ambiguous.
* @retval The time is either ambiguous, invalid, in dst, or not in dst
*/
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
{
include/boost/date_time/dst_rules.hpp view on Meta::CPAN
template<class date_type_,
class time_duration_type_,
unsigned int dst_start_offset_minutes=120, //from start of day
short dst_length_minutes=60> //1 hour == 60 min in US
class us_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef date_time::last_kday_of_month<date_type> lkday;
typedef date_time::first_kday_of_month<date_type> fkday;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
//! Calculates if the given local time is dst or not
/*! Determines if the time is really in DST or not. Also checks for
* invalid and ambiguous.
* @retval The time is either ambiguous, invalid, in dst, or not in dst
*/
static time_is_dst_result local_is_dst(const date_type& d,
include/boost/date_time/gregorian/greg_calendar.hpp view on Meta::CPAN
/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
* Use, modification and distribution is subject to the
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
* Author: Jeff Garland
* $Date: 2003/11/23 02:27:09 $
*/
#include "boost/date_time/gregorian/greg_weekday.hpp"
#include "boost/date_time/gregorian/greg_day_of_year.hpp"
#include "boost/date_time/gregorian_calendar.hpp"
#include "boost/date_time/gregorian/greg_ymd.hpp"
#include "boost/date_time/int_adapter.hpp"
namespace boost {
namespace gregorian {
//!An internal date representation that includes infinities, not a date
typedef date_time::int_adapter<unsigned long> fancy_date_rep;
//! Gregorian calendar for this implementation, hard work in the base
class gregorian_calendar :
public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
public:
//! Type to hold a weekday (eg: Sunday, Monday,...)
typedef greg_weekday day_of_week_type;
//! Counter type from 1 to 366 for gregorian dates.
typedef greg_day_of_year_rep day_of_year_type;
//! Internal date representation that handles infinity, not a date
typedef fancy_date_rep date_rep_type;
//! Date rep implements the traits stuff as well
typedef fancy_date_rep date_traits_type;
include/boost/date_time/gregorian/greg_date.hpp view on Meta::CPAN
/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
* Use, modification and distribution is subject to the
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
* Author: Jeff Garland
* $Date: 2004/09/10 23:09:50 $
*/
#include "boost/date_time/date.hpp"
#include "boost/date_time/special_defs.hpp"
#include "boost/date_time/gregorian/greg_calendar.hpp"
#include "boost/date_time/gregorian/greg_duration.hpp"
namespace boost {
namespace gregorian {
//bring special enum values into the namespace
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
//! A date type based on gregorian_calendar
/*! This class is the primary interface for programming with
greogorian dates. The is a lightweight type that can be
freely passed by value. All comparison operators are
supported.
\ingroup date_basics
*/
class date : public date_time::date<date, gregorian_calendar, date_duration>
{
public:
typedef gregorian_calendar::year_type year_type;
typedef gregorian_calendar::month_type month_type;
typedef gregorian_calendar::day_type day_type;
typedef gregorian_calendar::day_of_year_type day_of_year_type;
typedef gregorian_calendar::ymd_type ymd_type;
typedef gregorian_calendar::date_rep_type date_rep_type;
typedef gregorian_calendar::date_int_type date_int_type;
typedef date_duration duration_type;
#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
//! Default constructor constructs with not_a_date_time
date():
date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
{}
#endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR
//! Main constructor with year, month, day
date(year_type y, month_type m, day_type d)
: date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
{
if (gregorian_calendar::end_of_month_day(y, m) < d) {
throw bad_day_of_month(std::string("Day of month is not valid for year"));
}
}
//! Constructor from a ymd_type structure
explicit date(const ymd_type& ymd)
: date_time::date<date, gregorian_calendar, date_duration>(ymd)
{}
//! Needed copy constructor
explicit date(const date_int_type& rhs):
date_time::date<date,gregorian_calendar, date_duration>(rhs)
{}
//! Needed copy constructor
explicit date(date_rep_type rhs):
date_time::date<date,gregorian_calendar, date_duration>(rhs)
{}
//! Constructor for infinities, not a date, max and min date
explicit date(special_values sv):
date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
{
if (sv == min_date_time)
{
*this = date(1400, 1, 1);
}
if (sv == max_date_time)
{
*this = date(9999, 12, 31);
}
}
//!Return the Julian Day number for the date.
date_int_type julian_day() const
{
ymd_type ymd = year_month_day();
return gregorian_calendar::julian_day_number(ymd);
}
//!Return the day of year 1..365 or 1..366 (for leap year)
day_of_year_type day_of_year() const
{
date start_of_year(year(), 1, 1);
unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
return day_of_year_type(doy);
}
//!Return the Modified Julian Day number for the date.
long modjulian_day() const
{
ymd_type ymd = year_month_day();
return gregorian_calendar::modjulian_day_number(ymd);
}
//!Return the iso 8601 week number 1..53
int week_number() const
{
ymd_type ymd = year_month_day();
return gregorian_calendar::week_number(ymd);
}
//! Return the day number from the calendar
date_int_type day_number() const
{
return days_;
}
//! Return the last day of the current month
date end_of_month() const
{
ymd_type ymd = year_month_day();
short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
return date(ymd.year, ymd.month, eom_day);
}
private:
};
} } //namespace gregorian
include/boost/date_time/gregorian/greg_day.hpp view on Meta::CPAN
{}
};
//! Policy class that declares error handling and day of month ranges
typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
//! Generated represetation for gregorian day of month
typedef CV::constrained_value<greg_day_policies> greg_day_rep;
//! Represent a day of the month (range 1 - 31)
/*! This small class allows for simple conversion an integer value into
a day of the month for a standard gregorian calendar. The type
is automatically range checked so values outside of the range 1-31
will cause a bad_day_of_month exception
*/
class greg_day : public greg_day_rep {
public:
greg_day(unsigned short day_of_month) : greg_day_rep(day_of_month) {}
unsigned short as_number() const {return value_;}
operator unsigned short() const {return value_;}
private:
include/boost/date_time/gregorian/greg_month.hpp view on Meta::CPAN
struct bad_month : public std::out_of_range
{
bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
};
//! Build a policy class for the greg_month_rep
typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
//! A constrained range that implements the gregorian_month rules
typedef CV::constrained_value<greg_month_policies> greg_month_rep;
//! Wrapper class to represent months in gregorian based calendar
class BOOST_DATE_TIME_DECL greg_month : public greg_month_rep {
public:
typedef date_time::months_of_year month_enum;
typedef std::map<std::string, unsigned short> month_map_type;
typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
//! Construct a month from the months_of_year enumeration
greg_month(month_enum theMonth) :
greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}
//! Construct from a short value
greg_month(unsigned short theMonth) : greg_month_rep(theMonth) {}
include/boost/date_time/gregorian/greg_year.hpp view on Meta::CPAN
{}
};
//! Policy class that declares error handling gregorian year type
typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
//! Generated representation for gregorian year
typedef CV::constrained_value<greg_year_policies> greg_year_rep;
//! Represent a day of the month (range 1900 - 10000)
/*! This small class allows for simple conversion an integer value into
a year for the gregorian calendar. This currently only allows a
range of 1900 to 10000. Both ends of the range are a bit arbitrary
at the moment, but they are the limits of current testing of the
library. As such they may be increased in the future.
*/
class greg_year : public greg_year_rep {
public:
greg_year(unsigned short year) : greg_year_rep(year) {}
operator unsigned short() const {return value_;}
private:
include/boost/date_time/gregorian/gregorian_types.hpp view on Meta::CPAN
* $Date: 2004/06/29 16:29:21 $
*/
/*! @file gregorian_types.hpp
Single file header that defines most of the types for the gregorian
date-time system.
*/
#include "boost/date_time/date.hpp"
#include "boost/date_time/period.hpp"
#include "boost/date_time/gregorian/greg_calendar.hpp"
#include "boost/date_time/gregorian/greg_duration.hpp"
#if defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
#include "boost/date_time/gregorian/greg_duration_types.hpp"
#endif
#include "boost/date_time/gregorian/greg_date.hpp"
#include "boost/date_time/date_generators.hpp"
#include "boost/date_time/date_clock_device.hpp"
#include "boost/date_time/date_iterator.hpp"
#include "boost/date_time/adjust_functors.hpp"
include/boost/date_time/gregorian_calendar.hpp view on Meta::CPAN
* file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
* Author: Jeff Garland
* $Date: 2003/12/14 13:59:58 $
*/
namespace boost {
namespace date_time {
//! An implementation of the Gregorian calendar
/*! This is a parameterized implementation of a proleptic Gregorian Calendar that
can be used in the creation of date systems or just to perform calculations.
All the methods of this class are static functions, so the intent is to
never create instances of this class.
@param ymd_type_ Struct type representing the year, month, day. The ymd_type must
define a of types for the year, month, and day. These types need to be
arithmetic types.
@param date_int_type_ Underlying type for the date count. Must be an arithmetic type.
*/
template<typename ymd_type_, typename date_int_type_>
class gregorian_calendar_base {
public:
//! define a type a date split into components
typedef ymd_type_ ymd_type;
//! define a type for representing months
typedef typename ymd_type::month_type month_type;
//! define a type for representing days
typedef typename ymd_type::day_type day_type;
//! Type to hold a stand alone year value (eg: 2002)
typedef typename ymd_type::year_type year_type;
//! Define the integer type to use for internal calculations
include/boost/date_time/gregorian_calendar.hpp view on Meta::CPAN
static ymd_type epoch();
static unsigned short days_in_week();
};
} } //namespace
#ifndef NO_BOOST_DATE_TIME_INLINE
#include "boost/date_time/gregorian_calendar.ipp"
#endif
#endif
include/boost/date_time/gregorian_calendar.ipp view on Meta::CPAN
#endif
namespace boost {
namespace date_time {
//! Return the day of the week (0==Sunday, 1==Monday, etc)
/*! Converts a the year-month-day into a day of the week number
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
unsigned short
gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
unsigned short y = static_cast<unsigned short>(ymd.year - a);
unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 2);
unsigned short d = static_cast<unsigned short>((ymd.day + y + (y/4) - (y/100) + (y/400) + (31*m)/12) % 7);
//std::cout << year << "-" << month << "-" << day << " is day: " << d << "\n";
return d;
}
//!Return the iso week number for the date
/*!Implements the rules associated with the iso 8601 week number.
Basically the rule is that Week 1 of the year is the week that contains
January 4th or the week that contains the first Thursday in January.
Reference for this algorithm is the Calendar FAQ by Claus Tondering, April 2000.
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
int
gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
unsigned long juliantoday = julian_day_number(ymd);
unsigned long day = (julianbegin + 3) % 7;
unsigned long week = (juliantoday + day - julianbegin + 4)/7;
if ((week >= 1) && (week <= 52)) {
return week;
}
if ((week == 53)) {
include/boost/date_time/gregorian_calendar.ipp view on Meta::CPAN
return week; //not reachable -- well except if day == 5 and is_leap_year != true
}
//! Convert a ymd_type into a day number
/*! The day number is an absolute number of days since the start of count
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
date_int_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
{
unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
unsigned long d = ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
return d;
}
//! Convert a year-month-day into the julian day number
/*! Since this implementation uses julian day internally, this is the same as the day_number.
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
date_int_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
{
return day_number(ymd);
}
//! Convert year-month-day into a modified julian day number
/*! The day number is an absolute number of days.
* MJD 0 thus started on 17 Nov 1858(Gregorian) at 00:00:00 UTC
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
long
gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
{
return julian_day_number(ymd)-2400001; //prerounded
}
//! Change a day number into a year-month-day
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
ymd_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
{
date_int_type a = dayNumber + 32044;
date_int_type b = (4*a + 3)/146097;
date_int_type c = a-((146097*b)/4);
date_int_type d = (4*c + 3)/1461;
date_int_type e = c - (1461*d)/4;
date_int_type m = (5*e + 2)/153;
unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));
//std::cout << year << "-" << month << "-" << day << "\n";
return ymd_type(static_cast<unsigned short>(year),month,day);
}
//! Change a day number into a year-month-day
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
ymd_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
{
date_int_type a = dayNumber + 32044;
date_int_type b = (4*a+3)/146097;
date_int_type c = a - ((146097*b)/4);
date_int_type d = (4*c + 3)/1461;
date_int_type e = c - ((1461*d)/4);
date_int_type m = (5*e + 2)/153;
unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));
//std::cout << year << "-" << month << "-" << day << "\n";
return ymd_type(year,month,day);
}
//! Change a modified julian day number into a year-month-day
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
ymd_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(long dayNumber) {
date_int_type jd = dayNumber + 2400001; //is 2400000.5 prerounded
return from_julian_day_number(jd);
}
//! Determine if the provided year is a leap year
/*!
*@return true if year is a leap year, false otherwise
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
bool
gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
{
//divisible by 4, not if divisible by 100, but true if divisible by 400
return (!(year % 4)) && ((year % 100) || (!(year % 400)));
}
//! Calculate the last day of the month
/*! Find the day which is the end of the month given year and month
* No error checking is performed.
*/
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
unsigned short
gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
month_type month)
{
switch (month) {
case 2:
if (is_leap_year(year)) {
return 29;
} else {
return 28;
};
case 4:
include/boost/date_time/gregorian_calendar.ipp view on Meta::CPAN
default:
return 31;
};
}
//! Provide the ymd_type specification for the calandar start
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
ymd_type_
gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
{
return ymd_type(1400,1,1);
}
//! Defines length of a week for week calculations
template<typename ymd_type_, typename date_int_type_>
BOOST_DATE_TIME_INLINE
unsigned short
gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
{
return 7;
}
} } //namespace gregorian
include/boost/date_time/local_time/posix_time_zone.hpp view on Meta::CPAN
static_cast<nkday::week_num>(sw),sd,sm),
nth_last_dst_rule::start_rule(
static_cast<nkday::week_num>(ew),ed,em)
)
);
}
//! Julian day. Feb29 is never counted, even in leap years
// expects range of 1-365
void julian_no_leap(const std::string& s, const std::string& e){
typedef gregorian::gregorian_calendar calendar;
const unsigned short year = 2001; // Non-leap year
unsigned short sm=1;
int sd=0;
sd = lexical_cast<int>(s.substr(1)); // skip 'J'
while(sd >= calendar::end_of_month_day(year,sm)){
sd -= calendar::end_of_month_day(year,sm++);
}
unsigned short em=1;
int ed=0;
ed = lexical_cast<int>(e.substr(1)); // skip 'J'
while(ed > calendar::end_of_month_day(year,em)){
ed -= calendar::end_of_month_day(year,em++);
}
dst_calc_rules_ = shared_ptr<dst_calc_rule>(
new partial_date_dst_rule(
partial_date_dst_rule::start_rule(
sd, static_cast<date_time::months_of_year>(sm)),
partial_date_dst_rule::end_rule(
ed, static_cast<date_time::months_of_year>(em))
)
);
include/boost/date_time/time_system_counted.hpp view on Meta::CPAN
namespace date_time {
//! Time representation that uses a single integer count
template<class config>
struct counted_time_rep
{
typedef typename config::int_type int_type;
typedef typename config::date_type date_type;
typedef typename config::impl_type impl_type;
typedef typename date_type::duration_type date_duration_type;
typedef typename date_type::calendar_type calendar_type;
typedef typename date_type::ymd_type ymd_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::resolution_traits resolution_traits;
counted_time_rep(const date_type& d, const time_duration_type& tod)
: time_count_(1)
{
if(d.is_infinity() || d.is_not_a_date() || tod.is_special()) {
time_count_ = tod.get_rep() + d.day_count();
//std::cout << time_count_ << std::endl;
include/boost/date_time/time_system_counted.hpp view on Meta::CPAN
{}
explicit counted_time_rep(impl_type count) :
time_count_(count)
{}
date_type date() const
{
if(time_count_.is_special()) {
return date_type(time_count_.as_special());
}
else {
typename calendar_type::date_int_type dc = day_count();
//std::cout << "time_rep here:" << dc << std::endl;
ymd_type ymd = calendar_type::from_day_number(dc);
return date_type(ymd);
}
}
//int_type day_count() const
unsigned long day_count() const
{
/* resolution_traits::as_number returns a boost::int64_t &
* frac_sec_per_day is also a boost::int64_t so, naturally,
* the division operation returns a boost::int64_t.
* The static_cast to an unsigned long is ok (results in no data loss)
( run in 0.532 second using v1.01-cache-2.11-cpan-5dc5da66d9d )