passenger-jmazzi 2.2.9

data/ext/boost/date_time/period_parser.hpp

@@ -0,0 +1,196 @@
+
+#ifndef DATETIME_PERIOD_PARSER_HPP___
+#define DATETIME_PERIOD_PARSER_HPP___
+
+/* Copyright (c) 2002-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: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+#include "boost/date_time/string_parse_tree.hpp"
+#include "boost/date_time/string_convert.hpp"
+
+
+namespace boost { namespace date_time {
+
+
+  //! Not a facet, but a class used to specify and control period parsing 
+  /*! Provides settings for the following:
+   *   - period_separator -- default '/'
+   *   - period_open_start_delimeter -- default '['
+   *   - period_open_range_end_delimeter -- default ')' 
+   *   - period_closed_range_end_delimeter -- default ']' 
+   *   - display_as_open_range, display_as_closed_range -- default closed_range
+   *
+   *  For a typical date_period, the contents of the input stream would be
+   *@code
+   *  [2004-Jan-04/2004-Feb-01]
+   *@endcode
+   * where the date format is controlled by the date facet
+   */
+  template<class date_type, typename CharT>
+  class period_parser { 
+  public:
+    typedef std::basic_string<CharT> string_type;
+    typedef CharT                    char_type;
+    //typedef typename std::basic_string<char_type>::const_iterator const_itr_type;
+    typedef std::istreambuf_iterator<CharT> stream_itr_type;
+    typedef string_parse_tree<CharT> parse_tree_type;
+    typedef typename parse_tree_type::parse_match_result_type match_results;
+    typedef std::vector<std::basic_string<CharT> > collection_type;
+    
+    static const char_type default_period_separator[2];
+    static const char_type default_period_start_delimeter[2];
+    static const char_type default_period_open_range_end_delimeter[2];
+    static const char_type default_period_closed_range_end_delimeter[2];
+
+    enum period_range_option { AS_OPEN_RANGE, AS_CLOSED_RANGE };
+
+    //! Constructor that sets up period parser options
+    period_parser(period_range_option range_option = AS_CLOSED_RANGE, 
+                  const char_type* const period_separator = default_period_separator, 
+                  const char_type* const period_start_delimeter = default_period_start_delimeter,
+                  const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
+                  const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter)
+      : m_range_option(range_option)
+    {
+      delimiters.push_back(string_type(period_separator));
+      delimiters.push_back(string_type(period_start_delimeter));
+      delimiters.push_back(string_type(period_open_range_end_delimeter));
+      delimiters.push_back(string_type(period_closed_range_end_delimeter));
+    }
+
+    period_parser(const period_parser<date_type,CharT>& p_parser)
+    {
+      this->delimiters = p_parser.delimiters;
+      this->m_range_option = p_parser.m_range_option;
+    }
+
+    period_range_option range_option() const
+    {
+      return m_range_option;
+    }
+    void range_option(period_range_option option)
+    {
+      m_range_option = option;
+    }
+    collection_type delimiter_strings() const
+    {
+      return delimiters;
+    }
+    void delimiter_strings(const string_type& separator,
+                           const string_type& start_delim,
+                           const string_type& open_end_delim,
+                           const string_type& closed_end_delim)
+    {
+      delimiters.clear();
+      delimiters.push_back(separator);
+      delimiters.push_back(start_delim);
+      delimiters.push_back(open_end_delim);
+      delimiters.push_back(closed_end_delim);
+    }
+
+    //! Generic code to parse a period -- no matter the period type.
+    /*! This generic code will parse any period using a facet to
+     *  to get the 'elements'.  For example, in the case of a date_period
+     *  the elements will be instances of a date which will be parsed
+     *  according the to setup in the passed facet parameter.
+     * 
+     *  The steps for parsing a period are always the same:
+     *  - consume the start delimiter
+     *  - get start element
+     *  - consume the separator 
+     *  - get either last or end element depending on range settings
+     *  - consume the end delimeter depending on range settings
+     *
+     *  Thus for a typical date period the contents of the input stream
+     *  might look like this:
+     *@code
+     *
+     *    [March 01, 2004/June 07, 2004]   <-- closed range
+     *    [March 01, 2004/June 08, 2004)   <-- open range
+     *
+     *@endcode
+     */
+    template<class period_type, class duration_type, class facet_type>
+    period_type get_period(stream_itr_type& sitr, 
+                           stream_itr_type& stream_end,
+                           std::ios_base& a_ios, 
+                           const period_type& p,
+                           const duration_type& dur_unit,
+                           const facet_type& facet) const 
+    {
+      // skip leading whitespace
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
+     
+      typedef typename period_type::point_type point_type;
+      point_type p1(not_a_date_time), p2(not_a_date_time);
+
+
+      consume_delim(sitr, stream_end, delimiters[START]);       // start delim
+      facet.get(sitr, stream_end, a_ios, p1);                   // first point
+      consume_delim(sitr, stream_end, delimiters[SEPARATOR]);   // separator
+      facet.get(sitr, stream_end, a_ios, p2);                   // second point
+
+      // period construction parameters are always open range [begin, end)
+      if (m_range_option == AS_CLOSED_RANGE) {
+        consume_delim(sitr, stream_end, delimiters[CLOSED_END]);// end delim
+        // add 1 duration unit to p2 to make range open
+        p2 += dur_unit;
+      }
+      else {
+        consume_delim(sitr, stream_end, delimiters[OPEN_END]);  // end delim
+      }
+    
+      return period_type(p1, p2);
+    }
+      
+  private:
+    collection_type delimiters; 
+    period_range_option m_range_option;    
+    
+    enum delim_ids { SEPARATOR, START, OPEN_END, CLOSED_END };
+
+    //! throws ios_base::failure if delimiter and parsed data do not match
+    void consume_delim(stream_itr_type& sitr,
+                       stream_itr_type& stream_end,
+                       const string_type& delim) const
+    {
+      /* string_parse_tree will not parse a string of punctuation characters 
+       * without knowing exactly how many characters to process
+       * Ex [2000. Will not parse out the '[' string without knowing 
+       * to process only one character. By using length of the delimiter 
+       * string we can safely iterate past it. */
+      string_type s;
+      for(unsigned int i = 0; i < delim.length() && sitr != stream_end; ++i) {
+        s += *sitr;
+        ++sitr;
+      }
+      if(s != delim) {
+        throw std::ios_base::failure("Parse failed. Expected '" + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'");
+      }
+    }
+  };
+
+  template <class date_type, class char_type>  
+  const typename period_parser<date_type, char_type>::char_type 
+  period_parser<date_type, char_type>::default_period_separator[2] = {'/'};
+
+  template <class date_type, class char_type>  
+  const typename period_parser<date_type, char_type>::char_type 
+  period_parser<date_type, char_type>::default_period_start_delimeter[2] = {'['};
+
+  template <class date_type, class char_type>  
+  const typename period_parser<date_type, char_type>::char_type 
+  period_parser<date_type, char_type>::default_period_open_range_end_delimeter[2] = {')'};
+
+  template <class date_type, class char_type>  
+  const typename period_parser<date_type, char_type>::char_type 
+  period_parser<date_type, char_type>::default_period_closed_range_end_delimeter[2] = {']'};
+
+ } } //namespace boost::date_time
+
+#endif // DATETIME_PERIOD_PARSER_HPP___

