passenger 2.2.15 → 3.0.0.pre1

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

@@ -6,17 +6,19 @@
  * 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) $
+ * $Date: 2008-11-13 14:05:31 -0500 (Thu, 13 Nov 2008) $
  */
 
-#include "boost/date_time/time_facet.hpp"
-#include "boost/date_time/period_formatter.hpp"
-#include "boost/date_time/posix_time/time_period.hpp"
-#include "boost/date_time/posix_time/posix_time_duration.hpp"
-//#include "boost/date_time/gregorian/gregorian_io.hpp"
-#include "boost/io/ios_state.hpp"
-#include <iostream>
 #include <locale>
+#include <iostream>
+#include <iterator> // i/ostreambuf_iterator
+#include <boost/io/ios_state.hpp>
+#include <boost/date_time/time_facet.hpp>
+#include <boost/date_time/period_formatter.hpp>
+#include <boost/date_time/posix_time/ptime.hpp>
+#include <boost/date_time/posix_time/time_period.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/posix_time/conversion.hpp> // to_tm will be needed in the facets
 
 namespace boost {
 namespace posix_time {
@@ -39,9 +41,9 @@ namespace posix_time {
   typedef boost::date_time::time_input_facet<ptime, char>         time_input_facet;
 
   template <class CharT, class TraitsT>
-  inline 
+  inline
   std::basic_ostream<CharT, TraitsT>&
-  operator<<(std::basic_ostream<CharT, TraitsT>& os, 
+  operator<<(std::basic_ostream<CharT, TraitsT>& os,
              const ptime& p) {
     boost::io::ios_flags_saver iflags(os);
     typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
@@ -55,7 +57,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the locale did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -71,11 +72,10 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, ptime& pt)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
         typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-        
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
         if(std::has_facet<time_input_facet>(is.getloc())) {
           std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
@@ -87,31 +87,30 @@ namespace posix_time {
           f->get(sit, str_end, is, pt);
         }
       }
-      catch(...) { 
+      catch(...) {
         // mask tells us what exceptions are turned on
         std::ios_base::iostate exception_mask = is.exceptions();
         // if the user wants exceptions on failbit, we'll rethrow our 
         // date_time exception & set the failbit
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {} // ignore this one
           throw; // rethrow original exception
         }
         else {
           // if the user want's to fail quietly, we simply set the failbit
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 
   template <class CharT, class TraitsT>
   inline 
   std::basic_ostream<CharT, TraitsT>&
-  operator<<(std::basic_ostream<CharT, TraitsT>& os, 
+  operator<<(std::basic_ostream<CharT, TraitsT>& os,
              const boost::posix_time::time_period& p) {
     boost::io::ios_flags_saver iflags(os);
     typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
@@ -126,7 +125,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the local did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -142,11 +140,10 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, time_period& tp)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
         typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
         if(std::has_facet<time_input_facet>(is.getloc())) {
           std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
@@ -158,22 +155,21 @@ namespace posix_time {
           f->get(sit, str_end, is, tp);
         }
       }
-      catch(...) { 
+      catch(...) {
         std::ios_base::iostate exception_mask = is.exceptions();
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {}
           throw; // rethrow original exception
         }
         else {
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 
   //! ostream operator for posix_time::time_duration 
   //  todo fix to use facet --  place holder for now...
@@ -194,7 +190,6 @@ namespace posix_time {
       //since we would always need to reconstruct for every time period
       //if the locale did not already exist.  Of course this will be overridden
       //if the user imbues as some later point.
-      std::ostreambuf_iterator<CharT> oitr(os);
       custom_ptime_facet* f = new custom_ptime_facet();
       std::locale l = std::locale(os.getloc(), f);
       os.imbue(l);
@@ -210,11 +205,10 @@ namespace posix_time {
   operator>>(std::basic_istream<CharT, Traits>& is, time_duration& td)
   {
     boost::io::ios_flags_saver iflags(is);
-    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false); 
+    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
     if (strm_sentry) {
       try {
         typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
-
         std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
         if(std::has_facet<time_input_facet>(is.getloc())) {
           std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
@@ -226,21 +220,20 @@ namespace posix_time {
           f->get(sit, str_end, is, td);
         }
       }
-      catch(...) { 
+      catch(...) {
         std::ios_base::iostate exception_mask = is.exceptions();
         if(std::ios_base::failbit & exception_mask) {
-          try { is.setstate(std::ios_base::failbit); } 
+          try { is.setstate(std::ios_base::failbit); }
           catch(std::ios_base::failure&) {}
           throw; // rethrow original exception
         }
         else {
-          is.setstate(std::ios_base::failbit); 
-        } 
-            
+          is.setstate(std::ios_base::failbit);
+        }
       }
     }
     return is;
   }
-  
+
 } } // namespaces
 #endif // DATE_TIME_POSIX_TIME_IO_HPP__

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

@@ -2,24 +2,24 @@
 #define POSIXTIME_FORMATTERS_HPP___
 
 /* Copyright (c) 2002-2004 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * 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) $
+ * $Date: 2010-01-10 14:17:23 -0500 (Sun, 10 Jan 2010) $
  */
 
-#include "boost/date_time/gregorian/gregorian.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/iso_format.hpp"
-#include "boost/date_time/date_format_simple.hpp"
-#include "boost/date_time/posix_time/posix_time_types.hpp"
-#include "boost/date_time/time_formatting_streams.hpp"
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/iso_format.hpp>
+#include <boost/date_time/date_format_simple.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/time_formatting_streams.hpp>
+#include <boost/date_time/time_resolution_traits.hpp> // absolute_value
+#include <boost/date_time/time_parsing.hpp>
 
-#include "boost/date_time/time_parsing.hpp"
-
-/* NOTE: The "to_*_string" code for older compilers, ones that define 
- * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in 
+/* NOTE: The "to_*_string" code for older compilers, ones that define
+ * BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS, is located in
  * formatters_limited.hpp
  */
 
@@ -57,27 +57,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.hours()) << ":";
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.minutes()) << ":";
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       charT buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill(fill_char)
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -99,7 +99,7 @@ namespace posix_time {
   // template function called by wrapper functions:
   // to_*_string(time_duration) & to_*_wstring(time_duration)
   template<class charT>
-  inline std::basic_string<charT> to_iso_string_type(time_duration td) 
+  inline std::basic_string<charT> to_iso_string_type(time_duration td)
   {
     std::basic_ostringstream<charT> ss;
     if(td.is_special()) {
@@ -126,27 +126,27 @@ namespace posix_time {
       if(td.is_negative()) {
         ss << '-';
       }
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.hours());
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.minutes());
-      ss  << std::setw(2) << std::setfill(fill_char) 
+      ss  << std::setw(2) << std::setfill(fill_char)
           << date_time::absolute_value(td.seconds());
       //TODO the following is totally non-generic, yelling FIXME
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
-      boost::int64_t frac_sec = 
+      boost::int64_t frac_sec =
         date_time::absolute_value(td.fractional_seconds());
       // JDG [7/6/02 VC++ compatibility]
       charT buff[32];
       _i64toa(frac_sec, buff, 10);
 #else
-      time_duration::fractional_seconds_type frac_sec = 
+      time_duration::fractional_seconds_type frac_sec =
         date_time::absolute_value(td.fractional_seconds());
 #endif
       if (frac_sec != 0) {
         ss  << "." << std::setw(time_duration::num_fractional_digits())
             << std::setfill(fill_char)
-          
+
           // JDG [7/6/02 VC++ compatibility]
 #if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
             << buff;
@@ -168,7 +168,7 @@ namespace posix_time {
   /*!\ingroup time_format
    */
   template<class charT>
-  inline std::basic_string<charT> to_simple_string_type(ptime t) 
+  inline std::basic_string<charT> to_simple_string_type(ptime t)
   {
     // can't use this w/gcc295, no to_simple_string_type<>(td) available
     std::basic_string<charT> ts = gregorian::to_simple_string_type<charT>(t.date());// + " ";
@@ -184,10 +184,10 @@ namespace posix_time {
     return to_simple_string_type<char>(t);
   }
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_simple_string_type(time_period tp) 
+  inline std::basic_string<charT> to_simple_string_type(time_period tp)
   {
     charT beg = '[', mid = '/', end = ']';
     std::basic_string<charT> d1(to_simple_string_type<charT>(tp.begin()));
@@ -201,10 +201,10 @@ namespace posix_time {
     return to_simple_string_type<char>(tp);
   }
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_iso_string_type(ptime t) 
+  inline std::basic_string<charT> to_iso_string_type(ptime t)
   {
     std::basic_string<charT> ts = gregorian::to_iso_string_type<charT>(t.date());// + "T";
     if(!t.time_of_day().is_special()) {
@@ -223,10 +223,10 @@ namespace posix_time {
   }
 
 
-  // function called by wrapper functions to_*_string(time_period) 
+  // function called by wrapper functions to_*_string(time_period)
   // & to_*_wstring(time_period)
   template<class charT>
-  inline std::basic_string<charT> to_iso_extended_string_type(ptime t) 
+  inline std::basic_string<charT> to_iso_extended_string_type(ptime t)
   {
     std::basic_string<charT> ts = gregorian::to_iso_extended_string_type<charT>(t.date());// + "T";
     if(!t.time_of_day().is_special()) {

data/ext/boost/date_time/string_parse_tree.hpp

@@ -2,16 +2,16 @@
 #define BOOST_DATE_TIME_STRING_PARSE_TREE___HPP__
 
 /* Copyright (c) 2004-2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * 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) $
+ * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */
 
 
 #include "boost/lexical_cast.hpp" //error without?
-#include "boost/algorithm/string/case_conv.hpp" 
+#include "boost/algorithm/string/case_conv.hpp"
 #include <map>
 #include <string>
 #include <vector>
@@ -37,21 +37,21 @@ struct parse_match_result
       return cache;
     }
     //some of the cache was used return the rest
-    return string_type(cache, match_depth); 
+    return string_type(cache, match_depth);
   }
   charT last_char() const
   {
     return cache[cache.size()-1];
   }
   //! Returns true if more characters were parsed than was necessary
-  /*! Should be used in conjunction with last_char() 
-   *  to get the remaining character. 
+  /*! Should be used in conjunction with last_char()
+   *  to get the remaining character.
    */
   bool has_remaining() const
   {
     return (cache.size() > match_depth);
   }
-  
+
   // cache will hold characters that have been read from the stream
   string_type cache;
   unsigned short match_depth;
@@ -64,8 +64,8 @@ template<typename charT>
 std::basic_ostream<charT>&
 operator<<(std::basic_ostream<charT>& os, parse_match_result<charT>& mr)
 {
-  os << "cm: " << mr.current_match 
-     << " C: '" << mr.cache 
+  os << "cm: " << mr.current_match
+     << " C: '" << mr.cache
      << "' md: " << mr.match_depth
      << " R: " << mr.remaining();
   return os;
@@ -93,11 +93,11 @@ struct string_parse_tree
   typedef std::basic_string<charT> string_type;
   typedef std::vector<std::basic_string<charT> > collection_type;
   typedef parse_match_result<charT> parse_match_result_type;
- 
-  /*! Parameter "starting_point" desingates where the numbering begins. 
-   * A starting_point of zero will start the numbering at zero 
-   * (Sun=0, Mon=1, ...) were a starting_point of one starts the 
-   * numbering at one (Jan=1, Feb=2, ...). The default is zero, 
+
+  /*! Parameter "starting_point" designates where the numbering begins.
+   * A starting_point of zero will start the numbering at zero
+   * (Sun=0, Mon=1, ...) were a starting_point of one starts the
+   * numbering at one (Jan=1, Feb=2, ...). The default is zero,
    * negative vaules are not allowed */
   string_parse_tree(collection_type names, unsigned int starting_point=0)
   {
@@ -126,44 +126,44 @@ struct string_parse_tree
     while(i < s.size()) {
       if (i==0) {
         if (i == (s.size()-1)) {
-          ti = m_next_chars.insert(value_type(s[i], 
+          ti = m_next_chars.insert(value_type(s[i],
                                               string_parse_tree<charT>(value)));
         }
         else {
-          ti = m_next_chars.insert(value_type(s[i], 
+          ti = m_next_chars.insert(value_type(s[i],
                                               string_parse_tree<charT>()));
         }
       }
       else {
         if (i == (s.size()-1)) {
-          ti = ti->second.m_next_chars.insert(value_type(s[i], 
+          ti = ti->second.m_next_chars.insert(value_type(s[i],
                                                          string_parse_tree<charT>(value)));
         }
-        
+
         else {
-          ti = ti->second.m_next_chars.insert(value_type(s[i], 
+          ti = ti->second.m_next_chars.insert(value_type(s[i],
                                                          string_parse_tree<charT>()));
         }
-      
-      } 
+
+      }
       i++;
     }
   }
- 
-  
+
+
   //! Recursive function that finds a matching string in the tree.
-  /*! Must check match_results::has_remaining() after match() is 
-   * called. This is required so the user can determine if 
-   * stream iterator is already pointing to the expected 
+  /*! Must check match_results::has_remaining() after match() is
+   * called. This is required so the user can determine if
+   * stream iterator is already pointing to the expected
    * character or not (match() might advance sitr to next char in stream).
    *
-   * A parse_match_result that has been returned from a failed match 
-   * attempt can be sent in to the match function of a different 
-   * string_parse_tree to attempt a match there. Use the iterators 
-   * for the partially consumed stream, the parse_match_result object, 
+   * A parse_match_result that has been returned from a failed match
+   * attempt can be sent in to the match function of a different
+   * string_parse_tree to attempt a match there. Use the iterators
+   * for the partially consumed stream, the parse_match_result object,
    * and '0' for the level parameter. */
   short
-  match(std::istreambuf_iterator<charT>& sitr, 
+  match(std::istreambuf_iterator<charT>& sitr,
         std::istreambuf_iterator<charT>& stream_end,
         parse_match_result_type& result,
         unsigned int& level)  const
@@ -171,7 +171,7 @@ struct string_parse_tree
 
     level++;
     charT c;
-    // if we conditionally advance sitr, we won't have 
+    // if we conditionally advance sitr, we won't have
     // to consume the next character past the input
     bool adv_itr = true;
     if (level > result.cache.size()) {
@@ -181,16 +181,16 @@ struct string_parse_tree
       //sitr++;
     }
     else {
-      // if we're looking for characters from the cache, 
+      // if we're looking for characters from the cache,
       // we don't want to increment sitr
-      adv_itr = false; 
+      adv_itr = false;
       c = static_cast<charT>(std::tolower(result.cache[level-1]));
     }
     const_iterator litr = m_next_chars.lower_bound(c);
     const_iterator uitr = m_next_chars.upper_bound(c);
     while (litr != uitr) { // equal if not found
       if(adv_itr) {
-        sitr++; 
+        sitr++;
         result.cache += c;
       }
       if (litr->second.m_value != -1) { // -1 is default value
@@ -198,16 +198,16 @@ struct string_parse_tree
           result.current_match = litr->second.m_value;
           result.match_depth = static_cast<unsigned short>(level);
         }
-        litr->second.match(sitr, stream_end, 
+        litr->second.match(sitr, stream_end,
                            result, level);
         level--;
       }
       else {
-        litr->second.match(sitr, stream_end, 
+        litr->second.match(sitr, stream_end,
                            result, level);
         level--;
       }
-    
+
       if(level <= result.cache.size()) {
         adv_itr = false;
       }
@@ -218,13 +218,13 @@ struct string_parse_tree
 
   }
 
-  /*! Must check match_results::has_remaining() after match() is 
-   * called. This is required so the user can determine if 
-   * stream iterator is already pointing to the expected 
+  /*! Must check match_results::has_remaining() after match() is
+   * called. This is required so the user can determine if
+   * stream iterator is already pointing to the expected
    * character or not (match() might advance sitr to next char in stream).
    */
   parse_match_result_type
-  match(std::istreambuf_iterator<charT>& sitr, 
+  match(std::istreambuf_iterator<charT>& sitr,
         std::istreambuf_iterator<charT>& stream_end) const
   {
     // lookup to_lower of char in tree.
@@ -242,8 +242,8 @@ struct string_parse_tree
     iterator end = m_next_chars.end();
     //    os << "starting level: " << level << std::endl;
     while (itr != end) {
-      os << "level:  " << level 
-         << " node:  " << itr->first 
+      os << "level:  " << level
+         << " node:  " << itr->first
          << " value: " << itr->second.m_value
          << std::endl;
       itr->second.printme(os, level);
@@ -257,14 +257,14 @@ struct string_parse_tree
     int level = 0;
     printme(os, level);
   }
-    
+
   void printmatch(std::ostream& os, charT c)
   {
     iterator litr = m_next_chars.lower_bound(c);
     iterator uitr = m_next_chars.upper_bound(c);
     os << "matches for: " << c << std::endl;
     while (litr != uitr) {
-      os << " node:  " << litr->first 
+      os << " node:  " << litr->first
          << " value: " << litr->second.m_value
          << std::endl;
       litr++;