passenger_dudemeister 3.0.1

data/ext/boost/date_time/dst_rules.hpp

@@ -0,0 +1,391 @@
+#ifndef DATE_TIME_DST_RULES_HPP__
+#define DATE_TIME_DST_RULES_HPP__
+
+/* Copyright (c) 2002,2003, 2007 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+/*! @file dst_rules.hpp
+  Contains template class to provide static dst rule calculations
+*/
+
+#include "boost/date_time/date_generators.hpp"
+#include "boost/date_time/period.hpp"
+#include "boost/date_time/date_defs.hpp"
+#include <stdexcept>
+
+namespace boost {
+  namespace date_time {
+
+    enum time_is_dst_result {is_not_in_dst, is_in_dst, 
+                             ambiguous, invalid_time_label};
+
+
+    //! Dynamic class used to caluclate dst transition information
+    template<class date_type_, 
+             class time_duration_type_>
+    class dst_calculator
+    {
+    public:
+      typedef time_duration_type_ time_duration_type;
+      typedef date_type_ date_type;
+
+      //! Check the local time offset when on dst start day
+      /*! On this dst transition, the time label between
+       *  the transition boundary and the boudary + the offset
+       *  are invalid times.  If before the boundary then still 
+       *  not in dst.  
+       *@param time_of_day Time offset in the day for the local time
+       *@param dst_start_offset_minutes Local day offset for start of dst
+       *@param dst_length_minutes Number of minutes to adjust clock forward
+       *@retval status of time label w.r.t. dst
+       */
+      static time_is_dst_result 
+      process_local_dst_start_day(const time_duration_type& time_of_day,
+                                  unsigned int dst_start_offset_minutes,
+                                  long dst_length_minutes)
+      {
+        //std::cout << "here" << std::endl;
+        if (time_of_day < time_duration_type(0,dst_start_offset_minutes,0)) {
+          return is_not_in_dst;
+        }
+        long offset = dst_start_offset_minutes + dst_length_minutes;
+        if (time_of_day >= time_duration_type(0,offset,0)) {
+          return is_in_dst;
+        }
+        return invalid_time_label; 
+      }
+
+      //! Check the local time offset when on the last day of dst
+      /*! This is the calculation for the DST end day.  On that day times
+       *  prior to the conversion time - dst_length (1 am in US) are still 
+       *  in dst.  Times between the above and the switch time are 
+       *  ambiguous.  Times after the start_offset are not in dst.
+       *@param time_of_day Time offset in the day for the local time
+       *@param dst_end_offset_minutes Local time of day for end of dst
+       *@retval status of time label w.r.t. dst
+       */
+      static time_is_dst_result 
+      process_local_dst_end_day(const time_duration_type& time_of_day,
+                                unsigned int dst_end_offset_minutes,
+                                long dst_length_minutes)
+      {
+        //in US this will be 60 so offset in day is 1,0,0
+        int offset = dst_end_offset_minutes-dst_length_minutes;
+        if (time_of_day < time_duration_type(0,offset,0)) {
+          return is_in_dst;
+        }
+        if (time_of_day >= time_duration_type(0,dst_end_offset_minutes,0)) {
+          return is_not_in_dst;
+        }
+        return ambiguous;
+      }
+
+      //! 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.
+       *  @param current_day The day to check for dst
+       *  @param time_of_day Time offset within the day to check 
+       *  @param dst_start_day  Starting day of dst for the given locality
+       *  @param dst_start_offset Time offset within day for dst boundary
+       *  @param dst_end_day    Ending day of dst for the given locality
+       *  @param dst_end_offset Time offset within day given in dst for dst boundary
+       *  @param dst_length lenght of dst adjusment
+       *  @retval The time is either ambiguous, invalid, in dst, or not in dst
+       */
+      static time_is_dst_result 
+      local_is_dst(const date_type& current_day,
+                   const time_duration_type& time_of_day,
+                   const date_type& dst_start_day,
+                   const time_duration_type& dst_start_offset,
+                   const date_type& dst_end_day,
+                   const time_duration_type& dst_end_offset,
+                   const time_duration_type& dst_length_minutes)
+      {
+        unsigned int start_minutes = 
+          dst_start_offset.hours() * 60 + dst_start_offset.minutes();
+        unsigned int end_minutes = 
+          dst_end_offset.hours() * 60 + dst_end_offset.minutes();
+        long length_minutes =  
+          dst_length_minutes.hours() * 60 + dst_length_minutes.minutes();
+
+        return local_is_dst(current_day, time_of_day,
+                            dst_start_day, start_minutes,
+                            dst_end_day, end_minutes,
+                            length_minutes);
+      }
+
+      //! 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.
+       *  @param current_day The day to check for dst
+       *  @param time_of_day Time offset within the day to check 
+       *  @param dst_start_day  Starting day of dst for the given locality
+       *  @param dst_start_offset_minutes Offset within day for dst 
+       *         boundary (eg 120 for US which is 02:00:00)
+       *  @param dst_end_day    Ending day of dst for the given locality
+       *  @param dst_end_offset_minutes Offset within day given in dst for dst 
+       *         boundary (eg 120 for US which is 02:00:00)
+       *  @param dst_length_minutes Length of dst adjusment (eg: 60 for US)
+       *  @retval The time is either ambiguous, invalid, in dst, or not in dst
+       */
+      static time_is_dst_result 
+      local_is_dst(const date_type& current_day,
+                   const time_duration_type& time_of_day,
+                   const date_type& dst_start_day,
+                   unsigned int dst_start_offset_minutes,
+                   const date_type& dst_end_day,
+                   unsigned int dst_end_offset_minutes,
+                   long dst_length_minutes)
+      {
+        //in northern hemisphere dst is in the middle of the year
+        if (dst_start_day < dst_end_day) {
+          if ((current_day > dst_start_day) && (current_day < dst_end_day)) {
+            return is_in_dst;
+          }
+          if ((current_day < dst_start_day) || (current_day > dst_end_day)) {
+            return is_not_in_dst;
+          }
+        }
+        else {//southern hemisphere dst is at begining /end of year
+          if ((current_day < dst_start_day) && (current_day > dst_end_day)) {
+            return is_not_in_dst;
+          }
+          if ((current_day > dst_start_day) || (current_day < dst_end_day)) {
+            return is_in_dst;
+          }
+        }
+
+        if (current_day == dst_start_day) {
+          return process_local_dst_start_day(time_of_day,
+                                             dst_start_offset_minutes,
+                                             dst_length_minutes);
+        }
+      
+        if (current_day == dst_end_day) {
+          return process_local_dst_end_day(time_of_day,
+                                           dst_end_offset_minutes,
+                                           dst_length_minutes);
+        }
+        //you should never reach this statement
+        return invalid_time_label;
+      }
+
+    };
+
+
+    //! Compile-time configurable daylight savings time calculation engine
+    /* This template provides the ability to configure a daylight savings
+     * calculation at compile time covering all the cases.  Unfortunately
+     * because of the number of dimensions related to daylight savings
+     * calculation the number of parameters is high.  In addition, the
+     * start and end transition rules are complex types that specify 
+     * an algorithm for calculation of the starting day and ending
+     * day of daylight savings time including the month and day 
+     * specifications (eg: last sunday in October).
+     *
+     * @param date_type A type that represents dates, typically gregorian::date
+     * @param time_duration_type Used for the offset in the day calculations
+     * @param dst_traits A set of traits that define the rules of dst 
+     *        calculation.  The dst_trait must include the following:
+     * start_rule_functor - Rule to calculate the starting date of a
+     *                      dst transition (eg: last_kday_of_month).
+     * start_day - static function that returns month of dst start for 
+     *             start_rule_functor
+     * start_month -static function that returns day or day of week for 
+     *              dst start of dst
+     * end_rule_functor - Rule to calculate the end of dst day.
+     * end_day - static fucntion that returns end day for end_rule_functor
+     * end_month - static function that returns end month for end_rule_functor
+     * dst_start_offset_minutes - number of minutes from start of day to transition to dst -- 120 (or 2:00 am) is typical for the U.S. and E.U.
+     * 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) 
+      {
+
+        year_type y = d.year();
+        date_type dst_start = local_dst_start_day(y);
+        date_type dst_end   = local_dst_end_day(y);
+        return dstcalc::local_is_dst(d,td,
+                                     dst_start,
+                                     dst_traits::dst_start_offset_minutes(),
+                                     dst_end, 
+                                     dst_traits::dst_end_offset_minutes(), 
+                                     dst_traits::dst_shift_length_minutes());
+      
+      }
+
+      static bool is_dst_boundary_day(date_type d)
+      {
+        year_type y = d.year();
+        return ((d == local_dst_start_day(y)) ||
+                (d == local_dst_end_day(y)));
+      }
+
+      //! The time of day for the dst transition (eg: typically 01:00:00 or 02:00:00)
+      static time_duration_type dst_offset() 
+      {
+        return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
+      }
+
+      static date_type local_dst_start_day(year_type year)
+      {
+        return dst_traits::local_dst_start_day(year);      
+      }
+
+      static date_type local_dst_end_day(year_type year)
+      {
+        return dst_traits::local_dst_end_day(year);
+      }
+
+
+    };
+
+    //! Depricated: Class to calculate dst boundaries for US time zones
+    /* Use dst_calc_engine instead.
+     * In 2007 US/Canada DST rules changed
+     * (http://en.wikipedia.org/wiki/Energy_Policy_Act_of_2005#Change_to_daylight_saving_time).
+     */
+    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 date_time::nth_kday_of_month<date_type> nkday;
+      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) 
+      {
+
+        year_type y = d.year();
+        date_type dst_start = local_dst_start_day(y);
+        date_type dst_end   = local_dst_end_day(y);
+        return dstcalc::local_is_dst(d,td,
+                                     dst_start,dst_start_offset_minutes,
+                                     dst_end, dst_start_offset_minutes, 
+                                     dst_length_minutes);
+      
+      }
+
+
+      static bool is_dst_boundary_day(date_type d)
+      {
+        year_type y = d.year();
+        return ((d == local_dst_start_day(y)) ||
+                (d == local_dst_end_day(y)));
+      }
+
+      static date_type local_dst_start_day(year_type year)
+      {
+        if (year >= year_type(2007)) {
+          //second sunday in march
+          nkday ssim(nkday::second, Sunday, gregorian::Mar);
+          return ssim.get_date(year);      
+        } else {
+          //first sunday in april
+          fkday fsia(Sunday, gregorian::Apr);
+          return fsia.get_date(year);      
+        }
+      }
+
+      static date_type local_dst_end_day(year_type year)
+      {
+        if (year >= year_type(2007)) {
+          //first sunday in november
+          fkday fsin(Sunday, gregorian::Nov);
+          return fsin.get_date(year);      
+        } else {
+          //last sunday in october
+          lkday lsio(Sunday, gregorian::Oct);
+          return lsio.get_date(year);
+        }
+      }
+
+      static time_duration_type dst_offset()
+      {
+        return time_duration_type(0,dst_length_minutes,0);
+      }
+
+     private:
+
+
+    };
+
+    //! Used for local time adjustments in places that don't use dst
+    template<class date_type_, class time_duration_type_>
+    class null_dst_rules
+    {
+    public:
+      typedef time_duration_type_ time_duration_type;
+      typedef date_type_ date_type;
+
+
+      //! Calculates if the given local time is dst or not
+      /*! @retval Always is_not_in_dst since this is for zones without dst
+       */
+      static time_is_dst_result local_is_dst(const date_type&, 
+                                             const time_duration_type&) 
+      {
+        return is_not_in_dst;
+      }
+    
+      //! Calculates if the given utc time is in dst
+      static time_is_dst_result utc_is_dst(const date_type&, 
+                                           const time_duration_type&) 
+      {
+        return is_not_in_dst;
+      }
+
+      static bool is_dst_boundary_day(date_type d)
+      {
+        return false;
+      }
+
+      static time_duration_type dst_offset() 
+      {
+        return time_duration_type(0,0,0);
+      }
+
+    };
+
+
+  } } //namespace date_time
+
+
+
+#endif

