external/boost/boost.property_tree.Wshadow.warnings.patch.1

   1 --- boost/boost/property_tree/detail/json_parser_error.hpp      2007-05-13 00:02:53.000000000 +0200
   2 +++ boost/boost/property_tree/detail/json_parser_error.hpp      2013-05-17 15:36:44.605902442 +0200
   3 @@ -20,10 +20,10 @@
   4      class json_parser_error: public file_parser_error
   5      {
   6      public:
   7 -        json_parser_error(const std::string &message,
   8 -                          const std::string &filename,
   9 -                          unsigned long line):
  10 -            file_parser_error(message, filename, line)
  11 +        json_parser_error(const std::string &message_,
  12 +                          const std::string &filename_,
  13 +                          unsigned long line_):
  14 +            file_parser_error(message_, filename_, line_)
  15          {
  16          }
  17      };
  18 --- boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:57:23.740638395 +0200
  19 +++ boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:31:05.666857356 +0200
  20 @@ -45,7 +45,7 @@
  21          struct a_object_s
  22          {
  23              context &c;
  24 -            a_object_s(context &c): c(c) { }
  25 +            a_object_s(context &c_): c(c_) { }
  26              void operator()(Ch) const
  27              {
  28                  if (c.stack.empty())
  29 @@ -63,7 +63,7 @@
  30          struct a_object_e
  31          {
  32              context &c;
  33 -            a_object_e(context &c): c(c) { }
  34 +            a_object_e(context &c_): c(c_) { }
  35              void operator()(Ch) const
  36              {
  37                  BOOST_ASSERT(c.stack.size() >= 1);
  38 @@ -74,7 +74,7 @@
  39          struct a_name
  40          {
  41              context &c;
  42 -            a_name(context &c): c(c) { }
  43 +            a_name(context &c_): c(c_) { }
  44              void operator()(It, It) const
  45              {
  46                  c.name.swap(c.string);
  47 @@ -85,7 +85,7 @@
  48          struct a_string_val
  49          {
  50              context &c;
  51 -            a_string_val(context &c): c(c) { }
  52 +            a_string_val(context &c_): c(c_) { }
  53              void operator()(It, It) const
  54              {
  55                  BOOST_ASSERT(c.stack.size() >= 1);
  56 @@ -98,7 +98,7 @@
  57          struct a_literal_val
  58          {
  59              context &c;
  60 -            a_literal_val(context &c): c(c) { }
  61 +            a_literal_val(context &c_): c(c_) { }
  62              void operator()(It b, It e) const
  63              {
  64                  BOOST_ASSERT(c.stack.size() >= 1);
  65 @@ -111,8 +111,8 @@
  66          struct a_char
  67          {
  68              context &c;
  69 -            a_char(context &c): c(c) { }
  70 -            void operator()(It b, It e) const
  71 +            a_char(context &c_): c(c_) { }
  72 +            void operator()(It b, It /* e */) const
  73              {
  74                  c.string += *b;
  75              }
  76 @@ -121,7 +121,7 @@
  77          struct a_escape
  78          {
  79              context &c;
  80 -            a_escape(context &c): c(c) { }
  81 +            a_escape(context &c_): c(c_) { }
  82              void operator()(Ch ch) const
  83              {
  84                  switch (ch)
  85 @@ -142,7 +142,7 @@
  86          struct a_unicode
  87          {
  88              context &c;
  89 -            a_unicode(context &c): c(c) { }
  90 +            a_unicode(context &c_): c(c_) { }
  91              void operator()(unsigned long u) const
  92              {
  93                  u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
  94 --- boost/boost/property_tree/detail/ptree_implementation.hpp   2010-07-03 22:59:45.000000000 +0200
  95 +++ boost/boost/property_tree/detail/ptree_implementation.hpp   2013-05-17 15:55:56.449713452 +0200
  96 @@ -539,48 +539,48 @@
  97
  98      template<class K, class D, class C>
  99      basic_ptree<K, D, C> &
 100 -        basic_ptree<K, D, C>::get_child(const path_type &path)
 101 +        basic_ptree<K, D, C>::get_child(const path_type &path_)
 102      {
 103 -        path_type p(path);
 104 +        path_type p(path_);
 105          self_type *n = walk_path(p);
 106          if (!n) {
 107 -            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
 108 +            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
 109          }
 110          return *n;
 111      }
 112
 113      template<class K, class D, class C> inline
 114      const basic_ptree<K, D, C> &
 115 -        basic_ptree<K, D, C>::get_child(const path_type &path) const
 116 +        basic_ptree<K, D, C>::get_child(const path_type &path_) const
 117      {
 118 -        return const_cast<self_type*>(this)->get_child(path);
 119 +        return const_cast<self_type*>(this)->get_child(path_);
 120      }
 121
 122      template<class K, class D, class C> inline
 123      basic_ptree<K, D, C> &
 124 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 125 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 126                                          self_type &default_value)
 127      {
 128 -        path_type p(path);
 129 +        path_type p(path_);
 130          self_type *n = walk_path(p);
 131          return n ? *n : default_value;
 132      }
 133
 134      template<class K, class D, class C> inline
 135      const basic_ptree<K, D, C> &
 136 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 137 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 138                                          const self_type &default_value) const
 139      {
 140 -        return const_cast<self_type*>(this)->get_child(path,
 141 +        return const_cast<self_type*>(this)->get_child(path_,
 142              const_cast<self_type&>(default_value));
 143      }
 144
 145
 146      template<class K, class D, class C>
 147      optional<basic_ptree<K, D, C> &>
 148 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path)
 149 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
 150      {
 151 -        path_type p(path);
 152 +        path_type p(path_);
 153          self_type *n = walk_path(p);
 154          if (!n) {
 155              return optional<self_type&>();
 156 @@ -590,9 +590,9 @@
 157
 158      template<class K, class D, class C>
 159      optional<const basic_ptree<K, D, C> &>
 160 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
 161 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
 162      {
 163 -        path_type p(path);
 164 +        path_type p(path_);
 165          self_type *n = walk_path(p);
 166          if (!n) {
 167              return optional<const self_type&>();
 168 @@ -602,10 +602,10 @@
 169
 170      template<class K, class D, class C>
 171      basic_ptree<K, D, C> &
 172 -        basic_ptree<K, D, C>::put_child(const path_type &path,
 173 +        basic_ptree<K, D, C>::put_child(const path_type &path_,
 174                                          const self_type &value)
 175      {
 176 -        path_type p(path);
 177 +        path_type p(path_);
 178          self_type &parent = force_path(p);
 179          // Got the parent. Now get the correct child.
 180          key_type fragment = p.reduce();
 181 @@ -620,10 +620,10 @@
 182
 183      template<class K, class D, class C>
 184      basic_ptree<K, D, C> &
 185 -        basic_ptree<K, D, C>::add_child(const path_type &path,
 186 +        basic_ptree<K, D, C>::add_child(const path_type &path_,
 187                                          const self_type &value)
 188      {
 189 -        path_type p(path);
 190 +        path_type p(path_);
 191          self_type &parent = force_path(p);
 192          // Got the parent.
 193          key_type fragment = p.reduce();
 194 @@ -709,26 +709,26 @@
 195      template<class K, class D, class C>
 196      template<class Type, class Translator> inline
 197      typename boost::enable_if<detail::is_translator<Translator>, Type>::type
 198 -    basic_ptree<K, D, C>::get(const path_type &path,
 199 +    basic_ptree<K, D, C>::get(const path_type &path_,
 200                                Translator tr) const
 201      {
 202 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 203 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 204      }
 205
 206      template<class K, class D, class C>
 207      template<class Type> inline
 208 -    Type basic_ptree<K, D, C>::get(const path_type &path) const
 209 +    Type basic_ptree<K, D, C>::get(const path_type &path_) const
 210      {
 211 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
 212 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
 213      }
 214
 215      template<class K, class D, class C>
 216      template<class Type, class Translator> inline
 217 -    Type basic_ptree<K, D, C>::get(const path_type &path,
 218 +    Type basic_ptree<K, D, C>::get(const path_type &path_,
 219                                     const Type &default_value,
 220                                     Translator tr) const
 221      {
 222 -        return get_optional<Type>(path, tr).get_value_or(default_value);
 223 +        return get_optional<Type>(path_, tr).get_value_or(default_value);
 224      }
 225
 226      template<class K, class D, class C>
 227 @@ -738,18 +738,18 @@
 228          std::basic_string<Ch>
 229      >::type
 230      basic_ptree<K, D, C>::get(
 231 -        const path_type &path, const Ch *default_value, Translator tr) const
 232 +        const path_type &path_, const Ch *default_value, Translator tr) const
 233      {
 234 -        return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
 235 +        return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
 236      }
 237
 238      template<class K, class D, class C>
 239      template<class Type> inline
 240      typename boost::disable_if<detail::is_translator<Type>, Type>::type
 241 -    basic_ptree<K, D, C>::get(const path_type &path,
 242 +    basic_ptree<K, D, C>::get(const path_type &path_,
 243                                const Type &default_value) const
 244      {
 245 -        return get_optional<Type>(path).get_value_or(default_value);
 246 +        return get_optional<Type>(path_).get_value_or(default_value);
 247      }
 248
 249      template<class K, class D, class C>
 250 @@ -759,17 +759,17 @@
 251          std::basic_string<Ch>
 252      >::type
 253      basic_ptree<K, D, C>::get(
 254 -        const path_type &path, const Ch *default_value) const
 255 +        const path_type &path_, const Ch *default_value) const
 256      {
 257 -        return get< std::basic_string<Ch> >(path, default_value);
 258 +        return get< std::basic_string<Ch> >(path_, default_value);
 259      }
 260
 261      template<class K, class D, class C>
 262      template<class Type, class Translator>
 263 -    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
 264 +    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
 265                                                           Translator tr) const
 266      {
 267 -        if (optional<const self_type&> child = get_child_optional(path))
 268 +        if (optional<const self_type&> child = get_child_optional(path_))
 269              return child.get().
 270                  BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
 271          else
 272 @@ -778,9 +778,9 @@
 273      template<class K, class D, class C>
 274      template<class Type>
 275      optional<Type> basic_ptree<K, D, C>::get_optional(
 276 -                                                const path_type &path) const
 277 +                                                const path_type &path_) const
 278      {
 279 -        if (optional<const self_type&> child = get_child_optional(path))
 280 +        if (optional<const self_type&> child = get_child_optional(path_))
 281              return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
 282          else
 283              return optional<Type>();
 284 @@ -809,13 +809,13 @@
 285      template<class K, class D, class C>
 286      template<class Type, typename Translator>
 287      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 288 -        const path_type &path, const Type &value, Translator tr)
 289 +        const path_type &path_, const Type &value, Translator tr)
 290      {
 291 -        if(optional<self_type &> child = get_child_optional(path)) {
 292 +        if(optional<self_type &> child = get_child_optional(path_)) {
 293              child.get().put_value(value, tr);
 294              return *child;
 295          } else {
 296 -            self_type &child2 = put_child(path, self_type());
 297 +            self_type &child2 = put_child(path_, self_type());
 298              child2.put_value(value, tr);
 299              return child2;
 300          }
 301 @@ -824,18 +824,18 @@
 302      template<class K, class D, class C>
 303      template<class Type> inline
 304      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 305 -        const path_type &path, const Type &value)
 306 +        const path_type &path_, const Type &value)
 307      {
 308 -        return put(path, value,
 309 +        return put(path_, value,
 310                     typename translator_between<data_type, Type>::type());
 311      }
 312
 313      template<class K, class D, class C>
 314      template<class Type, typename Translator> inline
 315      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 316 -        const path_type &path, const Type &value, Translator tr)
 317 +        const path_type &path_, const Type &value, Translator tr)
 318      {
 319 -        self_type &child = add_child(path, self_type());
 320 +        self_type &child = add_child(path_, self_type());
 321          child.put_value(value, tr);
 322          return child;
 323      }
 324 @@ -843,9 +843,9 @@
 325      template<class K, class D, class C>
 326      template<class Type> inline
 327      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 328 -        const path_type &path, const Type &value)
 329 +        const path_type &path_, const Type &value)
 330      {
 331 -        return add(path, value,
 332 +        return add(path_, value,
 333                     typename translator_between<data_type, Type>::type());
 334      }
 335
 336 --- a/boost/property_tree/string_path.hpp
 337 +++ a/boost/property_tree/string_path.hpp
 338 @@ -88,14 +88,14 @@ namespace boost { namespace property_tree
 339          typedef typename String::value_type char_type;
 340
 341          /// Create an empty path.
 342 -        explicit string_path(char_type separator = char_type('.'));
 343 +        explicit string_path(char_type separator_ = char_type('.'));
 344          /// Create a path by parsing the given string.
 345          /// @param value A sequence, possibly with separators, that describes
 346          ///              the path, e.g. "one.two.three".
 347          /// @param separator The separator used in parsing. Defaults to '.'.
 348          /// @param tr The translator used by this path to convert the individual
 349          ///           parts to keys.
 350 -        string_path(const String &value, char_type separator = char_type('.'),
 351 +        string_path(const String &value, char_type separator_ = char_type('.'),
 352                      Translator tr = Translator());
 353          /// Create a path by parsing the given string.
 354          /// @param value A zero-terminated array of values. Only use if zero-
 355 @@ -106,7 +106,7 @@ namespace boost { namespace property_tree
 356          /// @param tr The translator used by this path to convert the individual
 357          ///           parts to keys.
 358          string_path(const char_type *value,
 359 -                    char_type separator = char_type('.'),
 360 +                    char_type separator_ = char_type('.'),
 361                      Translator tr = Translator());
 362
 363          // Default copying doesn't do the right thing with the iterator
 364 @@ -162,23 +162,23 @@ namespace boost { namespace property_tree
 365      };
 366
 367      template <typename String, typename Translator> inline
 368 -    string_path<String, Translator>::string_path(char_type separator)
 369 -        : m_separator(separator), m_start(m_value.begin())
 370 +    string_path<String, Translator>::string_path(char_type separator_)
 371 +        : m_separator(separator_), m_start(m_value.begin())
 372      {}
 373
 374      template <typename String, typename Translator> inline
 375      string_path<String, Translator>::string_path(const String &value,
 376 -                                                 char_type separator,
 377 +                                                 char_type separator_,
 378                                                   Translator tr)
 379 -        : m_value(value), m_separator(separator),
 380 +        : m_value(value), m_separator(separator_),
 381            m_tr(tr), m_start(m_value.begin())
 382      {}
 383
 384      template <typename String, typename Translator> inline
 385      string_path<String, Translator>::string_path(const char_type *value,
 386 -                                                 char_type separator,
 387 +                                                 char_type separator_,
 388                                                   Translator tr)
 389 -        : m_value(value), m_separator(separator),
 390 +        : m_value(value), m_separator(separator_),
 391            m_tr(tr), m_start(m_value.begin())
 392      {}
 393