passenger-jmazzi 2.2.9

data/ext/boost/date_time/date_iterator.hpp

@@ -0,0 +1,101 @@
+#ifndef DATE_ITERATOR_HPP___
+#define DATE_ITERATOR_HPP___
+
+/* Copyright (c) 2002,2003 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 <iterator>
+
+namespace boost {
+namespace date_time {
+  //! An iterator over dates with varying resolution (day, week, month, year, etc)
+  enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
+
+  //! Base date iterator type
+  /*! This class provides the skeleton for the creation of iterators.
+   *  New and interesting interators can be created by plugging in a new
+   *  function that derives the next value from the current state.
+   *  generation of various types of -based information.
+   *
+   *  <b>Template Parameters</b>
+   *
+   *  <b>date_type</b>
+   *
+   *  The date_type is a concrete date_type. The date_type must
+   *  define a duration_type and a calendar_type.
+   */
+  template<class date_type>
+  class date_itr_base {
+  // works, but benefit unclear at the moment
+  //   class date_itr_base : public std::iterator<std::input_iterator_tag, 
+  //                                             date_type, void, void, void>{
+  public:
+    typedef typename date_type::duration_type duration_type;
+    typedef date_type value_type;
+    typedef std::input_iterator_tag iterator_category;
+
+    date_itr_base(date_type d) : current_(d) {}
+    virtual ~date_itr_base() {};
+    date_itr_base& operator++() 
+    {
+      current_ = current_ + get_offset(current_);
+      return *this;
+    }
+    date_itr_base& operator--() 
+    {
+      current_ = current_ + get_neg_offset(current_);
+      return *this;
+    }
+    virtual duration_type get_offset(const date_type& current) const=0;
+    virtual duration_type get_neg_offset(const date_type& current) const=0;
+    date_type operator*() {return current_;};
+    date_type* operator->() {return &current_;};
+    bool operator<  (const date_type& d) {return current_ < d;}
+    bool operator<= (const date_type& d) {return current_ <= d;}
+    bool operator>  (const date_type& d) {return current_ > d;}
+    bool operator>= (const date_type& d) {return current_ >= d;}
+    bool operator== (const date_type& d) {return current_ == d;}
+    bool operator!= (const date_type& d) {return current_ != d;}    
+  private:
+    date_type current_;
+  };
+  
+  //! Overrides the base date iterator providing hook for functors
+  /*
+   *  <b>offset_functor</b>
+   *
+   *  The offset functor must define a get_offset function that takes the
+   *  current point in time and calculates and offset.
+   *
+   */
+  template<class offset_functor, class date_type>
+  class date_itr : public date_itr_base<date_type> {
+  public:
+    typedef typename date_type::duration_type duration_type;
+    date_itr(date_type d, int factor=1) : 
+      date_itr_base<date_type>(d), 
+      of_(factor) 
+    {}
+  private:
+    virtual duration_type get_offset(const date_type& current) const
+    {
+      return of_.get_offset(current);
+    }
+    virtual duration_type get_neg_offset(const date_type& current) const
+    {
+      return of_.get_neg_offset(current);
+    }
+    offset_functor of_;
+  };
+  
+
+  
+} } //namespace date_time
+
+
+#endif

data/ext/boost/date_time/date_names_put.hpp