data/ext/boost/date_time/filetime_functions.hpp

@@ -0,0 +1,170 @@
+#ifndef DATE_TIME_FILETIME_FUNCTIONS_HPP__
+#define DATE_TIME_FILETIME_FUNCTIONS_HPP__
+
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2009-06-06 07:24:09 -0400 (Sat, 06 Jun 2009) $
+ */
+
+/*! @file filetime_functions.hpp
+ * Function(s) for converting between a FILETIME structure and a
+ * time object. This file is only available on systems that have
+ * BOOST_HAS_FTIME defined.
+ */
+
+#include <boost/date_time/compiler_config.hpp>
+
+#if defined(BOOST_HAS_FTIME) // skip this file if no FILETIME
+
+#if defined(BOOST_USE_WINDOWS_H)
+#  include <windows.h>
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/date_time/time.hpp>
+#include <boost/date_time/date_defs.hpp>
+
+namespace boost {
+
+namespace date_time {
+
+namespace winapi {
+
+#if !defined(BOOST_USE_WINDOWS_H)
+
+    extern "C" {
+
+        struct FILETIME
+        {
+            boost::uint32_t dwLowDateTime;
+            boost::uint32_t dwHighDateTime;
+        };
+        struct SYSTEMTIME
+        {
+            boost::uint16_t wYear;
+            boost::uint16_t wMonth;
+            boost::uint16_t wDayOfWeek;
+            boost::uint16_t wDay;
+            boost::uint16_t wHour;
+            boost::uint16_t wMinute;
+            boost::uint16_t wSecond;
+            boost::uint16_t wMilliseconds;
+        };
+
+        __declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(FILETIME* lpFileTime);
+        __declspec(dllimport) int __stdcall FileTimeToLocalFileTime(const FILETIME* lpFileTime, FILETIME* lpLocalFileTime);
+        __declspec(dllimport) void __stdcall GetSystemTime(SYSTEMTIME* lpSystemTime);
+        __declspec(dllimport) int __stdcall SystemTimeToFileTime(const SYSTEMTIME* lpSystemTime, FILETIME* lpFileTime);
+
+    } // extern "C"
+
+#endif // defined(BOOST_USE_WINDOWS_H)
+
+    typedef FILETIME file_time;
+    typedef SYSTEMTIME system_time;
+
+    inline void get_system_time_as_file_time(file_time& ft)
+    {
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+        // Some runtime library implementations expect local times as the norm for ctime.
+        file_time ft_utc;
+        GetSystemTimeAsFileTime(&ft_utc);
+        FileTimeToLocalFileTime(&ft_utc, &ft);
+#elif defined(BOOST_NO_GETSYSTEMTIMEASFILETIME)
+        system_time st;
+        GetSystemTime(&st);
+        SystemTimeToFileTime(&st, &ft);
+#else
+        GetSystemTimeAsFileTime(&ft);
+#endif
+    }
+
+    /*!
+     * The function converts file_time into number of microseconds elapsed since 1970-Jan-01
+     *
+     * \note Only dates after 1970-Jan-01 are supported. Dates before will be wrapped.
+     *
+     * \note The function is templated on the FILETIME type, so that
+     *       it can be used with both native FILETIME and the ad-hoc
+     *       boost::date_time::winapi::file_time type.
+     */
+    template< typename FileTimeT >
+    inline boost::uint64_t file_time_to_microseconds(FileTimeT const& ft)
+    {
+        /* shift is difference between 1970-Jan-01 & 1601-Jan-01
+        * in 100-nanosecond intervals */
+        const uint64_t shift = 116444736000000000ULL; // (27111902 << 32) + 3577643008
+
+        union {
+            FileTimeT as_file_time;
+            uint64_t as_integer; // 100-nanos since 1601-Jan-01
+        } caster;
+        caster.as_file_time = ft;
+
+        caster.as_integer -= shift; // filetime is now 100-nanos since 1970-Jan-01
+        return (caster.as_integer / 10); // truncate to microseconds
+    }
+
+} // namespace winapi
+
+//! Create a time object from an initialized FILETIME struct.
+/*!
+ * Create a time object from an initialized FILETIME struct.
+ * A FILETIME struct holds 100-nanosecond units (0.0000001). When
+ * built with microsecond resolution the file_time's sub second value
+ * will be truncated. Nanosecond resolution has no truncation.
+ *
+ * \note The function is templated on the FILETIME type, so that
+ *       it can be used with both native FILETIME and the ad-hoc
+ *       boost::date_time::winapi::file_time type.
+ */
+template< typename TimeT, typename FileTimeT >
+inline
+TimeT time_from_ftime(const FileTimeT& ft)
+{
+    typedef typename TimeT::date_type date_type;
+    typedef typename TimeT::date_duration_type date_duration_type;
+    typedef typename TimeT::time_duration_type time_duration_type;
+
+    // https://svn.boost.org/trac/boost/ticket/2523
+    // Since this function can be called with arbitrary times, including ones that
+    // are before 1970-Jan-01, we'll have to cast the time a bit differently,
+    // than it is done in the file_time_to_microseconds function. This allows to
+    // avoid integer wrapping for dates before 1970-Jan-01.
+    union {
+        FileTimeT as_file_time;
+        uint64_t as_integer; // 100-nanos since 1601-Jan-01
+    } caster;
+    caster.as_file_time = ft;
+
+    uint64_t sec = caster.as_integer / 10000000UL;
+    uint32_t sub_sec = (caster.as_integer % 10000000UL) // 100-nanoseconds since the last second
+#if !defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+        / 10; // microseconds since the last second
+#else
+        * 100; // nanoseconds since the last second
+#endif
+
+    // split sec into usable chunks: days, hours, minutes, & seconds
+    const uint32_t sec_per_day = 86400; // seconds per day
+    uint32_t days = static_cast< uint32_t >(sec / sec_per_day);
+    uint32_t tmp = static_cast< uint32_t >(sec % sec_per_day);
+    uint32_t hours = tmp / 3600; // sec_per_hour
+    tmp %= 3600;
+    uint32_t minutes = tmp / 60; // sec_per_min
+    tmp %= 60;
+    uint32_t seconds = tmp; // seconds
+
+    date_duration_type dd(days);
+    date_type d = date_type(1601, Jan, 01) + dd;
+    return TimeT(d, time_duration_type(hours, minutes, seconds, sub_sec));
+}
+
+}} // boost::date_time
+
+#endif // BOOST_HAS_FTIME
+
+#endif // DATE_TIME_FILETIME_FUNCTIONS_HPP__