data/ext/boost/date_time/posix_time/conversion.hpp

@@ -0,0 +1,93 @@
+#ifndef POSIX_TIME_CONVERSION_HPP___
+#define POSIX_TIME_CONVERSION_HPP___
+
+/* Copyright (c) 2002-2005 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) $
+ */
+
+#include "boost/date_time/posix_time/ptime.hpp"
+#include "boost/date_time/posix_time/posix_time_duration.hpp"
+#include "boost/date_time/filetime_functions.hpp"
+#include "boost/date_time/c_time.hpp"
+#include "boost/date_time/gregorian/conversion.hpp"
+
+namespace boost {
+
+namespace posix_time {
+
+
+  //! Function that converts a time_t into a ptime.
+  inline
+  ptime from_time_t(std::time_t t) 
+  {
+    ptime start(gregorian::date(1970,1,1));
+    return start + seconds(static_cast<long>(t));
+  }
+
+  //! Convert a time to a tm structure truncating any fractional seconds 
+  inline
+  std::tm to_tm(const boost::posix_time::ptime& t) {
+    std::tm timetm = boost::gregorian::to_tm(t.date());
+    boost::posix_time::time_duration td = t.time_of_day();
+    timetm.tm_hour = td.hours(); 
+    timetm.tm_min = td.minutes(); 
+    timetm.tm_sec = td.seconds();
+    timetm.tm_isdst = -1; // -1 used when dst info is unknown 
+    return timetm;
+  }
+  //! Convert a time_duration to a tm structure truncating any fractional seconds and zeroing fields for date components 
+  inline
+  std::tm to_tm(const boost::posix_time::time_duration& td) {
+    std::tm timetm;
+    timetm.tm_year = 0;
+    timetm.tm_mon = 0;
+    timetm.tm_mday = 0;
+    timetm.tm_wday = 0;
+    timetm.tm_yday = 0;
+    
+    timetm.tm_hour = date_time::absolute_value(td.hours()); 
+    timetm.tm_min = date_time::absolute_value(td.minutes());
+    timetm.tm_sec = date_time::absolute_value(td.seconds());
+    timetm.tm_isdst = -1; // -1 used when dst info is unknown
+    return timetm;
+  }
+
+  //! Convert a tm struct to a ptime ignoring is_dst flag
+  inline
+  ptime ptime_from_tm(const std::tm& timetm) {
+    boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);
+    return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec));
+  }
+
+
+#if defined(BOOST_HAS_FTIME)
+  
+  //! Function to create a time object from an initialized FILETIME struct.
+  /*! Function to create a time object from an initialized FILETIME struct.
+   * A FILETIME struct holds 100-nanosecond units (0.0000001). When 
+   * built with microsecond resolution the FILETIME's sub second value 
+   * will be truncated. Nanosecond resolution has no truncation. 
+   *
+   * Note ftime is part of the Win32 API, so it is not portable to non-windows
+   * platforms.
+   */
+  template<class time_type>
+  inline
+  time_type from_ftime(const FILETIME& ft)
+  {
+    return boost::date_time::time_from_ftime<time_type>(ft);
+  }
+
+#endif // BOOST_HAS_FTIME
+
+} } //namespace boost::posix_time
+
+
+
+
+#endif
+

