EIC code displayed by LXR master/​include/​boost/​date_time/​format_date_parser.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:30:38

 
 #ifndef DATE_TIME_FORMAT_DATE_PARSER_HPP__
 #define DATE_TIME_FORMAT_DATE_PARSER_HPP__
 
 /* Copyright (c) 2004-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$
  */
 
 
 #include "boost/lexical_cast.hpp"
 #include "boost/date_time/string_parse_tree.hpp"
 #include "boost/date_time/strings_from_facet.hpp"
 #include "boost/date_time/special_values_parser.hpp"
 #include <string>
 #include <vector>
 #include <sstream>
 #include <iterator>
 #ifndef BOOST_NO_STDC_NAMESPACE
 #  include <cctype>
 #else
 #  include <ctype.h>
 #endif
 
 #ifdef BOOST_NO_STDC_NAMESPACE
 namespace std {
   using ::isspace;
   using ::isdigit;
 }
 #endif
 namespace boost { namespace date_time {
 
 //! Helper function for parsing fixed length strings into integers
 /*! Will consume 'length' number of characters from stream. Consumed
  * character are transfered to parse_match_result struct.
  * Returns '-1' if no number can be parsed or incorrect number of
  * digits in stream. */
 template<typename int_type, typename charT>
 inline
 int_type
 fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
                     std::istreambuf_iterator<charT>& stream_end,
                     parse_match_result<charT>& mr,
                     unsigned int length,
                     const charT& fill_char)
 {
   //typedef std::basic_string<charT>  string_type;
   unsigned int j = 0;
   //string_type s;
   while (j < length && itr != stream_end &&
       (std::isdigit(*itr) || *itr == fill_char)) {
     if(*itr == fill_char) {
       /* Since a fill_char can be anything, we convert it to a zero.
        * lexical_cast will behave predictably when zero is used as fill. */
       mr.cache += ('0');
     }
     else {
       mr.cache += (*itr);
     }
     itr++;
     j++;
   }
   int_type i = static_cast<int_type>(-1);
   // mr.cache will hold leading zeros. size() tells us when input is too short.
   if(mr.cache.size() < length) {
     return i;
   }
   try {
     i = boost::lexical_cast<int_type>(mr.cache);
   }catch(bad_lexical_cast&){
     // we want to return -1 if the cast fails so nothing to do here
   }
   return i;
 }
 
 //! Helper function for parsing fixed length strings into integers
 /*! Will consume 'length' number of characters from stream. Consumed
  * character are transfered to parse_match_result struct.
  * Returns '-1' if no number can be parsed or incorrect number of
  * digits in stream. */
 template<typename int_type, typename charT>
 inline
 int_type
 fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
                     std::istreambuf_iterator<charT>& stream_end,
                     parse_match_result<charT>& mr,
                     unsigned int length)
 {
   return fixed_string_to_int<int_type, charT>(itr, stream_end, mr, length, '0');
 }
 
 //! Helper function for parsing varied length strings into integers
 /*! Will consume 'max_length' characters from stream only if those
  * characters are digits. Returns '-1' if no number can be parsed.
  * Will not parse a number preceeded by a '+' or '-'. */
 template<typename int_type, typename charT>
 inline
 int_type
 var_string_to_int(std::istreambuf_iterator<charT>& itr,
                   const std::istreambuf_iterator<charT>& stream_end,
                   unsigned int max_length)
 {
   typedef std::basic_string<charT>  string_type;
   unsigned int j = 0;
   string_type s;
   while (itr != stream_end && (j < max_length) && std::isdigit(*itr)) {
     s += (*itr);
     ++itr;
     ++j;
   }
   int_type i = static_cast<int_type>(-1);
   if(!s.empty()) {
     i = boost::lexical_cast<int_type>(s);
   }
   return i;
 }
 
 
 //! Class with generic date parsing using a format string
 /*! The following is the set of recognized format specifiers
  -  %a - Short weekday name
  -  %A - Long weekday name
  -  %b - Abbreviated month name
  -  %B - Full month name
  -  %d - Day of the month as decimal 01 to 31
  -  %j - Day of year as decimal from 001 to 366
  -  %m - Month name as a decimal 01 to 12
  -  %U - Week number 00 to 53 with first Sunday as the first day of week 1?
  -  %w - Weekday as decimal number 0 to 6 where Sunday == 0
  -  %W - Week number 00 to 53 where Monday is first day of week 1
  -  %x - facet default date representation
  -  %y - Year without the century - eg: 04 for 2004
  -  %Y - Year with century
 
  The weekday specifiers (%a and %A) do not add to the date construction,
  but they provide a way to skip over the weekday names for formats that
  provide them.
 
  todo -- Another interesting feature that this approach could provide is
          an option to fill in any missing fields with the current values
          from the clock.  So if you have %m-%d the parser would detect
          the missing year value and fill it in using the clock.
 
  todo -- What to do with the %x.  %x in the classic facet is just bad...
 
  */
 template<class date_type, typename charT>
 class format_date_parser
 {
  public:
   typedef std::basic_string<charT>        string_type;
   typedef std::basic_istringstream<charT>  stringstream_type;
   typedef std::istreambuf_iterator<charT> stream_itr_type;
   typedef typename string_type::const_iterator const_itr;
   typedef typename date_type::year_type  year_type;
   typedef typename date_type::month_type month_type;
   typedef typename date_type::day_type day_type;
   typedef typename date_type::duration_type duration_type;
   typedef typename date_type::day_of_week_type day_of_week_type;
   typedef typename date_type::day_of_year_type day_of_year_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> > input_collection_type;
 
   // TODO sv_parser uses its default constructor - write the others
 
   format_date_parser(const string_type& format_str,
                      const input_collection_type& month_short_names,
                      const input_collection_type& month_long_names,
                      const input_collection_type& weekday_short_names,
                      const input_collection_type& weekday_long_names) :
     m_format(format_str),
     m_month_short_names(month_short_names, 1),
     m_month_long_names(month_long_names, 1),
     m_weekday_short_names(weekday_short_names),
     m_weekday_long_names(weekday_long_names)
   {}
 
   format_date_parser(const string_type& format_str,
                      const std::locale& locale) :
     m_format(format_str),
     m_month_short_names(gather_month_strings<charT>(locale), 1),
     m_month_long_names(gather_month_strings<charT>(locale, false), 1),
     m_weekday_short_names(gather_weekday_strings<charT>(locale)),
     m_weekday_long_names(gather_weekday_strings<charT>(locale, false))
   {}
 
   format_date_parser(const format_date_parser<date_type,charT>& fdp)
   {
     this->m_format = fdp.m_format;
     this->m_month_short_names = fdp.m_month_short_names;
     this->m_month_long_names = fdp.m_month_long_names;
     this->m_weekday_short_names = fdp.m_weekday_short_names;
     this->m_weekday_long_names = fdp.m_weekday_long_names;
   }
 
   string_type format() const
   {
     return m_format;
   }
 
   void format(string_type format_str)
   {
     m_format = format_str;
   }
 
   void short_month_names(const input_collection_type& month_names)
   {
     m_month_short_names = parse_tree_type(month_names, 1);
   }
   void long_month_names(const input_collection_type& month_names)
   {
     m_month_long_names = parse_tree_type(month_names, 1);
   }
   void short_weekday_names(const input_collection_type& weekday_names)
   {
     m_weekday_short_names = parse_tree_type(weekday_names);
   }
   void long_weekday_names(const input_collection_type& weekday_names)
   {
     m_weekday_long_names = parse_tree_type(weekday_names);
   }
 
   date_type
   parse_date(const string_type& value,
              const string_type& format_str,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
     stringstream_type ss(value);
     stream_itr_type sitr(ss);
     stream_itr_type stream_end;
     return parse_date(sitr, stream_end, format_str, sv_parser);
   }
 
   date_type
   parse_date(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
     return parse_date(sitr, stream_end, m_format, sv_parser);
   }
 
   /*! Of all the objects that the format_date_parser can parse, only a
    * date can be a special value. Therefore, only parse_date checks
    * for special_values. */
   date_type
   parse_date(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              const special_values_parser<date_type,charT>& sv_parser) const
   {
     bool use_current_char = false;
 
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     short year(0), month(0), day(0), day_of_year(0);// wkday(0);
     /* Initialized the following to their minimum values. These intermediate
      * objects are used so we get specific exceptions when part of the input
      * is unparsable.
      * Ex: "205-Jan-15" will throw a bad_year, "2005-Jsn-15"- bad_month, etc.*/
     year_type t_year(1400);
     month_type t_month(1);
     day_type t_day(1);
     day_of_week_type wkday(0);
 
 
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
         if ( ++itr == format_str.end())
           break;
         if (*itr != '%') {
           switch(*itr) {
           case 'a':
             {
               //this value is just throw away.  It could be used for
               //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               match_results mr = m_weekday_short_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
                 // check special_values
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'A':
             {
               //this value is just throw away.  It could be used for
               //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               match_results mr = m_weekday_long_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
                 // check special_values
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'b':
             {
               match_results mr = m_month_short_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
                 // check special_values
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'B':
             {
               match_results mr = m_month_long_names.match(sitr, stream_end);
               if(mr.current_match == match_results::PARSE_ERROR) {
                 // check special_values
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'd':
             {
               match_results mr;
               day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
               if(day == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_day = day_type(day);
               break;
             }
           case 'e':
             {
               match_results mr;
               day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2, ' ');
               if(day == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_day = day_type(day);
               break;
             }
           case 'j':
             {
               match_results mr;
               day_of_year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 3);
               if(day_of_year == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               // these next two lines are so we get an exception with bad input
               day_of_year_type t_day_of_year(1);
               t_day_of_year = day_of_year_type(day_of_year);
               break;
             }
           case 'm':
             {
               match_results mr;
               month = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
               if(month == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_month = month_type(month);
               break;
             }
           case 'Y':
             {
               match_results mr;
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 4);
               if(year == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               t_year = year_type(year);
               break;
             }
           case 'y':
             {
               match_results mr;
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
               if(year == -1) {
                 if(sv_parser.match(sitr, stream_end, mr)) {
                   return date_type(static_cast<special_values>(mr.current_match));
                 }
               }
               year += 2000; //make 2 digit years in this century
               t_year = year_type(year);
               break;
             }
           default:
             {} //ignore those we don't understand
 
           }//switch
 
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
 
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
         }
         else {
           sitr++;
         }
       }
     }
 
     if (day_of_year > 0) {
       date_type d(static_cast<unsigned short>(year-1),12,31); //end of prior year
       return d + duration_type(day_of_year);
     }
 
     return date_type(t_year, t_month, t_day); // exceptions were thrown earlier
                                         // if input was no good
   }
 
   //! Throws bad_month if unable to parse
   month_type
   parse_month(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
     match_results mr;
     return parse_month(sitr, stream_end, format_str, mr);
   }
 
   //! Throws bad_month if unable to parse
   month_type
   parse_month(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
     bool use_current_char = false;
 
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     short month(0);
 
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
         if ( ++itr == format_str.end())
           break;
         if (*itr != '%') {
           switch(*itr) {
           case 'b':
             {
               mr = m_month_short_names.match(sitr, stream_end);
               month = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'B':
             {
               mr = m_month_long_names.match(sitr, stream_end);
               month = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'm':
             {
               month = var_string_to_int<short, charT>(sitr, stream_end, 2);
               // var_string_to_int returns -1 if parse failed. That will
               // cause a bad_month exception to be thrown so we do nothing here
               break;
             }
           default:
             {} //ignore those we don't understand
 
           }//switch
 
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
 
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
         }
         else {
           sitr++;
         }
       }
     }
 
     return month_type(month); // throws bad_month exception when values are zero
   }
 
   //! Expects 1 or 2 digits 1-31. Throws bad_day_of_month if unable to parse
   day_type
   parse_var_day_of_month(std::istreambuf_iterator<charT>& sitr,
                          std::istreambuf_iterator<charT>& stream_end) const
   {
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     return day_type(var_string_to_int<short, charT>(sitr, stream_end, 2));
   }
   //! Expects 2 digits 01-31. Throws bad_day_of_month if unable to parse
   day_type
   parse_day_of_month(std::istreambuf_iterator<charT>& sitr,
                      std::istreambuf_iterator<charT>& stream_end) const
   {
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     //return day_type(var_string_to_int<short, charT>(sitr, stream_end, 2));
     match_results mr;
     return day_type(fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2));
   }
 
   day_of_week_type
   parse_weekday(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
     match_results mr;
     return parse_weekday(sitr, stream_end, format_str, mr);
   }
   day_of_week_type
   parse_weekday(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
     bool use_current_char = false;
 
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     short wkday(0);
 
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
         if ( ++itr == format_str.end())
           break;
         if (*itr != '%') {
           switch(*itr) {
           case 'a':
             {
               //this value is just throw away.  It could be used for
               //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               mr = m_weekday_short_names.match(sitr, stream_end);
               wkday = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'A':
             {
               //this value is just throw away.  It could be used for
               //error checking potentially, but it isn't helpful in
               //actually constructing the date - we just need to get it
               //out of the stream
               mr = m_weekday_long_names.match(sitr, stream_end);
               wkday = mr.current_match;
               if (mr.has_remaining()) {
                 use_current_char = true;
               }
               break;
             }
           case 'w':
             {
               // weekday as number 0-6, Sunday == 0
               wkday = var_string_to_int<short, charT>(sitr, stream_end, 2);
               break;
             }
           default:
             {} //ignore those we don't understand
 
           }//switch
 
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
 
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         if (use_current_char) {
           use_current_char = false;
         }
         else {
           sitr++;
         }
       }
     }
 
     return day_of_week_type(wkday); // throws bad_day_of_month exception
                                     // when values are zero
   }
 
   //! throws bad_year if unable to parse
   year_type
   parse_year(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str) const
   {
     match_results mr;
     return parse_year(sitr, stream_end, format_str, mr);
   }
 
   //! throws bad_year if unable to parse
   year_type
   parse_year(std::istreambuf_iterator<charT>& sitr,
              std::istreambuf_iterator<charT>& stream_end,
              string_type format_str,
              match_results& mr) const
   {
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
 
     unsigned short year(0);
 
     const_itr itr(format_str.begin());
     while (itr != format_str.end() && (sitr != stream_end)) {
       if (*itr == '%') {
         if ( ++itr == format_str.end())
           break;
         if (*itr != '%') {
           //match_results mr;
           switch(*itr) {
           case 'Y':
             {
               // year from 4 digit string
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 4);
               break;
             }
           case 'y':
             {
               // year from 2 digit string (no century)
               year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
               year += 2000; //make 2 digit years in this century
               break;
             }
           default:
             {} //ignore those we don't understand
 
           }//switch
 
         }
         else { // itr == '%', second consecutive
           sitr++;
         }
 
         itr++; //advance past format specifier
       }
       else {  //skip past chars in format and in buffer
         itr++;
         sitr++;
       }
     }
 
     return year_type(year); // throws bad_year exception when values are zero
   }
 
 
  private:
   string_type m_format;
   parse_tree_type m_month_short_names;
   parse_tree_type m_month_long_names;
   parse_tree_type m_weekday_short_names;
   parse_tree_type m_weekday_long_names;
 
 };
 
 } } //namespace
 
 #endif
 
 
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team