passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/date_time/date_generator_formatter.hpp

@@ -6,7 +6,7 @@
  * 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 <iostream>
@@ -63,6 +63,7 @@ namespace date_time {
       //! Default format elements used
       date_generator_formatter()
       {
+        phrase_strings.reserve(number_of_phrase_elements);
         phrase_strings.push_back(string_type(first_string));
         phrase_strings.push_back(string_type(second_string));
         phrase_strings.push_back(string_type(third_string));
@@ -75,25 +76,26 @@ namespace date_time {
       }
 
       //! Constructor that allows for a custom set of phrase elements
-      date_generator_formatter(const string_type& first,
-                               const string_type& second,
-                               const string_type& third,
-                               const string_type& fourth,
-                               const string_type& fifth,
-                               const string_type& last,
-                               const string_type& before,
-                               const string_type& after,
-                               const string_type& of)
+      date_generator_formatter(const string_type& first_str,
+                               const string_type& second_str,
+                               const string_type& third_str,
+                               const string_type& fourth_str,
+                               const string_type& fifth_str,
+                               const string_type& last_str,
+                               const string_type& before_str,
+                               const string_type& after_str,
+                               const string_type& of_str)
       {
-        phrase_strings.push_back(string_type(first_string));
-        phrase_strings.push_back(string_type(second_string));
-        phrase_strings.push_back(string_type(third_string));
-        phrase_strings.push_back(string_type(fourth_string));
-        phrase_strings.push_back(string_type(fifth_string));
-        phrase_strings.push_back(string_type(last_string));
-        phrase_strings.push_back(string_type(before_string));
-        phrase_strings.push_back(string_type(after_string));
-        phrase_strings.push_back(string_type(of_string));
+        phrase_strings.reserve(number_of_phrase_elements);
+        phrase_strings.push_back(first_str);
+        phrase_strings.push_back(second_str);
+        phrase_strings.push_back(third_str);
+        phrase_strings.push_back(fourth_str);
+        phrase_strings.push_back(fifth_str);
+        phrase_strings.push_back(last_str);
+        phrase_strings.push_back(before_str);
+        phrase_strings.push_back(after_str);
+        phrase_strings.push_back(of_str);
       }
 
       //! Replace the set of phrase elements with those contained in new_strings
@@ -148,7 +150,7 @@ namespace date_time {
         facet.put(next, a_ios, a_fill, nkd.month());
         return next;
       }
-   
+
       //! Put a first_day_of_the_week_in_month => "first weekday of month"
       template<class facet_type>
       OutItrT put_first_kday(OutItrT next, std::ios_base& a_ios,

data/ext/boost/date_time/date_generator_parser.hpp

@@ -7,15 +7,17 @@
  * 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/date_time/string_parse_tree.hpp"
-#include "boost/date_time/date_generators.hpp"
-#include "boost/date_time/format_date_parser.hpp"
 #include <string>
 #include <vector>
+#include <iterator> // istreambuf_iterator
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/string_parse_tree.hpp>
+#include <boost/date_time/date_generators.hpp>
+#include <boost/date_time/format_date_parser.hpp>
 
 namespace boost { namespace date_time {
 
@@ -66,10 +68,10 @@ namespace boost { namespace date_time {
     static const char_type last_string[5];
     static const char_type before_string[8];
     static const char_type after_string[6];
-    static const char_type of_string[3];  
- 
+    static const char_type of_string[3];
+
     enum phrase_elements {first=0, second, third, fourth, fifth, last,
-                          before, after, of, number_of_phrase_elements};   
+                          before, after, of, number_of_phrase_elements};
 
     //! Creates a date_generator_parser with the default set of "element_strings"
     date_generator_parser()
@@ -96,7 +98,7 @@ namespace boost { namespace date_time {
                           const string_type& after_str,
                           const string_type& of_str)
     {
-      element_strings(first_str, second_str, third_str, fourth_str, fifth_str, 
+      element_strings(first_str, second_str, third_str, fourth_str, fifth_str,
                       last_str, before_str, after_str, of_str);
     }
 
@@ -128,19 +130,18 @@ namespace boost { namespace date_time {
     {
       m_element_strings = parse_tree_type(col, this->first); // enum first
     }
-                     
 
     //! returns partial_date parsed from stream
     template<class facet_type>
     partial_date_type
-    get_partial_date_type(stream_itr_type& sitr, 
+    get_partial_date_type(stream_itr_type& sitr,
                           stream_itr_type& stream_end,
-                          std::ios_base& a_ios, 
+                          std::ios_base& a_ios,
                           const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_type d(1);
       month_type m(1);
       facet.get(sitr, stream_end, a_ios, d);
@@ -152,18 +153,18 @@ namespace boost { namespace date_time {
     //! returns nth_kday_of_week parsed from stream
     template<class facet_type>
     nth_kday_type
-    get_nth_kday_type(stream_itr_type& sitr, 
+    get_nth_kday_type(stream_itr_type& sitr,
                       stream_itr_type& stream_end,
-                      std::ios_base& a_ios, 
+                      std::ios_base& a_ios,
                       const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+ 
       typename nth_kday_type::week_num wn;
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+
       match_results mr = m_element_strings.match(sitr, stream_end);
       switch(mr.current_match) {
         case first  : { wn = nth_kday_type::first; break; }
@@ -173,98 +174,98 @@ namespace boost { namespace date_time {
         case fifth  : { wn = nth_kday_type::fifth; break; }
         default:
         {
-          throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
-          break;
+          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
+          BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(wn = nth_kday_type::first);
         }
       }                                         // week num
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, of);    // "of" element
       facet.get(sitr, stream_end, a_ios, m);    // month
-      
+
       return nth_kday_type(wn, wd, m);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     first_kday_type
-    get_first_kday_type(stream_itr_type& sitr, 
+    get_first_kday_type(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
-                        std::ios_base& a_ios, 
+                        std::ios_base& a_ios,
                         const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+
       extract_element(sitr, stream_end, first); // "first" element
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, of);    // "of" element
       facet.get(sitr, stream_end, a_ios, m);    // month
-      
-      
+
+
       return first_kday_type(wd, m);
     }
 
     //! returns last_kday_of_week parsed from stream
     template<class facet_type>
     last_kday_type
-    get_last_kday_type(stream_itr_type& sitr, 
+    get_last_kday_type(stream_itr_type& sitr,
                        stream_itr_type& stream_end,
-                       std::ios_base& a_ios, 
+                       std::ios_base& a_ios,
                        const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
       month_type m(1);        // no default constructor
-     
+ 
       extract_element(sitr, stream_end, last); // "last" element
       facet.get(sitr, stream_end, a_ios, wd);  // day_of_week
       extract_element(sitr, stream_end, of);   // "of" element
       facet.get(sitr, stream_end, a_ios, m);   // month
-      
-      
+
+
       return last_kday_type(wd, m);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     kday_before_type
-    get_kday_before_type(stream_itr_type& sitr, 
+    get_kday_before_type(stream_itr_type& sitr,
                          stream_itr_type& stream_end,
-                         std::ios_base& a_ios, 
+                         std::ios_base& a_ios,
                          const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
-     
+
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, before);// "before" element
-      
+
       return kday_before_type(wd);
     }
 
     //! returns first_kday_of_week parsed from stream
     template<class facet_type>
     kday_after_type
-    get_kday_after_type(stream_itr_type& sitr, 
+    get_kday_after_type(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
-                        std::ios_base& a_ios, 
+                        std::ios_base& a_ios,
                         const facet_type& facet) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-      
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
+
       day_of_week_type wd(0); // no default constructor
-     
+
       facet.get(sitr, stream_end, a_ios, wd);   // day_of_week
       extract_element(sitr, stream_end, after); // "after" element
-      
+
       return kday_after_type(wd);
     }
 
@@ -277,13 +278,13 @@ namespace boost { namespace date_time {
                          typename date_generator_parser::phrase_elements ele) const
     {
       // skip leading whitespace
-      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
+      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
       match_results mr = m_element_strings.match(sitr, stream_end);
       if(mr.current_match != ele) {
-        throw std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'");
+        boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
       }
     }
-    
+
   };
 
   template<class date_type, class CharT>

data/ext/boost/date_time/date_generators.hpp

@@ -6,16 +6,18 @@
  * 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) $
  */
 
 /*! @file date_generators.hpp
   Definition and implementation of date algorithm templates
 */
+
 #include <stdexcept>
 #include <sstream>
-#include "boost/date_time/date.hpp"
-#include "boost/date_time/compiler_config.hpp"
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/date.hpp>
+#include <boost/date_time/compiler_config.hpp>
 
 namespace boost {
 namespace date_time {
@@ -99,13 +101,11 @@ namespace date_time {
    date_type get_date(year_type y) const
    {
      if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
-       std::stringstream ss("");
+       std::ostringstream ss;
        ss << "No Feb 29th in given year of " << y << ".";
-       throw std::invalid_argument(ss.str());
-       //return date_type(1,1,1); // should never reach
-     } else {
-       return date_type(y, month_, day_);
+       boost::throw_exception(std::invalid_argument(ss.str()));
      }
+     return date_type(y, month_, day_);
    }
    date_type operator()(year_type y) const
    {
@@ -141,7 +141,7 @@ namespace date_time {
     * Dec-31 == "365" */
    virtual std::string to_string() const
    {
-     std::stringstream ss;
+     std::ostringstream ss;
      date_type d(2004, month_, day_);
      unsigned short c = d.day_of_year();     
      c--; // numbered 0-365 while day_of_year is 1 based...
@@ -154,6 +154,9 @@ namespace date_time {
  };
 
 
+  //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5.
+  BOOST_DATE_TIME_DECL const char* nth_as_str(int n);
+
   //! Useful generator functor for finding holidays
   /*! Based on the idea in Cal. Calc. for finding holidays that are
    *  the 'first Monday of September'. When instantiated with
@@ -229,7 +232,7 @@ namespace date_time {
     /*! Returns a string formatted as "M4.3.0" ==> 3rd Sunday in April. */
     virtual std::string to_string() const
     {
-     std::stringstream ss;
+     std::ostringstream ss;
      ss << 'M' 
        << static_cast<int>(month_) << '.'
        << static_cast<int>(wn_) << '.'
@@ -242,9 +245,6 @@ namespace date_time {
     day_of_week_type dow_;
   };
   
-  //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5.
-  BOOST_DATE_TIME_DECL const char* nth_as_str(int n);
-
   //! Useful generator functor for finding holidays and daylight savings
   /*! Similar to nth_kday_of_month, but requires less paramters
    *  \ingroup date_alg
@@ -275,7 +275,7 @@ namespace date_time {
         d = d + one_day;
       }
       return d;
-        }
+    }
     // added for streaming
     month_type month() const
     {
@@ -289,7 +289,7 @@ namespace date_time {
     /*! Returns a string formatted as "M4.1.0" ==> 1st Sunday in April. */
     virtual std::string to_string() const
     {
-     std::stringstream ss;
+     std::ostringstream ss;
      ss << 'M' 
        << static_cast<int>(month_) << '.'
        << 1 << '.'
@@ -350,7 +350,7 @@ namespace date_time {
     /*! Returns a string formatted as "M4.5.0" ==> last Sunday in April. */
     virtual std::string to_string() const
     {
-      std::stringstream ss;
+      std::ostringstream ss;
       ss << 'M' 
          << static_cast<int>(month_) << '.'
          << 5 << '.'

data/ext/boost/date_time/date_parsing.hpp

@@ -2,22 +2,22 @@
 #define _DATE_TIME_DATE_PARSING_HPP___
 
 /* Copyright (c) 2002,2003,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: 2009-06-04 04:24:49 -0400 (Thu, 04 Jun 2009) $
  */
 
-#include "boost/tokenizer.hpp"
-#include "boost/lexical_cast.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/parse_format_base.hpp"
 #include <string>
 #include <iterator>
 #include <algorithm>
+#include <boost/tokenizer.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/parse_format_base.hpp>
 
-#if defined(BOOST_NO_STD_LOCALE)
+#if defined(BOOST_DATE_TIME_NO_LOCALE)
 #include <cctype> // ::tolower(int)
 #else
 #include <locale> // std::tolower(char, locale)
@@ -29,43 +29,43 @@ namespace date_time {
   //! A function to replace the std::transform( , , ,tolower) construct
   /*! This function simply takes a string, and changes all the characters
    * in that string to lowercase (according to the default system locale).
-   * In the event that a compiler does not support locales, the old 
+   * In the event that a compiler does not support locales, the old
    * C style tolower() is used.
    */
   inline
-  std::string 
-  convert_to_lower(const std::string& inp) {
-    std::string tmp;
-    unsigned i = 0;
-#if defined(BOOST_NO_STD_LOCALE)
-    while(i < inp.length()) {
-      tmp += static_cast<char>(std::tolower(inp.at(i++)));
+  std::string
+  convert_to_lower(std::string inp)
+  {
+#if !defined(BOOST_DATE_TIME_NO_LOCALE)
+    const std::locale loc(std::locale::classic());
+#endif
+    std::string::size_type i = 0, n = inp.length();
+    for (; i < n; ++i) {
+      inp[i] =
+#if defined(BOOST_DATE_TIME_NO_LOCALE)
+        static_cast<char>(std::tolower(inp[i]));
 #else
-      static const std::locale loc(std::locale::classic());
-      while(i < inp.length()) {
         // tolower and others were brought in to std for borland >= v564
         // in compiler_config.hpp
-        std::string::value_type c(inp.at(i++));
-        tmp += std::tolower(c, loc);
+        std::tolower(inp[i], loc);
 #endif
-        
-      }
-      return tmp;
     }
-    
+    return inp;
+  }
+
     //! Helper function for parse_date.
     /* Used by-value parameter because we change the string and may
      * want to preserve the original argument */
     template<class month_type>
-    unsigned short 
-    month_str_to_ushort(std::string s) {
+    inline unsigned short
+    month_str_to_ushort(std::string const& s) {
       if((s.at(0) >= '0') && (s.at(0) <= '9')) {
         return boost::lexical_cast<unsigned short>(s);
-      } 
+      }
       else {
-        s = convert_to_lower(s);
+        std::string str = convert_to_lower(s);
         typename month_type::month_map_ptr_type ptr = month_type::get_month_map_ptr();
-        typename month_type::month_map_type::iterator iter = ptr->find(s);
+        typename month_type::month_map_type::iterator iter = ptr->find(str);
         if(iter != ptr->end()) { // required for STLport
           return iter->second;
         }
@@ -74,44 +74,45 @@ namespace date_time {
     }
  
     //! Find index of a string in either of 2 arrays
-    /*! find_match searches both arrays for a match to 's'. Indexing of the 
-     * arrays is from 0 to 'limit'. The index of the match is returned.
+    /*! find_match searches both arrays for a match to 's'. Both arrays
+     * must contain 'size' elements. The index of the match is returned.
+     * If no match is found, 'size' is returned.
      * Ex. "Jan" returns 0, "Dec" returns 11, "Tue" returns 2.
-     * 'limit' can be sent in with: greg_month::max(), 
-     * greg_weekday::max() or date_time::NumSpecialValues */
+     * 'size' can be sent in with: (greg_month::max)() (which 12),
+     * (greg_weekday::max)() + 1 (which is 7) or date_time::NumSpecialValues */
     template<class charT>
-    short find_match(const charT* const* short_names, 
-                     const charT* const* long_names, 
-                     short limit,
+    short find_match(const charT* const* short_names,
+                     const charT* const* long_names,
+                     short size,
                      const std::basic_string<charT>& s) {
-      for(short i = 0; i <= limit; ++i){
+      for(short i = 0; i < size; ++i){
         if(short_names[i] == s || long_names[i] == s){
           return i;
         }
       }
-      return static_cast<short>(limit + 1); // not-found, return a value out of range
+      return size; // not-found, return a value out of range
     }
-    
+
     //! Generic function to parse a delimited date (eg: 2002-02-10)
     /*! Accepted formats are: "2003-02-10" or " 2003-Feb-10" or
-     * "2003-Feburary-10" 
-     * The order in which the Month, Day, & Year appear in the argument 
-     * string can be accomodated by passing in the appropriate ymd_order_spec 
+     * "2003-Feburary-10"
+     * The order in which the Month, Day, & Year appear in the argument
+     * string can be accomodated by passing in the appropriate ymd_order_spec
      */
     template<class date_type>
     date_type
     parse_date(const std::string& s, int order_spec = ymd_order_iso) {
-      std::string spec_str("");
+      std::string spec_str;
       if(order_spec == ymd_order_iso) {
         spec_str = "ymd";
-      } 
+      }
       else if(order_spec == ymd_order_dmy) {
         spec_str = "dmy";
-      } 
+      }
       else { // (order_spec == ymd_order_us)
         spec_str = "mdy";
       }
-      
+
       typedef typename date_type::year_type year_type;
       typedef typename date_type::month_type month_type;
       unsigned pos = 0;
@@ -128,21 +129,21 @@ namespace date_time {
       const char sep_char[] = {',','-','.',' ','/','\0'};
       char_separator_type sep(sep_char);
       tokenizer tok(s,sep);
-      for(tokenizer_iterator beg=tok.begin(); 
-          beg!=tok.end() && pos < spec_str.size(); 
+      for(tokenizer_iterator beg=tok.begin();
+          beg!=tok.end() && pos < spec_str.size();
           ++beg, ++pos) {
         switch(spec_str.at(pos)) {
-          case 'y': 
+          case 'y':
           {
             year = boost::lexical_cast<unsigned short>(*beg);
             break;
           }
-          case 'm': 
+          case 'm':
           {
             month = month_str_to_ushort<month_type>(*beg);
             break;
           }
-          case 'd': 
+          case 'd':
           {
             day = boost::lexical_cast<unsigned short>(*beg);
             break;
@@ -151,7 +152,7 @@ namespace date_time {
       }
       return date_type(year, month, day);
     }
-    
+
     //! Generic function to parse undelimited date (eg: 20020201)
     template<class date_type>
     date_type
@@ -161,16 +162,16 @@ namespace date_time {
       typedef typename date_type::year_type year_type;
       //typename date_type::ymd_type ymd((year_type::min)(),1,1);
       unsigned short y = 0, m = 0, d = 0;
-      
-      /* The two bool arguments state that parsing will not wrap 
-       * (only the first 8 characters will be parsed) and partial 
-       * strings will not be parsed. 
+
+      /* The two bool arguments state that parsing will not wrap
+       * (only the first 8 characters will be parsed) and partial
+       * strings will not be parsed.
        * Ex:
        * "2005121" will parse 2005 & 12, but not the "1" */
       boost::offset_separator osf(offsets, offsets+3, false, false);
-      
-      typedef typename boost::tokenizer<boost::offset_separator, 
-                                        std::basic_string<char>::const_iterator, 
+
+      typedef typename boost::tokenizer<boost::offset_separator,
+                                        std::basic_string<char>::const_iterator,
                                         std::basic_string<char> > tokenizer_type;
       tokenizer_type tok(s, osf);
       for(typename tokenizer_type::iterator ti=tok.begin(); ti!=tok.end();++ti) {
@@ -184,34 +185,34 @@ namespace date_time {
       }
       return date_type(y,m,d);
     }
-    
+
     //! Helper function for 'date gregorian::from_stream()'
     /*! Creates a string from the iterators that reference the
-     * begining & end of a char[] or string. All elements are 
+     * begining & end of a char[] or string. All elements are
      * used in output string */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     char) 
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& end,
+                     char)
     {
-      std::stringstream ss("");
+      std::ostringstream ss;
       while(beg != end) {
         ss << *beg++;
       }
       return parse_date<date_type>(ss.str());
     }
- 
+
     //! Helper function for 'date gregorian::from_stream()'
     /*! Returns the first string found in the stream referenced by the
      * begining & end iterators */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     std::string) 
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& /* end */,
+                     std::string const&)
     {
       return parse_date<date_type>(*beg);
     }
@@ -220,22 +221,30 @@ namespace date_time {
      * parse_date<>()? In the mean time this gets us started... */
     //! Helper function for 'date gregorian::from_stream()'
     /*! Creates a string from the iterators that reference the
-     * begining & end of a wstring. All elements are 
+     * begining & end of a wstring. All elements are
      * used in output string */
     template<class date_type, class iterator_type>
-    inline 
-    date_type from_stream_type(iterator_type& beg, 
-                               iterator_type& end,
-                               wchar_t) 
+    inline
+    date_type from_stream_type(iterator_type& beg,
+                               iterator_type const& end,
+                               wchar_t)
     {
-      std::stringstream ss("");
-      while(beg != end) {
+      std::ostringstream ss;
 #if !defined(BOOST_DATE_TIME_NO_LOCALE)
-        ss << std::use_facet<std::ctype<wchar_t> >(std::locale()).narrow(*beg++, 'X'); // 'X' will cause exception to be thrown
+      std::locale loc;
+      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
+      while(beg != end) {
+        ss << fac.narrow(*beg++, 'X'); // 'X' will cause exception to be thrown
+      }
 #else
-        ss << ss.narrow(*beg++, 'X');
-#endif
+      while(beg != end) {
+        char c = 'X'; // 'X' will cause exception to be thrown
+        const wchar_t wc = *beg++;
+        if (wc >= 0 && wc <= 127)
+          c = static_cast< char >(wc);
+        ss << c;
       }
+#endif
       return parse_date<date_type>(ss.str());
     }
 #ifndef BOOST_NO_STD_WSTRING
@@ -243,21 +252,29 @@ namespace date_time {
     /*! Creates a string from the first wstring found in the stream
      * referenced by the begining & end iterators */
     template<class date_type, class iterator_type>
-    inline 
+    inline
     date_type
-    from_stream_type(iterator_type& beg, 
-                     iterator_type& end,
-                     std::wstring) {
+    from_stream_type(iterator_type& beg,
+                     iterator_type const& /* end */,
+                     std::wstring const&) {
       std::wstring ws = *beg;
-      std::stringstream ss("");
+      std::ostringstream ss;
       std::wstring::iterator wsb = ws.begin(), wse = ws.end();
-      while(wsb != wse) {
 #if !defined(BOOST_DATE_TIME_NO_LOCALE)
-        ss << std::use_facet<std::ctype<wchar_t> >(std::locale()).narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
+      std::locale loc;
+      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
+      while(wsb != wse) {
+        ss << fac.narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
+      }
 #else
-        ss << ss.narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
-#endif
+      while(wsb != wse) {
+        char c = 'X'; // 'X' will cause exception to be thrown
+        const wchar_t wc = *wsb++;
+        if (wc >= 0 && wc <= 127)
+          c = static_cast< char >(wc);
+        ss << c;
       }
+#endif
       return parse_date<date_type>(ss.str());
     }
 #endif // BOOST_NO_STD_WSTRING
@@ -266,30 +283,30 @@ namespace date_time {
 #else
     //! function called by wrapper functions: date_period_from_(w)string()
     template<class date_type, class charT>
-    period<date_type, typename date_type::duration_type> 
+    period<date_type, typename date_type::duration_type>
     from_simple_string_type(const std::basic_string<charT>& s){
       typedef typename std::basic_string<charT>::traits_type traits_type;
       typedef typename boost::char_separator<charT, traits_type> char_separator;
-      typedef typename boost::tokenizer<char_separator, 
-                                        typename std::basic_string<charT>::const_iterator, 
+      typedef typename boost::tokenizer<char_separator,
+                                        typename std::basic_string<charT>::const_iterator,
                                         std::basic_string<charT> > tokenizer;
       const charT sep_list[4] = {'[','/',']','\0'};
       char_separator sep(sep_list);
       tokenizer tokens(s, sep);
-      typename tokenizer::iterator tok_it = tokens.begin(); 
+      typename tokenizer::iterator tok_it = tokens.begin();
       std::basic_string<charT> date_string = *tok_it;
       // get 2 string iterators and generate a date from them
-      typename std::basic_string<charT>::iterator date_string_start = date_string.begin(), 
-                                                  date_string_end = date_string.end(); 
+      typename std::basic_string<charT>::iterator date_string_start = date_string.begin(),
+                                                  date_string_end = date_string.end();
       typedef typename std::iterator_traits<typename std::basic_string<charT>::iterator>::value_type value_type;
       date_type d1 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
       date_string = *(++tok_it); // next token
-      date_string_start = date_string.begin(), date_string_end = date_string.end(); 
+      date_string_start = date_string.begin(), date_string_end = date_string.end();
       date_type d2 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
-      return period<date_type, typename date_type::duration_type>(d1, d2); 
+      return period<date_type, typename date_type::duration_type>(d1, d2);
     }
 #endif
-    
+
 } } //namespace date_time