@@ -0,0 +1,320 @@
+#ifndef DATE_TIME_DATE_NAMES_PUT_HPP___
+#define DATE_TIME_DATE_NAMES_PUT_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/locale_config.hpp" // set BOOST_DATE_TIME_NO_LOCALE
+
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+
+#include "boost/date_time/special_defs.hpp"
+#include "boost/date_time/date_defs.hpp"
+#include "boost/date_time/parse_format_base.hpp"
+#include "boost/lexical_cast.hpp"
+#include <locale>
+
+
+namespace boost {
+namespace date_time {
+
+    //! Output facet base class for gregorian dates.
+    /*! This class is a base class for date facets used to localize the
+     *  names of months and the names of days in the week.
+     * 
+     * Requirements of Config
+     *  - define an enumeration month_enum that enumerates the months. 
+     *    The enumeration should be '1' based eg: Jan==1
+     *  - define as_short_string and as_long_string
+     *
+     * (see langer & kreft p334).
+     * 
+     */
+    template<class Config,
+             class charT = char, 
+             class OutputIterator = std::ostreambuf_iterator<charT> >
+    class date_names_put : public std::locale::facet
+    {
+    public:
+      date_names_put() {};
+      typedef OutputIterator iter_type;
+      typedef typename Config::month_type month_type;
+      typedef typename Config::month_enum month_enum;
+      typedef typename Config::weekday_enum weekday_enum;
+      typedef typename Config::special_value_enum special_value_enum;
+      //typedef typename Config::format_type format_type;
+      typedef std::basic_string<charT> string_type;
+      typedef charT char_type;
+      static const char_type default_special_value_names[3][17];
+      static const char_type separator[2];
+
+      static std::locale::id id;
+
+#if defined (__SUNPRO_CC) && defined (_RWSTD_VER)
+      std::locale::id& __get_id (void) const { return id; }
+#endif
+
+      void put_special_value(iter_type& oitr, special_value_enum sv) const
+      {
+        do_put_special_value(oitr, sv);
+      }
+      void put_month_short(iter_type& oitr, month_enum moy) const
+      {
+        do_put_month_short(oitr, moy);
+      }
+      void put_month_long(iter_type& oitr, month_enum moy) const
+      {
+        do_put_month_long(oitr, moy);
+      }
+      void put_weekday_short(iter_type& oitr, weekday_enum wd) const
+      {
+        do_put_weekday_short(oitr, wd);
+      }
+      void put_weekday_long(iter_type& oitr, weekday_enum wd) const
+      {
+        do_put_weekday_long(oitr, wd);
+      }
+      bool has_date_sep_chars() const
+      {
+        return do_has_date_sep_chars();
+      }
+      void year_sep_char(iter_type& oitr) const
+      {
+        do_year_sep_char(oitr);
+      }
+      //! char between year-month
+      void month_sep_char(iter_type& oitr) const
+      {
+        do_month_sep_char(oitr);
+      }
+      //! Char to separate month-day
+      void day_sep_char(iter_type& oitr) const
+      {
+        do_day_sep_char(oitr);
+      }
+      //! Determines the order to put the date elements
+      ymd_order_spec date_order() const
+      {
+        return do_date_order();
+      }
+      //! Determines if month is displayed as integer, short or long string
+      month_format_spec month_format() const
+      {
+        return do_month_format();
+      }
+
+    protected:
+      //! Default facet implementation uses month_type defaults
+      virtual void do_put_month_short(iter_type& oitr, month_enum moy) const
+      {
+        month_type gm(moy);
+        charT c = '\0';
+        put_string(oitr, gm.as_short_string(c));
+      }
+      //! Default facet implementation uses month_type defaults
+      virtual void do_put_month_long(iter_type& oitr, 
+                                     month_enum moy) const
+      {
+        month_type gm(moy);
+        charT c = '\0';
+        put_string(oitr, gm.as_long_string(c));
+      }
+      //! Default facet implementation for special value types
+      virtual void do_put_special_value(iter_type& oitr, special_value_enum sv) const
+      {
+        if(sv <= 2) { // only output not_a_date_time, neg_infin, or pos_infin
+          string_type s(default_special_value_names[sv]);
+          put_string(oitr, s);
+        }
+      }
+      virtual void do_put_weekday_short(iter_type&, weekday_enum) const
+      {
+      }
+      virtual void do_put_weekday_long(iter_type&, weekday_enum) const
+      {
+      }
+      virtual bool do_has_date_sep_chars() const
+      {
+        return true;
+      }
+      virtual void do_year_sep_char(iter_type& oitr) const
+      {
+        string_type s(separator);
+        put_string(oitr, s);
+      }
+      //! char between year-month
+      virtual void do_month_sep_char(iter_type& oitr) const
+      {
+        string_type s(separator);
+        put_string(oitr, s);
+      }
+      //! Char to separate month-day
+      virtual void do_day_sep_char(iter_type& oitr) const
+      {
+        string_type s(separator); //put in '-'
+        put_string(oitr, s);
+      }
+      //! Default for date order 
+      virtual ymd_order_spec do_date_order() const
+      {
+        return ymd_order_iso;
+      }
+      //! Default month format
+      virtual month_format_spec do_month_format() const
+      {
+        return month_as_short_string;
+      }
+      void put_string(iter_type& oi, const charT* const s) const
+      {
+        string_type s1(boost::lexical_cast<string_type>(s));
+        typename string_type::iterator si,end;
+        for (si=s1.begin(), end=s1.end(); si!=end; si++, oi++) {
+          *oi = *si;
+        }
+      }
+      void put_string(iter_type& oi, const string_type& s1) const
+      {
+        typename string_type::const_iterator si,end;
+        for (si=s1.begin(), end=s1.end(); si!=end; si++, oi++) {
+          *oi = *si;
+        }
+      }
+    };
+    
+    template<class Config, class charT, class OutputIterator>
+    const typename date_names_put<Config, charT, OutputIterator>::char_type 
+    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = { 
+      {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'},
+      {'-','i','n','f','i','n','i','t','y'},
+      {'+','i','n','f','i','n','i','t','y'} };
+
+    template<class Config, class charT, class OutputIterator>
+    const typename date_names_put<Config, charT, OutputIterator>::char_type 
+    date_names_put<Config, charT, OutputIterator>::separator[2] = 
+      {'-', '\0'} ;
+    
+
+    //! Generate storage location for a std::locale::id 
+    template<class Config, class charT, class OutputIterator>
+    std::locale::id date_names_put<Config, charT, OutputIterator>::id;
+
+    //! A date name output facet that takes an array of char* to define strings
+    template<class Config,
+             class charT = char, 
+             class OutputIterator = std::ostreambuf_iterator<charT> >
+    class all_date_names_put : public date_names_put<Config, charT, OutputIterator>
+    {
+    public:
+      all_date_names_put(const charT* const month_short_names[],
+                         const charT* const month_long_names[],
+                         const charT* const special_value_names[],
+                         const charT* const weekday_short_names[],
+                         const charT* const weekday_long_names[],
+                         charT separator_char = '-',
+                         ymd_order_spec order_spec = ymd_order_iso,
+                         month_format_spec month_format = month_as_short_string) :
+        month_short_names_(month_short_names),
+        month_long_names_(month_long_names),
+        special_value_names_(special_value_names),
+        weekday_short_names_(weekday_short_names),
+        weekday_long_names_(weekday_long_names),
+        order_spec_(order_spec),
+        month_format_spec_(month_format)
+      {
+        separator_char_[0] = separator_char;
+        separator_char_[1] = '\0';
+
+      };
+      typedef OutputIterator iter_type;
+      typedef typename Config::month_enum month_enum;
+      typedef typename Config::weekday_enum weekday_enum;
+      typedef typename Config::special_value_enum special_value_enum;
+
+      const charT* const* get_short_month_names() const 
+      {
+        return month_short_names_;
+      }
+      const charT* const* get_long_month_names() const 
+      {
+        return month_long_names_;
+      }
+      const charT* const* get_special_value_names() const 
+      {
+        return special_value_names_;
+      }
+      const charT* const* get_short_weekday_names()const  
+      {
+        return weekday_short_names_;
+      }
+      const charT* const* get_long_weekday_names()const 
+      {
+        return weekday_long_names_;
+      }
+
+    protected:
+      //! Generic facet that takes array of chars
+      virtual void do_put_month_short(iter_type& oitr, month_enum moy) const
+      {
+        this->put_string(oitr, month_short_names_[moy-1]);
+      }
+      //! Long month names 
+      virtual void do_put_month_long(iter_type& oitr, month_enum moy) const
+      {
+        this->put_string(oitr, month_long_names_[moy-1]);
+      }
+      //! Special values names
+      virtual void do_put_special_value(iter_type& oitr, special_value_enum sv) const
+      {
+        this->put_string(oitr, special_value_names_[sv]);
+      }
+      virtual void do_put_weekday_short(iter_type& oitr, weekday_enum wd) const
+      {
+        this->put_string(oitr, weekday_short_names_[wd]);
+      }
+      virtual void do_put_weekday_long(iter_type& oitr, weekday_enum wd) const
+      {
+        this->put_string(oitr, weekday_long_names_[wd]);
+      }
+      //! char between year-month
+      virtual void do_month_sep_char(iter_type& oitr) const
+      {
+        this->put_string(oitr, separator_char_);
+      }
+      //! Char to separate month-day
+      virtual void do_day_sep_char(iter_type& oitr) const
+      {
+        this->put_string(oitr, separator_char_);
+      }
+      //! Set the date ordering
+      virtual ymd_order_spec do_date_order() const
+      {
+        return order_spec_;
+      }
+      //! Set the date ordering
+      virtual month_format_spec do_month_format() const
+      {
+        return month_format_spec_;
+      }
+
+    private:
+      const charT* const* month_short_names_;
+      const charT* const* month_long_names_;
+      const charT* const* special_value_names_;
+      const charT* const* weekday_short_names_;
+      const charT* const* weekday_long_names_;
+      charT separator_char_[2];
+      ymd_order_spec order_spec_;
+      month_format_spec month_format_spec_;      
+    };
+
+} } //namespace boost::date_time
+
+#endif //BOOST_NO_STD_LOCALE
+
+#endif

data/ext/boost/date_time/date_parsing.hpp

@@ -0,0 +1,299 @@
+#ifndef _DATE_TIME_DATE_PARSING_HPP___
+#define _DATE_TIME_DATE_PARSING_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/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>
+
+#if defined(BOOST_NO_STD_LOCALE)
+#include <cctype> // ::tolower(int)
+#else
+#include <locale> // std::tolower(char, locale)
+#endif
+
+namespace boost {
+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 
+   * 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++)));
+#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);
+#endif
+        
+      }
+      return tmp;
+    }
+    
+    //! 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) {
+      if((s.at(0) >= '0') && (s.at(0) <= '9')) {
+        return boost::lexical_cast<unsigned short>(s);
+      } 
+      else {
+        s = 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);
+        if(iter != ptr->end()) { // required for STLport
+          return iter->second;
+        }
+      }
+      return 13; // intentionally out of range - name not found
+    }
+ 
+    //! 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.
+     * 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 */
+    template<class charT>
+    short find_match(const charT* const* short_names, 
+                     const charT* const* long_names, 
+                     short limit,
+                     const std::basic_string<charT>& s) {
+      for(short i = 0; i <= limit; ++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
+    }
+    
+    //! 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 
+     */
+    template<class date_type>
+    date_type
+    parse_date(const std::string& s, int order_spec = ymd_order_iso) {
+      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;
+      unsigned short year(0), month(0), day(0);
+      typedef typename std::basic_string<char>::traits_type traits_type;
+      typedef boost::char_separator<char, traits_type> char_separator_type;
+      typedef boost::tokenizer<char_separator_type,
+                               std::basic_string<char>::const_iterator,
+                               std::basic_string<char> > tokenizer;
+      typedef boost::tokenizer<char_separator_type,
+                               std::basic_string<char>::const_iterator,
+                               std::basic_string<char> >::iterator tokenizer_iterator;
+      // may need more delimiters, these work for the regression tests
+      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(); 
+          ++beg, ++pos) {
+        switch(spec_str.at(pos)) {
+          case 'y': 
+          {
+            year = boost::lexical_cast<unsigned short>(*beg);
+            break;
+          }
+          case 'm': 
+          {
+            month = month_str_to_ushort<month_type>(*beg);
+            break;
+          }
+          case 'd': 
+          {
+            day = boost::lexical_cast<unsigned short>(*beg);
+            break;
+          }
+        } //switch
+      }
+      return date_type(year, month, day);
+    }
+    
+    //! Generic function to parse undelimited date (eg: 20020201)
+    template<class date_type>
+    date_type
+    parse_undelimited_date(const std::string& s) {
+      int offsets[] = {4,2,2};
+      int pos = 0;
+      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. 
+       * 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, 
+                                        std::basic_string<char> > tokenizer_type;
+      tokenizer_type tok(s, osf);
+      for(typename tokenizer_type::iterator ti=tok.begin(); ti!=tok.end();++ti) {
+        unsigned short i = boost::lexical_cast<unsigned short>(*ti);
+        switch(pos) {
+        case 0: y = i; break;
+        case 1: m = i; break;
+        case 2: d = i; break;
+        }
+        pos++;
+      }
+      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 
+     * used in output string */
+    template<class date_type, class iterator_type>
+    inline 
+    date_type
+    from_stream_type(iterator_type& beg, 
+                     iterator_type& end,
+                     char) 
+    {
+      std::stringstream 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 
+    date_type
+    from_stream_type(iterator_type& beg, 
+                     iterator_type& end,
+                     std::string) 
+    {
+      return parse_date<date_type>(*beg);
+    }
+
+    /* I believe the wchar stuff would be best elsewhere, perhaps in
+     * 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 
+     * 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) 
+    {
+      std::stringstream ss("");
+      while(beg != end) {
+#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
+#else
+        ss << ss.narrow(*beg++, 'X');
+#endif
+      }
+      return parse_date<date_type>(ss.str());
+    }
+#ifndef BOOST_NO_STD_WSTRING
+    //! Helper function for 'date gregorian::from_stream()'
+    /*! 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 
+    date_type
+    from_stream_type(iterator_type& beg, 
+                     iterator_type& end,
+                     std::wstring) {
+      std::wstring ws = *beg;
+      std::stringstream 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
+#else
+        ss << ss.narrow(*wsb++, 'X'); // 'X' will cause exception to be thrown
+#endif
+      }
+      return parse_date<date_type>(ss.str());
+    }
+#endif // BOOST_NO_STD_WSTRING
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+    // This function cannot be compiled with MSVC 6.0 due to internal compiler shorcomings
+#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> 
+    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, 
+                                        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(); 
+      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(); 
+      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_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); 
+    }
+#endif
+    
+} } //namespace date_time
+
+
+
+
+#endif
+