Ticket 10272

include/boost/property_tree/detail/info_parser_read.hpp

@@ -60,24 +60,13 @@ namespace boost { namespace property_tree { namespace info_parser
         }
         return result;
     }
-
-    // Detect whitespace in a not very smart way.
-    template <class Ch>
-    bool is_ascii_space(Ch c)
-    {
-        // Everything outside ASCII is not space.
-        unsigned n = c;
-        if (n > 127)
-            return false;
-        return isspace(c);
-    }
 
     // Advance pointer past whitespace
     template<class Ch>
     void skip_whitespace(const Ch *&text)
     {
         using namespace std;
-        while (is_ascii_space(*text))
+        while (isspace(*text))
             ++text;
     }
 
@@ -88,7 +77,7 @@ namespace boost { namespace property_tree { namespace info_parser
         using namespace std;
         skip_whitespace(text);
         const Ch *start = text;
-        while (!is_ascii_space(*text) && *text != Ch(';') && *text != Ch('\0'))
+        while (!isspace(*text) && *text != Ch(';') && *text != Ch('\0'))
             ++text;
         return expand_escapes(start, text);
     }
@@ -102,7 +91,7 @@ namespace boost { namespace property_tree { namespace info_parser
         const Ch *start = text;
         while (*text != Ch('\0') && *text != Ch(';'))
             ++text;
-        while (text > start && is_ascii_space(*(text - 1)))
+        while (text > start && isspace(*(text - 1)))
             --text;
         return expand_escapes(start, text);
     }

include/boost/property_tree/detail/json_parser_read.hpp

@@ -32,9 +32,8 @@ namespace boost { namespace property_tree { namespace json_parser
     template<class Ptree>
     struct context
     {
-
-        typedef typename Ptree::key_type::value_type Ch;
-        typedef std::basic_string<Ch> Str;
+	typedef typename Ptree::key_type Str;
+        typedef typename Str::value_type Ch;
         typedef typename std::vector<Ch>::iterator It;
 
         Str string;
@@ -162,7 +161,8 @@ namespace boost { namespace property_tree { namespace json_parser
     {
 
         typedef context<Ptree> Context;
-        typedef typename Ptree::key_type::value_type Ch;
+        typedef typename Ptree::key_type Str;
+        typedef typename Str::value_type Ch;
 
         mutable Context c;
 
@@ -239,8 +239,8 @@ namespace boost { namespace property_tree { namespace json_parser
                     =   !ch_p("-") >>
                         (ch_p("0") | (range_p(Ch('1'), Ch('9')) >> *digit_p)) >>
                         !(ch_p(".") >> +digit_p) >>
-                        !(chset_p(detail::widen<Ch>("eE").c_str()) >>
-                          !chset_p(detail::widen<Ch>("-+").c_str()) >>
+                        !(chset_p(detail::widen<Str>("eE").c_str()) >>
+                          !chset_p(detail::widen<Str>("-+").c_str()) >>
                           +digit_p)
                         ;
 
@@ -255,7 +255,7 @@ namespace boost { namespace property_tree { namespace json_parser
                     ;
 
                 escape
-                    =   chset_p(detail::widen<Ch>("\"\\/bfnrt").c_str())
+                    =   chset_p(detail::widen<Str>("\"\\/bfnrt").c_str())
                             [typename Context::a_escape(self.c)]
                     |   'u' >> uint_parser<unsigned long, 16, 4, 4>()
                             [typename Context::a_unicode(self.c)]

include/boost/property_tree/detail/ptree_utils.hpp

@@ -54,49 +54,48 @@ namespace boost { namespace property_tree { namespace detail
 
 
     // Naively convert narrow string to another character type
-    template<class Ch>
-    std::basic_string<Ch> widen(const char *text)
+    template<typename Str>
+    Str widen(const char *text)
     {
-        std::basic_string<Ch> result;
+	Str result;
         while (*text)
         {
-            result += Ch(*text);
+            result += typename Str::value_type(*text);
             ++text;
         }
         return result;
     }
 
     // Naively convert string to narrow character type
-    template<class Ch>
-    std::string narrow(const Ch *text)
+    template<typename Str, typename char_type>
+    Str narrow(const char_type *text)
     {
-        std::string result;
+	Str result;
         while (*text)
         {
             if (*text < 0 || *text > (std::numeric_limits<char>::max)())
                 result += '*';
             else
-                result += char(*text);
+                result += typename Str::value_type(*text);
             ++text;
         }
         return result;
     }
 
     // Remove trailing and leading spaces
-    template<class Ch>
-    std::basic_string<Ch> trim(const std::basic_string<Ch> &s,
-                               const std::locale &loc = std::locale())
+    template<class Str>
+    Str trim(const Str &s, const std::locale &loc = std::locale())
     {
-        typename std::basic_string<Ch>::const_iterator first = s.begin();
-        typename std::basic_string<Ch>::const_iterator end = s.end();
+        typename Str::const_iterator first = s.begin();
+        typename Str::const_iterator end = s.end();
         while (first != end && std::isspace(*first, loc))
             ++first;
         if (first == end)
-            return std::basic_string<Ch>();
-        typename std::basic_string<Ch>::const_iterator last = end;
+            return Str();
+        typename Str::const_iterator last = end;
         do --last; while (std::isspace(*last, loc));
         if (first != s.begin() || last + 1 != end)
-            return std::basic_string<Ch>(first, last + 1);
+            return Str(first, last + 1);
         else
             return s;
     }

include/boost/property_tree/detail/xml_parser_read_rapidxml.hpp

@@ -38,14 +38,13 @@ namespace boost { namespace property_tree { namespace xml_parser
                 if (node->first_attribute())
                 {
                     Ptree &pt_attr_root = pt_node.push_back(
-                        std::make_pair(xmlattr<Ch>(), Ptree()))->second;
+                        std::make_pair(xmlattr<typename Ptree::key_type>(), Ptree()))->second;
                     for (xml_attribute<Ch> *attr = node->first_attribute();
                          attr; attr = attr->next_attribute())
                     {
                         Ptree &pt_attr = pt_attr_root.push_back(
                             std::make_pair(attr->name(), Ptree()))->second;
-                        pt_attr.data() = std::basic_string<Ch>(attr->value(),
-                                                            attr->value_size());
+                        pt_attr.data() = typename Ptree::key_type(attr->value(), attr->value_size());
                     }
                 }
 
@@ -61,21 +60,19 @@ namespace boost { namespace property_tree { namespace xml_parser
             case node_cdata:
             {
                 if (flags & no_concat_text)
-                    pt.push_back(std::make_pair(xmltext<Ch>(),
+                    pt.push_back(std::make_pair(xmltext<typename Ptree::key_type>(),
                                                 Ptree(node->value())));
                 else
-                    pt.data() += std::basic_string<Ch>(node->value(),
-                                                       node->value_size());
+                    pt.data() += typename Ptree::key_type(node->value(), node->value_size());
             }
             break;
 
             // Comment nodes
             case node_comment:
             {
                 if (!(flags & no_comments))
-                    pt.push_back(std::make_pair(xmlcomment<Ch>(),
-                                    Ptree(std::basic_string<Ch>(node->value(),
-                                                         node->value_size()))));
+                    pt.push_back(std::make_pair(xmlcomment<typename Ptree::key_type>(),
+                                    Ptree(typename Ptree::key_type(node->value(), node->value_size()))));
             }
             break;
 

include/boost/property_tree/detail/xml_parser_utils.hpp

@@ -20,14 +20,15 @@
 namespace boost { namespace property_tree { namespace xml_parser
 {
 
-    template<class Ch>
-    std::basic_string<Ch> condense(const std::basic_string<Ch> &s)
+    template<class Str>
+    Str condense(const Str &s)
     {
-        std::basic_string<Ch> r;
+	typedef typename Str::value_type Ch;
+	Str r;
         std::locale loc;
         bool space = false;
-        typename std::basic_string<Ch>::const_iterator end = s.end();
-        for (typename std::basic_string<Ch>::const_iterator it = s.begin();
+        typename Str::const_iterator end = s.end();
+        for (typename Str::const_iterator it = s.begin();
              it != end; ++it)
         {
             if (isspace(*it, loc) || *it == Ch('\n'))
@@ -41,45 +42,47 @@ namespace boost { namespace property_tree { namespace xml_parser
         return r;
     }
 
-    template<class Ch>
-    std::basic_string<Ch> encode_char_entities(const std::basic_string<Ch> &s)
+
+    template<class Str>
+    Str encode_char_entities(const Str &s)
     {
         // Don't do anything for empty strings.
         if(s.empty()) return s;
 
-        typedef typename std::basic_string<Ch> Str;
+        typedef typename Str::value_type Ch;
+
         Str r;
         // To properly round-trip spaces and not uglify the XML beyond
         // recognition, we have to encode them IF the text contains only spaces.
         Str sp(1, Ch(' '));
         if(s.find_first_not_of(sp) == Str::npos) {
             // The first will suffice.
-            r = detail::widen<Ch>("&#32;");
+            r = detail::widen<Str>("&#32;");
             r += Str(s.size() - 1, Ch(' '));
         } else {
             typename Str::const_iterator end = s.end();
             for (typename Str::const_iterator it = s.begin(); it != end; ++it)
             {
                 switch (*it)
                 {
-                    case Ch('<'): r += detail::widen<Ch>("&lt;"); break;
-                    case Ch('>'): r += detail::widen<Ch>("&gt;"); break;
-                    case Ch('&'): r += detail::widen<Ch>("&amp;"); break;
-                    case Ch('"'): r += detail::widen<Ch>("&quot;"); break;
-                    case Ch('\''): r += detail::widen<Ch>("&apos;"); break;
-                    case Ch('\t'): r += detail::widen<Ch>("&#9;"); break;
-                    case Ch('\n'): r += detail::widen<Ch>("&#10;"); break;
+                    case Ch('<'): r += detail::widen<Str>("&lt;"); break;
+                    case Ch('>'): r += detail::widen<Str>("&gt;"); break;
+                    case Ch('&'): r += detail::widen<Str>("&amp;"); break;
+                    case Ch('"'): r += detail::widen<Str>("&quot;"); break;
+                    case Ch('\''): r += detail::widen<Str>("&apos;"); break;
+                    case Ch('\t'): r += detail::widen<Str>("&#9;"); break;
+                    case Ch('\n'): r += detail::widen<Str>("&#10;"); break;
                     default: r += *it; break;
                 }
             }
         }
         return r;
     }
 
-    template<class Ch>
-    std::basic_string<Ch> decode_char_entities(const std::basic_string<Ch> &s)
+    template<class Str>
+    Str decode_char_entities(const Str &s)
     {
-        typedef typename std::basic_string<Ch> Str;
+	typedef typename Str::value_type Ch;
         Str r;
         typename Str::const_iterator end = s.end();
         for (typename Str::const_iterator it = s.begin(); it != end; ++it)
@@ -90,11 +93,11 @@ namespace boost { namespace property_tree { namespace xml_parser
                 if (semicolon == end)
                     BOOST_PROPERTY_TREE_THROW(xml_parser_error("invalid character entity", "", 0));
                 Str ent(it + 1, semicolon);
-                if (ent == detail::widen<Ch>("lt")) r += Ch('<');
-                else if (ent == detail::widen<Ch>("gt")) r += Ch('>');
-                else if (ent == detail::widen<Ch>("amp")) r += Ch('&');
-                else if (ent == detail::widen<Ch>("quot")) r += Ch('"');
-                else if (ent == detail::widen<Ch>("apos")) r += Ch('\'');
+                if (ent == detail::widen<Str>("lt")) r += Ch('<');
+                else if (ent == detail::widen<Str>("gt")) r += Ch('>');
+                else if (ent == detail::widen<Str>("amp")) r += Ch('&');
+                else if (ent == detail::widen<Str>("quot")) r += Ch('"');
+                else if (ent == detail::widen<Str>("apos")) r += Ch('\'');
                 else
                     BOOST_PROPERTY_TREE_THROW(xml_parser_error("invalid character entity", "", 0));
                 it = semicolon;
@@ -105,31 +108,31 @@ namespace boost { namespace property_tree { namespace xml_parser
         return r;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmldecl()
+    template<class Str>
+    const Str &xmldecl()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<?xml>");
+        static Str s = detail::widen<Str>("<?xml>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmlattr()
+    template<class Str>
+    const Str &xmlattr()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmlattr>");
+        static Str s = detail::widen<Str>("<xmlattr>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmlcomment()
+    template<class Str>
+    const Str &xmlcomment()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmlcomment>");
+        static Str s = detail::widen<Str>("<xmlcomment>");
         return s;
     }
 
-    template<class Ch>
-    const std::basic_string<Ch> &xmltext()
+    template<class Str>
+    const Str &xmltext()
     {
-        static std::basic_string<Ch> s = detail::widen<Ch>("<xmltext>");
+        static Str s = detail::widen<Str>("<xmltext>");
         return s;
     }