Ye_Ol_Pi_Shack
/
CppCMS
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
ChipMaster's trial hacks on C++CMS starting with v1.2.1. Not sure I'll follow on with the v2 since it looks to be breaking and mostly frivolous.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1248 Commits
2 Branches
13 MiB
 
 
 
 
 
 
Tree: d1de6e5074
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1de6e5074'
${ noResults }
CppCMS/booster/lib/locale/src/util/gregorian.cpp

856 lines
33 KiB
Raw Blame History 

  1. //

  2. //  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)

  3. //

  4. //  Distributed under the Boost Software License, Version 1.0. (See

  5. //  accompanying file LICENSE_1_0.txt or copy at

  6. //  http://www.boost.org/LICENSE_1_0.txt)

  7. //

  8. #define BOOSTER_SOURCE

  9. #include <booster/config.h>

  10. #ifdef BOOSTER_MSVC

  11. #  pragma warning(disable : 4996)

  12. #endif

  13. #include <locale>

  14. #include <string>

  15. #include <ios>

  16. #include <booster/locale/date_time_facet.h>

  17. #include <booster/locale/date_time.h>

  18. #include <stdlib.h>

  19. #include <ctime>

  20. #include <booster/auto_ptr_inc.h>

  21. #include <algorithm>

  22. #include <limits>

  23. 

  24. #include "timezone.h"

  25. #include "gregorian.h"

  26. 

  27. namespace booster {

  28. namespace locale {

  29. namespace util {

  30.     namespace {

  31. 

  32.         int is_leap(int year)

  33.         {

  34.             if(year % 400 == 0)

  35.                 return 1;

  36.             if(year % 100 == 0)

  37.                 return 0;

  38.             if(year % 4 == 0)

  39.                 return 1;

  40.             return 0;

  41.         }

  42. 

  43.         int days_in_month(int year,int month)

  44.         {

  45.             static const int tbl[2][12] = {

  46.                 { 31,28,31,30,31,30,31,31,30,31,30,31 },

  47.                 { 31,29,31,30,31,30,31,31,30,31,30,31 }

  48.             };

  49.             return tbl[is_leap(year)][month - 1];

  50.         }

  51. 

  52.         inline int days_from_0(int year)

  53.         {

  54.             year--;

  55.             return 365 * year + (year / 400) - (year/100) + (year / 4);

  56.         }

  57. 

  58.         int days_from_1970(int year)

  59.         {

  60.             static const int days_from_0_to_1970 = days_from_0(1970);

  61.             return days_from_0(year) - days_from_0_to_1970;

  62.         }

  63. 

  64.         int days_from_1jan(int year,int month,int day)

  65.         {

  66.             static const int days[2][12] = {

  67.                 { 0,31,59,90,120,151,181,212,243,273,304,334 },

  68.                 { 0,31,60,91,121,152,182,213,244,274,305,335 }

  69.             };

  70.             return days[is_leap(year)][month-1] + day - 1;

  71.         }

  72.         

  73.         time_t internal_timegm(std::tm const *t)

  74.         {

  75.             int year = t->tm_year + 1900;

  76.             int month = t->tm_mon;

  77.             if(month > 11) {

  78.                 year += month/12;

  79.                 month %= 12;

  80.             }

  81.             else if(month < 0) {

  82.                 int years_diff = (-month + 11)/12;

  83.                 year -= years_diff;

  84.                 month+=12 * years_diff;

  85.             }

  86.             month++;

  87.             int day = t->tm_mday;

  88.             int day_of_year = days_from_1jan(year,month,day);

  89.             int days_since_epoch = days_from_1970(year) + day_of_year;

  90.             

  91.             time_t seconds_in_day = 3600 * 24;

  92.             time_t result =  seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;

  93.             

  94.             return result;

  95.         }

  96. 

  97.     } // anon

  98. 

  99. 

  100. 

  101. 

  102.     namespace {

  103. 

  104.         // Locale dependent data

  105. 

  106.         bool comparator(char const *left,char const *right)

  107.         {

  108.             return strcmp(left,right) < 0;

  109.         }

  110.         

  111.         //

  112.         // Ref: CLDR 1.9 common/supplemental/supplementalData.xml

  113.         //

  114.         // monday - default

  115.         // fri - MV

  116.         // sat - AE AF BH DJ DZ EG ER ET IQ IR JO KE KW LY MA OM QA SA SD SO SY TN YE

  117.         // sun - AR AS AZ BW CA CN FO GE GL GU HK IL IN JM JP KG KR LA MH MN MO MP MT NZ PH PK SG TH TT TW UM US UZ VI ZW

  118.         //

  119. 

  120.         int first_day_of_week(char const *terr) {

  121.             static char const * const sat[] = {

  122.                 "AE","AF","BH","DJ","DZ","EG","ER","ET","IQ","IR",

  123.                 "JO","KE","KW","LY","MA","OM","QA","SA","SD","SO",

  124.                 "SY","TN","YE"

  125.             };

  126.             // workaround for Sun Solaris !@#%@#$%@#$%234

  127.             #ifdef sun

  128.             #undef sun

  129.             #endif

  130.             static char const * const sun[] = {

  131.                 "AR","AS","AZ","BW","CA","CN","FO","GE","GL","GU",

  132.                 "HK","IL","IN","JM","JP","KG","KR","LA","MH","MN",

  133.                 "MO","MP","MT","NZ","PH","PK","SG","TH","TT","TW",

  134.                 "UM","US","UZ","VI","ZW" 

  135.             };

  136.             if(strcmp(terr,"MV") == 0)

  137.                 return 5; // fri

  138.             if(std::binary_search<char const * const *>(sat,sat+sizeof(sat)/(sizeof(sat[0])),terr,comparator))

  139.                 return 6; // sat

  140.             if(std::binary_search<char const * const *>(sun,sun+sizeof(sun)/(sizeof(sun[0])),terr,comparator))

  141.                 return 0; // sun

  142.             // default

  143.             return 1; // mon

  144.         }

  145.     }

  146. 

  147.     class gregorian_calendar : public abstract_calendar {

  148.     public:

  149.             

  150.             gregorian_calendar(std::string const &terr)

  151.             {

  152.                 first_day_of_week_ = first_day_of_week(terr.c_str());

  153.                 time_ = time(0);

  154.                 is_local_ = true;

  155.                 tzoff_ = 0;

  156.                 from_time(time_);

  157.             }

  158.                 

  159.             ///

  160.             /// Make a polymorphic copy of the calendar

  161.             ///

  162.             virtual gregorian_calendar *clone() const

  163.             {

  164.                 return new gregorian_calendar(*this);

  165.             }

  166. 

  167.             ///

  168.             /// Set specific \a value for period \a p, note not all values are settable.

  169.             ///

  170.             virtual void set_value(period::marks::period_mark p,int value) 

  171.             {

  172.                 using namespace period::marks;

  173.                 switch(p) {

  174.                 case era:                        ///< Era i.e. AC, BC in Gregorian and Julian calendar, range [0,1]

  175.                     return;

  176.                 case year:                       ///< Year, it is calendar specific

  177.                 case extended_year:              ///< Extended year for Gregorian/Julian calendars, where 1 BC == 0, 2 BC == -1.

  178.                     tm_updated_.tm_year = value - 1900;

  179.                     break;

  180.                 case month:

  181.                     tm_updated_.tm_mon = value;

  182.                     break;

  183.                 case day:

  184.                     tm_updated_.tm_mday = value;

  185.                     break;

  186.                 case hour:                       ///< 24 clock hour [0..23]

  187.                     tm_updated_.tm_hour = value;

  188.                     break;

  189.                 case hour_12:                    ///< 12 clock hour [0..11]

  190.                     tm_updated_.tm_hour = tm_updated_.tm_hour / 12 * 12 + value;

  191.                     break;

  192.                 case am_pm:                      ///< am or pm marker, [0..1]

  193.                     tm_updated_.tm_hour = 12 * value + tm_updated_.tm_hour % 12;

  194.                     break;

  195.                 case minute:                     ///< minute [0..59]

  196.                     tm_updated_.tm_min = value;

  197.                     break;

  198.                 case second:

  199.                     tm_updated_.tm_sec = value;

  200.                     break;

  201.                 case day_of_year:

  202.                     normalize();

  203.                     tm_updated_.tm_mday += (value - (tm_updated_.tm_yday + 1));

  204.                     break;

  205.                 case day_of_week:           ///< Day of week, starting from Sunday, [1..7]

  206.                     if(value < 1) // make sure it is positive 

  207.                         value += (-value / 7) * 7 + 7;

  208.                     // convert to local DOW

  209.                     value = (value - 1 - first_day_of_week_ + 14) % 7 + 1;

  210.                     // fall throght

  211.                 case day_of_week_local:     ///< Local day of week, for example in France Monday is 1, in US Sunday is 1, [1..7]

  212.                     normalize();

  213.                     tm_updated_.tm_mday += (value - 1) - (tm_updated_.tm_wday - first_day_of_week_ + 7) % 7;

  214.                     break;

  215.                 case day_of_week_in_month:  ///< Original number of the day of the week in month. (1st sunday, 2nd sunday etc)

  216.                 case week_of_year:          ///< The week number in the year, 4 is the minimal number of days to be in month

  217.                 case week_of_month:         ///< The week number withing current month

  218.                     {

  219.                         normalize();

  220.                         int current_week = get_value(p,current);

  221.                         int diff = 7 * (value - current_week);

  222.                         tm_updated_.tm_mday += diff;

  223.                     }

  224.                     break;

  225.                 case period::marks::first_day_of_week:          ///< For example Sunday in US, Monday in France

  226.                 default:

  227.                     return;

  228.                 }

  229.                 normalized_ = false;

  230.             }

  231. 

  232.             void normalize()

  233.             {

  234.                 if(!normalized_) {

  235.                     std::tm val = tm_updated_;

  236.                     val.tm_isdst = -1;

  237.                     val.tm_wday = -1; // indecator of error

  238.                     time_t point = -1;

  239.                     if(is_local_) {

  240.                         point = mktime(&val);

  241.                         if(point == static_cast<time_t>(-1)){

  242.                             #ifndef BOOSTER_WIN_NATIVE

  243.                             // windows does not handle negative time_t, under other plaforms

  244.                             // it may be actually valid value in  1969-12-31 23:59:59

  245.                             // so we check that a filed was updated - does not happen in case of error

  246.                             if(val.tm_wday == -1)

  247.                             #endif

  248.                             {

  249.                                 throw date_time_error("boost::locale::gregorian_calendar: invalid time");

  250.                             }

  251.                         }

  252.                     }

  253.                     else {

  254.                         point = internal_timegm(&val);

  255.                         #ifdef BOOSTER_WIN_NATIVE

  256.                         // Windows uses TLS, thread safe

  257.                         std::tm *revert_point = 0;

  258.                         if(point < 0  || (revert_point = gmtime(&point)) == 0)

  259.                             throw date_time_error("boost::locale::gregorian_calendar time is out of range");

  260.                         val = *revert_point;

  261.                         #else

  262.                         if(!gmtime_r(&point,&val))

  263.                             throw date_time_error("boost::locale::gregorian_calendar invalid time");

  264.                         #endif

  265.                         

  266.                     }

  267.                     

  268.                     time_ = point - tzoff_;

  269.                     tm_ = val;

  270.                     tm_updated_ = val;

  271.                     normalized_ = true;

  272.                 }

  273.             }

  274. 

  275.             int get_week_number(int day,int wday) const

  276.             {

  277.                 ///

  278.                 /// This is the number of days that are considered withing

  279.                 /// period such that the week belongs there

  280.                 ///

  281.                 static const int days_in_full_week = 4;

  282. 

  283. 

  284.                 // Alaways use local week start

  285.                 int current_dow = (wday - first_day_of_week_ + 7) % 7;

  286.                 // Calculate local week day of Jan 1st.

  287.                 int first_week_day = (current_dow + 700 - day) % 7; 

  288.                     // adding something big devidable by 7

  289. 

  290.                 int start_of_period_in_weeks;

  291.                 if(first_week_day < days_in_full_week) {

  292.                     start_of_period_in_weeks = - first_week_day;

  293.                 }

  294.                 else {

  295.                     start_of_period_in_weeks = 7 - first_week_day;

  296.                 }

  297.                 int week_number_in_days = day - start_of_period_in_weeks;

  298.                 if(week_number_in_days < 0)

  299.                     return -1;

  300.                 return week_number_in_days / 7 + 1;

  301.             }

  302. 

  303.             ///

  304.             /// Get specific value for period \a p according to a value_type \a v

  305.             ///

  306.             virtual int get_value(period::marks::period_mark p,value_type v) const 

  307.             {

  308.                 using namespace period::marks;

  309.                 switch(p) {

  310.                 case era:

  311.                     return 1;

  312.                 case year:

  313.                 case extended_year:

  314.                     switch(v) {

  315.                     case absolute_minimum:

  316.                     case greatest_minimum:

  317.                     case actual_minimum:

  318.                         #ifdef BOOSTER_WIN_NATIVE

  319.                         return 1970; // Unix epoch windows can't handle negative time_t

  320.                         #else

  321.                         if(sizeof(time_t) == 4)

  322.                             return 1901; // minimal year with 32 bit time_t

  323.                         else

  324.                             return 1; 

  325.                         #endif

  326.                     case absolute_maximum:

  327.                     case least_maximum:

  328.                     case actual_maximum:

  329.                         if(sizeof(time_t) == 4)

  330.                             return 2038; // Y2K38 - maximal with 32 bit time_t

  331.                         else

  332.                             return std::numeric_limits<int>::max();

  333.                     case current:

  334.                         return tm_.tm_year + 1900;

  335.                     };

  336.                     break;

  337.                 case month:

  338.                     switch(v) {

  339.                     case absolute_minimum:

  340.                     case greatest_minimum:

  341.                     case actual_minimum:

  342.                         return 0;

  343.                     case absolute_maximum:

  344.                     case least_maximum:

  345.                     case actual_maximum:

  346.                         return 11;

  347.                     case current:

  348.                         return tm_.tm_mon;

  349.                     };

  350.                     break;

  351.                 case day:

  352.                     switch(v) {

  353.                     case absolute_minimum:

  354.                     case greatest_minimum:

  355.                     case actual_minimum:

  356.                         return 1;

  357.                     case absolute_maximum:

  358.                         return 31;

  359.                     case least_maximum:

  360.                         return 28;

  361.                     case actual_maximum:

  362.                         return days_in_month(tm_.tm_year + 1900,tm_.tm_mon + 1);

  363.                     case current:

  364.                         return tm_.tm_mday;

  365.                     };

  366.                     break;

  367.                 case day_of_year:                ///< The number of day in year, starting from 1

  368.                     switch(v) {

  369.                     case absolute_minimum:

  370.                     case greatest_minimum:

  371.                     case actual_minimum:

  372.                         return 1;

  373.                     case absolute_maximum:

  374.                         return 366;

  375.                     case least_maximum:

  376.                         return 365;

  377.                     case actual_maximum:

  378.                         return is_leap(tm_.tm_year + 1900) ? 366 : 365;

  379.                     case current:

  380.                         return tm_.tm_yday + 1;

  381.                     }

  382.                     break;

  383.                 case day_of_week:                ///< Day of week, starting from Sunday, [1..7]

  384.                     switch(v) {

  385.                     case absolute_minimum:

  386.                     case greatest_minimum:

  387.                     case actual_minimum:

  388.                         return 1;

  389.                     case absolute_maximum:

  390.                     case least_maximum:

  391.                     case actual_maximum:

  392.                         return 7;

  393.                     case current:

  394.                         return tm_.tm_wday + 1;

  395.                     }

  396.                     break;

  397.                 case day_of_week_local:     ///< Local day of week, for example in France Monday is 1, in US Sunday is 1, [1..7]

  398.                     switch(v) {

  399.                     case absolute_minimum:

  400.                     case greatest_minimum:

  401.                     case actual_minimum:

  402.                         return 1;

  403.                     case absolute_maximum:

  404.                     case least_maximum:

  405.                     case actual_maximum:

  406.                         return 7;

  407.                     case current:

  408.                         return (tm_.tm_wday - first_day_of_week_ + 7) % 7 + 1;

  409.                     }

  410.                     break;

  411.                 case hour:                       ///< 24 clock hour [0..23]

  412.                     switch(v) {

  413.                     case absolute_minimum:

  414.                     case greatest_minimum:

  415.                     case actual_minimum:

  416.                         return 0;

  417.                     case absolute_maximum:

  418.                     case least_maximum:

  419.                     case actual_maximum:

  420.                         return 23;

  421.                     case current:

  422.                         return tm_.tm_hour;

  423.                     }

  424.                     break;

  425.                 case hour_12:                    ///< 12 clock hour [0..11]

  426.                     switch(v) {

  427.                     case absolute_minimum:

  428.                     case greatest_minimum:

  429.                     case actual_minimum:

  430.                         return 0;

  431.                     case absolute_maximum:

  432.                     case least_maximum:

  433.                     case actual_maximum:

  434.                         return 11;

  435.                     case current:

  436.                         return tm_.tm_hour % 12;

  437.                     }

  438.                     break;

  439.                 case am_pm:                      ///< am or pm marker, [0..1]

  440.                     switch(v) {

  441.                     case absolute_minimum:

  442.                     case greatest_minimum:

  443.                     case actual_minimum:

  444.                         return 0;

  445.                     case absolute_maximum:

  446.                     case least_maximum:

  447.                     case actual_maximum:

  448.                         return 1;

  449.                     case current:

  450.                         return tm_.tm_hour >= 12 ? 1 : 0;

  451.                     }

  452.                     break;

  453.                 case minute:                     ///< minute [0..59]

  454.                     switch(v) {

  455.                     case absolute_minimum:

  456.                     case greatest_minimum:

  457.                     case actual_minimum:

  458.                         return 0;

  459.                     case absolute_maximum:

  460.                     case least_maximum:

  461.                     case actual_maximum:

  462.                         return 59;

  463.                     case current:

  464.                         return tm_.tm_min;

  465.                     }

  466.                     break;

  467.                 case second:                     ///< second [0..59]

  468.                     switch(v) {

  469.                     case absolute_minimum:

  470.                     case greatest_minimum:

  471.                     case actual_minimum:

  472.                         return 0;

  473.                     case absolute_maximum:

  474.                     case least_maximum:

  475.                     case actual_maximum:

  476.                         return 59;

  477.                     case current:

  478.                         return tm_.tm_sec;

  479.                     }

  480.                     break;

  481.                 case period::marks::first_day_of_week:          ///< For example Sunday in US, Monday in France

  482.                     return first_day_of_week_ + 1;

  483.                 

  484.                 case week_of_year:               ///< The week number in the year

  485.                     switch(v) {

  486.                     case absolute_minimum:

  487.                     case greatest_minimum:

  488.                     case actual_minimum:

  489.                         return 1;

  490.                     case absolute_maximum:

  491.                         return 53;

  492.                     case least_maximum:

  493.                         return 52;

  494.                     case actual_maximum:

  495.                         {

  496.                             int year = tm_.tm_year + 1900;

  497.                             int end_of_year_days = (is_leap(year) ? 366 : 365) - 1;

  498.                             int dow_of_end_of_year = (end_of_year_days - tm_.tm_yday + tm_.tm_wday) % 7;

  499.                             return get_week_number(end_of_year_days,dow_of_end_of_year);

  500.                         }

  501.                     case current:

  502.                         {

  503.                             int val = get_week_number(tm_.tm_yday,tm_.tm_wday);

  504.                             if(val < 0)

  505.                                 return 53;

  506.                             return val;

  507.                         }

  508.                     }

  509.                 case week_of_month:              ///< The week number withing current month

  510.                     switch(v) {

  511.                     case absolute_minimum:

  512.                     case greatest_minimum:

  513.                     case actual_minimum:

  514.                         return 1;

  515.                     case absolute_maximum:

  516.                         return 5;

  517.                     case least_maximum:

  518.                         return 4;

  519.                     case actual_maximum:

  520.                         {

  521.                             int end_of_month_days = days_in_month(tm_.tm_year + 1900,tm_.tm_mon + 1);

  522.                             int dow_of_end_of_month = (end_of_month_days - tm_.tm_mday + tm_.tm_wday) % 7;

  523.                             return get_week_number(end_of_month_days,dow_of_end_of_month);

  524.                         }

  525.                     case current:

  526.                         {

  527.                             int val = get_week_number(tm_.tm_mday,tm_.tm_wday);

  528.                             if(val < 0)

  529.                                 return 5;

  530.                             return val;

  531.                         }

  532.                     }

  533. 

  534.                 case day_of_week_in_month:       ///< Original number of the day of the week in month.

  535.                     switch(v) {

  536.                     case absolute_minimum:

  537.                     case greatest_minimum:

  538.                     case actual_minimum:

  539.                         return 1;

  540.                     case absolute_maximum:

  541.                         return 5;

  542.                     case least_maximum:

  543.                         return 4;

  544.                     case actual_maximum:

  545.                         if(tm_.tm_mon == 1 && !is_leap(tm_.tm_year + 1900)) {

  546.                             // only in february in non leap year is 28 days, the rest

  547.                             // conver more then 4 weeks

  548.                             return 4;

  549.                         }

  550.                         return 5;

  551.                     case current:

  552.                         return (tm_.tm_mday - 1) / 7 + 1;

  553.                     default:

  554.                         ;

  555.                     }

  556.                 default:

  557.                     ;

  558.                 }

  559.                 return 0;

  560.  

  561.             }

  562. 

  563.             ///

  564.             /// Set current time point

  565.             ///

  566.             virtual void set_time(posix_time const &p)

  567.             {

  568.                 from_time(static_cast<time_t>(p.seconds));

  569.             }

  570.             virtual posix_time get_time() const  

  571.             {

  572.                 posix_time pt = { time_, 0};

  573.                 return pt;

  574.             }

  575. 

  576.             ///

  577.             /// Set option for calendar, for future use

  578.             ///

  579.             virtual void set_option(calendar_option_type opt,int /*v*/)

  580.             {

  581.                 switch(opt) {

  582.                 case is_gregorian:

  583.                     throw date_time_error("is_gregorian is not settable options for calendar");

  584.                 case is_dst:

  585.                     throw date_time_error("is_dst is not settable options for calendar");

  586.                 default:

  587.                     ;

  588.                 }

  589.             }

  590.             ///

  591.             /// Get option for calendar, currently only check if it is Gregorian calendar

  592.             ///

  593.             virtual int get_option(calendar_option_type opt) const 

  594.             {

  595.                 switch(opt) {

  596.                 case is_gregorian:

  597.                     return 1;

  598.                 case is_dst:

  599.                     return tm_.tm_isdst == 1;

  600.                 default:

  601.                     return 0;

  602.                 };

  603.             }

  604. 

  605.             ///

  606.             /// Adjust period's \a p value by \a difference items using a update_type \a u.

  607.             /// Note: not all values are adjustable

  608.             ///

  609.             virtual void adjust_value(period::marks::period_mark p,update_type u,int difference)

  610.             {

  611.                 switch(u) {

  612.                 case move:

  613.                     {

  614.                         using namespace period::marks;

  615.                         switch(p) {

  616.                         case year:                       ///< Year, it is calendar specific

  617.                         case extended_year:              ///< Extended year for Gregorian/Julian calendars, where 1 BC == 0, 2 BC == -1.

  618.                             tm_updated_.tm_year +=difference;

  619.                             break;

  620.                         case month:

  621.                             tm_updated_.tm_mon +=difference;

  622.                             break;

  623.                         case day:

  624.                         case day_of_year:

  625.                         case day_of_week:                ///< Day of week, starting from Sunday, [1..7]

  626.                         case day_of_week_local: ///< Local day of week, for example in France Monday is 1, in US Sunday is 1, [1..7]

  627.                             tm_updated_.tm_mday +=difference;

  628.                             break;

  629.                         case hour:                       ///< 24 clock hour [0..23]

  630.                         case hour_12:                    ///< 12 clock hour [0..11]

  631.                             tm_updated_.tm_hour += difference;

  632.                             break;

  633.                         case am_pm:                      ///< am or pm marker, [0..1]

  634.                             tm_updated_.tm_hour += 12 * difference;

  635.                             break;

  636.                         case minute:                     ///< minute [0..59]

  637.                             tm_updated_.tm_min += difference;

  638.                             break;

  639.                         case second:

  640.                             tm_updated_.tm_sec += difference;

  641.                             break;

  642.                         case week_of_year:               ///< The week number in the year

  643.                         case week_of_month:              ///< The week number withing current month

  644.                         case day_of_week_in_month:       ///< Original number of the day of the week in month.

  645.                             tm_updated_.tm_mday +=difference * 7;

  646.                             break;

  647.                         default:

  648.                             ; // Not all values are adjustable

  649.                         }

  650.                         normalized_ = false;

  651.                         normalize();

  652.                     }

  653.                     break;

  654.                 case roll:

  655.                     { // roll

  656.                         int cur_min = get_value(p,actual_minimum);

  657.                         int cur_max = get_value(p,actual_maximum);

  658.                         int max_diff = cur_max - cur_min + 1;

  659.                         if(max_diff > 0) {

  660.                             int value = get_value(p,current);

  661.                             int addon = 0;

  662.                             if(difference < 0)

  663.                                 addon = ((-difference/max_diff) + 1) * max_diff;

  664.                             value = (value - cur_min + difference + addon) % max_diff + cur_min;

  665.                             set_value(p,value);

  666.                             normalize();

  667.                         }

  668.                     }

  669.                 default:

  670.                     ;

  671.                 }

  672.             }

  673. 

  674.             int get_diff(period::marks::period_mark p,int diff,gregorian_calendar const *other) const

  675.             {

  676.                 if(diff == 0)

  677.                     return 0;

  678.                 std::auto_ptr<gregorian_calendar> self(clone());

  679.                 self->adjust_value(p,move,diff);

  680.                 if(diff > 0){

  681.                     if(self->time_ > other->time_)

  682.                         return diff - 1;

  683.                     else

  684.                         return diff;

  685.                 }

  686.                 else {

  687.                     if(self->time_ < other->time_)

  688.                         return diff + 1;

  689.                     else

  690.                         return diff;

  691.                 }

  692.              }

  693. 

  694.             ///

  695.             /// Calculate the difference between this calendar  and \a other in \a p units

  696.             ///

  697.             virtual int difference(abstract_calendar const *other_cal,period::marks::period_mark p) const 

  698.             {

  699.                 std::auto_ptr<gregorian_calendar> keeper;

  700.                 gregorian_calendar const *other = dynamic_cast<gregorian_calendar const *>(other_cal);

  701.                 if(!other) {

  702.                     keeper.reset(clone());

  703.                     keeper->set_time(other_cal->get_time());

  704.                     other = keeper.get();

  705.                 }

  706. 

  707.                 int factor = 1; // for weeks vs days handling

  708. 

  709.                 using namespace period::marks;

  710.                 switch(p) {

  711.                 case era:

  712.                     return 0;

  713.                 case year:

  714.                 case extended_year:

  715.                     {

  716.                         int diff = other->tm_.tm_year - tm_.tm_year;

  717.                         return get_diff(period::marks::year,diff,other);

  718.                     }

  719.                 case month:

  720.                     {

  721.                         int diff = 12 * (other->tm_.tm_year - tm_.tm_year) 

  722.                                     + other->tm_.tm_mon - tm_.tm_mon;

  723.                         return get_diff(period::marks::month,diff,other);

  724.                     }

  725.                 case day_of_week_in_month:

  726.                 case week_of_month:

  727.                 case week_of_year:

  728.                     factor = 7;

  729.                     // fall 

  730.                 case day:

  731.                 case day_of_year:

  732.                 case day_of_week:

  733.                 case day_of_week_local:

  734.                     {

  735.                         int diff = other->tm_.tm_yday - tm_.tm_yday;

  736.                         if(other->tm_.tm_year != tm_.tm_year) {

  737.                             diff += days_from_0(other->tm_.tm_year + 1900) -

  738.                                     days_from_0(tm_.tm_year + 1900);

  739.                         }

  740.                         return get_diff(period::marks::day,diff,other) / factor;

  741.                     }

  742.                 case am_pm:

  743.                     return static_cast<int>( (other->time_ - time_) / (3600*12) );

  744.                 case hour:

  745.                 case hour_12:

  746.                     return static_cast<int>( (other->time_ - time_) / 3600 );

  747.                 case minute:

  748.                     return static_cast<int>( (other->time_ - time_) / 60 );

  749.                 case second:

  750.                     return static_cast<int>( other->time_ - time_  );

  751.                 default:

  752.                     return 0;

  753.                 };

  754.             }

  755. 

  756.             ///

  757.             /// Set time zone, empty - use system

  758.             ///

  759.             virtual void set_timezone(std::string const &tz)

  760.             {

  761.                 if(tz.empty()) {

  762.                     is_local_ = true;

  763.                     tzoff_ = 0;

  764.                 }

  765.                 else {

  766.                     is_local_ = false;

  767.                     tzoff_ = parse_tz(tz);

  768.                 }

  769.                 from_time(time_);

  770.                 time_zone_name_ = tz;

  771.             }

  772.             virtual std::string get_timezone() const

  773.             {

  774.                 return time_zone_name_;

  775.             }

  776. 

  777.             virtual bool same(abstract_calendar const *other) const 

  778.             {

  779.                 gregorian_calendar const *gcal = dynamic_cast<gregorian_calendar const *>(other);

  780.                 if(!gcal)

  781.                     return false;

  782.                 return 

  783.                     gcal->tzoff_ == tzoff_ 

  784.                     && gcal->is_local_ == is_local_

  785.                     && gcal->first_day_of_week_  == first_day_of_week_;

  786.             }

  787. 

  788.             virtual ~gregorian_calendar()

  789.             {

  790.             }

  791. 

  792.     private:

  793. 

  794.         void from_time(time_t point)

  795.         {

  796.             time_t real_point = point + tzoff_;

  797.             std::tm *t = 0;

  798.             #ifdef BOOSTER_WIN_NATIVE

  799.             // Windows uses TLS, thread safe

  800.             t = is_local_ ? localtime(&real_point) : gmtime(&real_point);

  801.             #else

  802.             std::tm tmp_tm;

  803.             t = is_local_ ? localtime_r(&real_point,&tmp_tm) : gmtime_r(&real_point,&tmp_tm);

  804.             #endif

  805.             if(!t) {

  806.                 throw date_time_error("boost::locale::gregorian_calendar: invalid time point");

  807.             }

  808.             tm_ = *t;

  809.             tm_updated_ = *t;

  810.             normalized_ = true;

  811.             time_ = point;

  812.         }

  813.         int first_day_of_week_;

  814.         time_t time_;

  815.         std::tm tm_;

  816.         std::tm tm_updated_;

  817.         bool normalized_;

  818.         bool is_local_;

  819.         int tzoff_;

  820.         std::string time_zone_name_;

  821.         

  822.     };

  823.     

  824.     abstract_calendar *create_gregorian_calendar(std::string const &terr)

  825.     {

  826.         return new gregorian_calendar(terr);

  827.     }

  828. 

  829.     class gregorian_facet : public calendar_facet {

  830.     public:

  831.         gregorian_facet(std::string const &terr,size_t refs = 0) : 

  832.             calendar_facet(refs),

  833.             terr_(terr)

  834.         {

  835.         }

  836.         virtual abstract_calendar *create_calendar() const 

  837.         {

  838.             return create_gregorian_calendar(terr_);

  839.         }

  840.     private:

  841.         std::string terr_;

  842.     };

  843.     

  844.     std::locale install_gregorian_calendar(std::locale const &in,std::string const &terr)

  845.     {

  846.         return std::locale(in,new gregorian_facet(terr));

  847.     }

  848. 

  849. 

  850. } // util

  851. } // locale 

  852. } //boost

  853. 

  854. 

  855. // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4