data/ext/boost/date_time/posix_time/date_duration_operators.hpp

@@ -0,0 +1,114 @@
+#ifndef DATE_DURATION_OPERATORS_HPP___
+#define DATE_DURATION_OPERATORS_HPP___
+                                                                                
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * 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) $
+ */
+
+#include "boost/date_time/gregorian/greg_duration_types.hpp"
+#include "boost/date_time/posix_time/ptime.hpp"
+
+namespace boost {
+namespace posix_time {
+  
+  /*!@file date_duration_operators.hpp Operators for ptime and 
+   * optional gregorian types. Operators use snap-to-end-of-month behavior. 
+   * Further details on this behavior can be found in reference for 
+   * date_time/date_duration_types.hpp and documentation for 
+   * month and year iterators.
+   */
+ 
+
+  /*! Adds a months object and a ptime. Result will be same 
+   * day-of-month as ptime unless original day was the last day of month.
+   * see date_time::months_duration for more details */
+  inline
+  ptime 
+  operator+(const ptime& t, const boost::gregorian::months& m)
+  {
+    return t + m.get_offset(t.date());
+  }
+  
+  /*! Adds a months object to a ptime. Result will be same 
+   * day-of-month as ptime unless original day was the last day of month.
+   * see date_time::months_duration for more details */
+  inline
+  ptime 
+  operator+=(ptime& t, const boost::gregorian::months& m)
+  {
+    // get_neg_offset returns a negative duration, so we add
+    return t += m.get_offset(t.date());
+  }
+
+  /*! Subtracts a months object and a ptime. Result will be same 
+   * day-of-month as ptime unless original day was the last day of month.
+   * see date_time::months_duration for more details */
+  inline
+  ptime 
+  operator-(const ptime& t, const boost::gregorian::months& m)
+  {
+    // get_neg_offset returns a negative duration, so we add
+    return t + m.get_neg_offset(t.date());
+  }
+  
+  /*! Subtracts a months object from a ptime. Result will be same 
+   * day-of-month as ptime unless original day was the last day of month.
+   * see date_time::months_duration for more details */
+  inline
+  ptime 
+  operator-=(ptime& t, const boost::gregorian::months& m)
+  {
+    return t += m.get_neg_offset(t.date());
+  }
+
+  // ptime & years
+  
+  /*! Adds a years object and a ptime. Result will be same 
+   * month and day-of-month as ptime unless original day was the 
+   * last day of month. see date_time::years_duration for more details */
+  inline
+  ptime 
+  operator+(const ptime& t, const boost::gregorian::years& y)
+  {
+    return t + y.get_offset(t.date());
+  }
+
+  /*! Adds a years object to a ptime. Result will be same 
+   * month and day-of-month as ptime unless original day was the 
+   * last day of month. see date_time::years_duration for more details */
+  inline
+  ptime 
+  operator+=(ptime& t, const boost::gregorian::years& y)
+  {
+    return t += y.get_offset(t.date());
+  }
+
+  /*! Subtracts a years object and a ptime. Result will be same 
+   * month and day-of-month as ptime unless original day was the 
+   * last day of month. see date_time::years_duration for more details */
+  inline
+  ptime 
+  operator-(const ptime& t, const boost::gregorian::years& y)
+  {
+    // get_neg_offset returns a negative duration, so we add
+    return t + y.get_neg_offset(t.date());
+  }
+
+  /*! Subtracts a years object from a ptime. Result will be same 
+   * month and day-of-month as ptime unless original day was the 
+   * last day of month. see date_time::years_duration for more details */
+  inline
+  ptime 
+  operator-=(ptime& t, const boost::gregorian::years& y)
+  {
+    // get_neg_offset returns a negative duration, so we add
+    return t += y.get_neg_offset(t.date());
+  }
+
+}} // namespaces
+
+#endif // DATE_DURATION_OPERATORS_HPP___

data/ext/boost/date_time/posix_time/posix_time.hpp

@@ -0,0 +1,39 @@
+#ifndef POSIX_TIME_HPP___
+#define POSIX_TIME_HPP___
+
+/* Copyright (c) 2002-2005 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 posix_time.hpp Global header file to get all of posix time types 
+ */
+
+#include "boost/date_time/compiler_config.hpp"
+#include "boost/date_time/posix_time/ptime.hpp"
+#if defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
+#include "boost/date_time/posix_time/date_duration_operators.hpp"
+#endif
+
+// output functions
+#if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+#include "boost/date_time/posix_time/time_formatters_limited.hpp"
+#else
+#include "boost/date_time/posix_time/time_formatters.hpp"
+#endif // BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
+
+// streaming operators
+#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
+#include "boost/date_time/posix_time/posix_time_legacy_io.hpp"
+#else
+#include "boost/date_time/posix_time/posix_time_io.hpp"
+#endif // USE_DATE_TIME_PRE_1_33_FACET_IO
+
+#include "boost/date_time/posix_time/time_parsers.hpp"
+#include "boost/date_time/posix_time/conversion.hpp"
+
+
+#endif
+

data/ext/boost/date_time/posix_time/posix_time_config.hpp

@@ -0,0 +1,178 @@
+#ifndef POSIX_TIME_CONFIG_HPP___
+#define POSIX_TIME_CONFIG_HPP___
+
+/* Copyright (c) 2002,2003,2005 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) $
+ */
+
+#include "boost/date_time/time_duration.hpp"
+#include "boost/date_time/time_resolution_traits.hpp"
+#include "boost/date_time/gregorian/gregorian_types.hpp"
+#include "boost/date_time/wrapping_int.hpp"
+#include "boost/limits.hpp"
+#include "boost/date_time/compiler_config.hpp"
+#include "boost/cstdint.hpp"
+#include <cmath>
+#include <cstdlib> //for MCW 7.2 std::abs(long long)
+
+namespace boost {
+namespace posix_time {
+
+//Remove the following line if you want 64 bit millisecond resolution time
+//#define BOOST_GDTL_POSIX_TIME_STD_CONFIG
+
+#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+  // set up conditional test compilations
+#define BOOST_DATE_TIME_HAS_MILLISECONDS
+#define BOOST_DATE_TIME_HAS_MICROSECONDS
+#define BOOST_DATE_TIME_HAS_NANOSECONDS
+  typedef date_time::time_resolution_traits<boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::nano, 
+    1000000000, 9 > time_res_traits;
+#else
+  // set up conditional test compilations
+#define BOOST_DATE_TIME_HAS_MILLISECONDS
+#define BOOST_DATE_TIME_HAS_MICROSECONDS
+#undef  BOOST_DATE_TIME_HAS_NANOSECONDS
+  typedef date_time::time_resolution_traits<
+    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro, 
+                                            1000000, 6 > time_res_traits;
+
+
+// #undef BOOST_DATE_TIME_HAS_MILLISECONDS
+// #undef BOOST_DATE_TIME_HAS_MICROSECONDS
+// #undef BOOST_DATE_TIME_HAS_NANOSECONDS
+//   typedef date_time::time_resolution_traits<boost::int64_t, boost::date_time::tenth, 
+//                                              10, 0 > time_res_traits;
+
+#endif
+
+
+  //! Base time duration type
+  /*! \ingroup time_basics
+   */
+  class time_duration :
+    public date_time::time_duration<time_duration, time_res_traits>
+  {
+  public:
+    typedef time_res_traits rep_type;
+    typedef time_res_traits::day_type day_type;
+    typedef time_res_traits::hour_type hour_type;
+    typedef time_res_traits::min_type min_type;
+    typedef time_res_traits::sec_type sec_type;
+    typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
+    typedef time_res_traits::tick_type tick_type;
+    typedef time_res_traits::impl_type impl_type;
+    time_duration(hour_type hour,
+                  min_type min,
+                  sec_type sec,
+                  fractional_seconds_type fs=0) :
+      date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
+    {}
+    time_duration() :
+      date_time::time_duration<time_duration, time_res_traits>(0,0,0)
+    {}
+    //! Construct from special_values
+    time_duration(boost::date_time::special_values sv) :
+      date_time::time_duration<time_duration, time_res_traits>(sv)
+    {}
+    //Give duration access to ticks constructor -- hide from users
+    friend class date_time::time_duration<time_duration, time_res_traits>;
+  private:
+    explicit time_duration(impl_type ticks) :
+      date_time::time_duration<time_duration, time_res_traits>(ticks)
+    {}
+  };
+
+#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+
+  //! Simple implementation for the time rep
+  struct simple_time_rep
+  {
+    typedef gregorian::date      date_type;
+    typedef time_duration        time_duration_type;
+    simple_time_rep(date_type d, time_duration_type tod) :
+      day(d),
+      time_of_day(tod)
+    {
+      // make sure we have sane values for date & time
+      if(!day.is_special() && !time_of_day.is_special()){
+        if(time_of_day >= time_duration_type(24,0,0)) {
+          while(time_of_day >= time_duration_type(24,0,0)) {
+            day += date_type::duration_type(1);
+            time_of_day -= time_duration_type(24,0,0);
+          }
+        }
+        else if(time_of_day.is_negative()) {
+          while(time_of_day.is_negative()) {
+            day -= date_type::duration_type(1);
+            time_of_day += time_duration_type(24,0,0);
+          }
+        }
+      }
+    }
+    date_type day;
+    time_duration_type time_of_day;
+    bool is_special()const
+    {
+      return(is_pos_infinity() || is_neg_infinity() || is_not_a_date_time());
+    }
+    bool is_pos_infinity()const
+    {
+      return(day.is_pos_infinity() || time_of_day.is_pos_infinity());
+    }
+    bool is_neg_infinity()const
+    {
+      return(day.is_neg_infinity() || time_of_day.is_neg_infinity());
+    }
+    bool is_not_a_date_time()const
+    {
+      return(day.is_not_a_date() || time_of_day.is_not_a_date_time());
+    }
+  };
+
+  class posix_time_system_config 
+  {
+   public:
+    typedef simple_time_rep time_rep_type;
+    typedef gregorian::date date_type;
+    typedef gregorian::date_duration date_duration_type;
+    typedef time_duration time_duration_type;
+    typedef time_res_traits::tick_type int_type;
+    typedef time_res_traits resolution_traits;
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#else
+    BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000000);
+#endif
+  };
+
+#else
+
+  class millisec_posix_time_system_config 
+  {
+   public:
+    typedef boost::int64_t time_rep_type;
+    //typedef time_res_traits::tick_type time_rep_type;
+    typedef gregorian::date date_type;
+    typedef gregorian::date_duration date_duration_type;
+    typedef time_duration time_duration_type;
+    typedef time_res_traits::tick_type int_type;
+    typedef time_res_traits::impl_type impl_type;
+    typedef time_res_traits resolution_traits;
+#if (defined(BOOST_DATE_TIME_NO_MEMBER_INIT)) //help bad compilers 
+#else
+    BOOST_STATIC_CONSTANT(boost::int64_t, tick_per_second = 1000000);
+#endif
+  };
+
+#endif
+
+} }//namespace posix_time
+
+
+#endif
+
+