393 lines
16 KiB
Groff
393 lines
16 KiB
Groff
--- boost/boost/property_tree/detail/json_parser_error.hpp 2007-05-13 00:02:53.000000000 +0200
|
|
+++ boost/boost/property_tree/detail/json_parser_error.hpp 2013-05-17 15:36:44.605902442 +0200
|
|
@@ -20,10 +20,10 @@
|
|
class json_parser_error: public file_parser_error
|
|
{
|
|
public:
|
|
- json_parser_error(const std::string &message,
|
|
- const std::string &filename,
|
|
- unsigned long line):
|
|
- file_parser_error(message, filename, line)
|
|
+ json_parser_error(const std::string &message_,
|
|
+ const std::string &filename_,
|
|
+ unsigned long line_):
|
|
+ file_parser_error(message_, filename_, line_)
|
|
{
|
|
}
|
|
};
|
|
--- boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:57:23.740638395 +0200
|
|
+++ boost/boost/property_tree/detail/json_parser_read.hpp 2013-05-17 15:31:05.666857356 +0200
|
|
@@ -45,7 +45,7 @@
|
|
struct a_object_s
|
|
{
|
|
context &c;
|
|
- a_object_s(context &c): c(c) { }
|
|
+ a_object_s(context &c_): c(c_) { }
|
|
void operator()(Ch) const
|
|
{
|
|
if (c.stack.empty())
|
|
@@ -63,7 +63,7 @@
|
|
struct a_object_e
|
|
{
|
|
context &c;
|
|
- a_object_e(context &c): c(c) { }
|
|
+ a_object_e(context &c_): c(c_) { }
|
|
void operator()(Ch) const
|
|
{
|
|
BOOST_ASSERT(c.stack.size() >= 1);
|
|
@@ -74,7 +74,7 @@
|
|
struct a_name
|
|
{
|
|
context &c;
|
|
- a_name(context &c): c(c) { }
|
|
+ a_name(context &c_): c(c_) { }
|
|
void operator()(It, It) const
|
|
{
|
|
c.name.swap(c.string);
|
|
@@ -85,7 +85,7 @@
|
|
struct a_string_val
|
|
{
|
|
context &c;
|
|
- a_string_val(context &c): c(c) { }
|
|
+ a_string_val(context &c_): c(c_) { }
|
|
void operator()(It, It) const
|
|
{
|
|
BOOST_ASSERT(c.stack.size() >= 1);
|
|
@@ -98,7 +98,7 @@
|
|
struct a_literal_val
|
|
{
|
|
context &c;
|
|
- a_literal_val(context &c): c(c) { }
|
|
+ a_literal_val(context &c_): c(c_) { }
|
|
void operator()(It b, It e) const
|
|
{
|
|
BOOST_ASSERT(c.stack.size() >= 1);
|
|
@@ -111,8 +111,8 @@
|
|
struct a_char
|
|
{
|
|
context &c;
|
|
- a_char(context &c): c(c) { }
|
|
- void operator()(It b, It e) const
|
|
+ a_char(context &c_): c(c_) { }
|
|
+ void operator()(It b, It /* e */) const
|
|
{
|
|
c.string += *b;
|
|
}
|
|
@@ -121,7 +121,7 @@
|
|
struct a_escape
|
|
{
|
|
context &c;
|
|
- a_escape(context &c): c(c) { }
|
|
+ a_escape(context &c_): c(c_) { }
|
|
void operator()(Ch ch) const
|
|
{
|
|
switch (ch)
|
|
@@ -142,7 +142,7 @@
|
|
struct a_unicode
|
|
{
|
|
context &c;
|
|
- a_unicode(context &c): c(c) { }
|
|
+ a_unicode(context &c_): c(c_) { }
|
|
void operator()(unsigned long u) const
|
|
{
|
|
u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
|
|
--- boost/boost/property_tree/detail/ptree_implementation.hpp 2010-07-03 22:59:45.000000000 +0200
|
|
+++ boost/boost/property_tree/detail/ptree_implementation.hpp 2013-05-17 15:55:56.449713452 +0200
|
|
@@ -539,48 +539,48 @@
|
|
|
|
template<class K, class D, class C>
|
|
basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::get_child(const path_type &path)
|
|
+ basic_ptree<K, D, C>::get_child(const path_type &path_)
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type *n = walk_path(p);
|
|
if (!n) {
|
|
- BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
|
|
+ BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
|
|
}
|
|
return *n;
|
|
}
|
|
|
|
template<class K, class D, class C> inline
|
|
const basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::get_child(const path_type &path) const
|
|
+ basic_ptree<K, D, C>::get_child(const path_type &path_) const
|
|
{
|
|
- return const_cast<self_type*>(this)->get_child(path);
|
|
+ return const_cast<self_type*>(this)->get_child(path_);
|
|
}
|
|
|
|
template<class K, class D, class C> inline
|
|
basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::get_child(const path_type &path,
|
|
+ basic_ptree<K, D, C>::get_child(const path_type &path_,
|
|
self_type &default_value)
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type *n = walk_path(p);
|
|
return n ? *n : default_value;
|
|
}
|
|
|
|
template<class K, class D, class C> inline
|
|
const basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::get_child(const path_type &path,
|
|
+ basic_ptree<K, D, C>::get_child(const path_type &path_,
|
|
const self_type &default_value) const
|
|
{
|
|
- return const_cast<self_type*>(this)->get_child(path,
|
|
+ return const_cast<self_type*>(this)->get_child(path_,
|
|
const_cast<self_type&>(default_value));
|
|
}
|
|
|
|
|
|
template<class K, class D, class C>
|
|
optional<basic_ptree<K, D, C> &>
|
|
- basic_ptree<K, D, C>::get_child_optional(const path_type &path)
|
|
+ basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type *n = walk_path(p);
|
|
if (!n) {
|
|
return optional<self_type&>();
|
|
@@ -590,9 +590,9 @@
|
|
|
|
template<class K, class D, class C>
|
|
optional<const basic_ptree<K, D, C> &>
|
|
- basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
|
|
+ basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type *n = walk_path(p);
|
|
if (!n) {
|
|
return optional<const self_type&>();
|
|
@@ -602,10 +602,10 @@
|
|
|
|
template<class K, class D, class C>
|
|
basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::put_child(const path_type &path,
|
|
+ basic_ptree<K, D, C>::put_child(const path_type &path_,
|
|
const self_type &value)
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type &parent = force_path(p);
|
|
// Got the parent. Now get the correct child.
|
|
key_type fragment = p.reduce();
|
|
@@ -620,10 +620,10 @@
|
|
|
|
template<class K, class D, class C>
|
|
basic_ptree<K, D, C> &
|
|
- basic_ptree<K, D, C>::add_child(const path_type &path,
|
|
+ basic_ptree<K, D, C>::add_child(const path_type &path_,
|
|
const self_type &value)
|
|
{
|
|
- path_type p(path);
|
|
+ path_type p(path_);
|
|
self_type &parent = force_path(p);
|
|
// Got the parent.
|
|
key_type fragment = p.reduce();
|
|
@@ -709,26 +709,26 @@
|
|
template<class K, class D, class C>
|
|
template<class Type, class Translator> inline
|
|
typename boost::enable_if<detail::is_translator<Translator>, Type>::type
|
|
- basic_ptree<K, D, C>::get(const path_type &path,
|
|
+ basic_ptree<K, D, C>::get(const path_type &path_,
|
|
Translator tr) const
|
|
{
|
|
- return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
|
|
+ return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
template<class Type> inline
|
|
- Type basic_ptree<K, D, C>::get(const path_type &path) const
|
|
+ Type basic_ptree<K, D, C>::get(const path_type &path_) const
|
|
{
|
|
- return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
|
|
+ return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
template<class Type, class Translator> inline
|
|
- Type basic_ptree<K, D, C>::get(const path_type &path,
|
|
+ Type basic_ptree<K, D, C>::get(const path_type &path_,
|
|
const Type &default_value,
|
|
Translator tr) const
|
|
{
|
|
- return get_optional<Type>(path, tr).get_value_or(default_value);
|
|
+ return get_optional<Type>(path_, tr).get_value_or(default_value);
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
@@ -738,18 +738,18 @@
|
|
std::basic_string<Ch>
|
|
>::type
|
|
basic_ptree<K, D, C>::get(
|
|
- const path_type &path, const Ch *default_value, Translator tr) const
|
|
+ const path_type &path_, const Ch *default_value, Translator tr) const
|
|
{
|
|
- return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
|
|
+ return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
template<class Type> inline
|
|
typename boost::disable_if<detail::is_translator<Type>, Type>::type
|
|
- basic_ptree<K, D, C>::get(const path_type &path,
|
|
+ basic_ptree<K, D, C>::get(const path_type &path_,
|
|
const Type &default_value) const
|
|
{
|
|
- return get_optional<Type>(path).get_value_or(default_value);
|
|
+ return get_optional<Type>(path_).get_value_or(default_value);
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
@@ -759,17 +759,17 @@
|
|
std::basic_string<Ch>
|
|
>::type
|
|
basic_ptree<K, D, C>::get(
|
|
- const path_type &path, const Ch *default_value) const
|
|
+ const path_type &path_, const Ch *default_value) const
|
|
{
|
|
- return get< std::basic_string<Ch> >(path, default_value);
|
|
+ return get< std::basic_string<Ch> >(path_, default_value);
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
template<class Type, class Translator>
|
|
- optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
|
|
+ optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
|
|
Translator tr) const
|
|
{
|
|
- if (optional<const self_type&> child = get_child_optional(path))
|
|
+ if (optional<const self_type&> child = get_child_optional(path_))
|
|
return child.get().
|
|
BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
|
|
else
|
|
@@ -778,9 +778,9 @@
|
|
template<class K, class D, class C>
|
|
template<class Type>
|
|
optional<Type> basic_ptree<K, D, C>::get_optional(
|
|
- const path_type &path) const
|
|
+ const path_type &path_) const
|
|
{
|
|
- if (optional<const self_type&> child = get_child_optional(path))
|
|
+ if (optional<const self_type&> child = get_child_optional(path_))
|
|
return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
|
|
else
|
|
return optional<Type>();
|
|
@@ -809,13 +809,13 @@
|
|
template<class K, class D, class C>
|
|
template<class Type, typename Translator>
|
|
basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
|
|
- const path_type &path, const Type &value, Translator tr)
|
|
+ const path_type &path_, const Type &value, Translator tr)
|
|
{
|
|
- if(optional<self_type &> child = get_child_optional(path)) {
|
|
+ if(optional<self_type &> child = get_child_optional(path_)) {
|
|
child.get().put_value(value, tr);
|
|
return *child;
|
|
} else {
|
|
- self_type &child2 = put_child(path, self_type());
|
|
+ self_type &child2 = put_child(path_, self_type());
|
|
child2.put_value(value, tr);
|
|
return child2;
|
|
}
|
|
@@ -824,18 +824,18 @@
|
|
template<class K, class D, class C>
|
|
template<class Type> inline
|
|
basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
|
|
- const path_type &path, const Type &value)
|
|
+ const path_type &path_, const Type &value)
|
|
{
|
|
- return put(path, value,
|
|
+ return put(path_, value,
|
|
typename translator_between<data_type, Type>::type());
|
|
}
|
|
|
|
template<class K, class D, class C>
|
|
template<class Type, typename Translator> inline
|
|
basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
|
|
- const path_type &path, const Type &value, Translator tr)
|
|
+ const path_type &path_, const Type &value, Translator tr)
|
|
{
|
|
- self_type &child = add_child(path, self_type());
|
|
+ self_type &child = add_child(path_, self_type());
|
|
child.put_value(value, tr);
|
|
return child;
|
|
}
|
|
@@ -843,9 +843,9 @@
|
|
template<class K, class D, class C>
|
|
template<class Type> inline
|
|
basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
|
|
- const path_type &path, const Type &value)
|
|
+ const path_type &path_, const Type &value)
|
|
{
|
|
- return add(path, value,
|
|
+ return add(path_, value,
|
|
typename translator_between<data_type, Type>::type());
|
|
}
|
|
|
|
--- a/boost/property_tree/string_path.hpp
|
|
+++ a/boost/property_tree/string_path.hpp
|
|
@@ -88,14 +88,14 @@ namespace boost { namespace property_tree
|
|
typedef typename String::value_type char_type;
|
|
|
|
/// Create an empty path.
|
|
- explicit string_path(char_type separator = char_type('.'));
|
|
+ explicit string_path(char_type separator_ = char_type('.'));
|
|
/// Create a path by parsing the given string.
|
|
/// @param value A sequence, possibly with separators, that describes
|
|
/// the path, e.g. "one.two.three".
|
|
/// @param separator The separator used in parsing. Defaults to '.'.
|
|
/// @param tr The translator used by this path to convert the individual
|
|
/// parts to keys.
|
|
- string_path(const String &value, char_type separator = char_type('.'),
|
|
+ string_path(const String &value, char_type separator_ = char_type('.'),
|
|
Translator tr = Translator());
|
|
/// Create a path by parsing the given string.
|
|
/// @param value A zero-terminated array of values. Only use if zero-
|
|
@@ -106,7 +106,7 @@ namespace boost { namespace property_tree
|
|
/// @param tr The translator used by this path to convert the individual
|
|
/// parts to keys.
|
|
string_path(const char_type *value,
|
|
- char_type separator = char_type('.'),
|
|
+ char_type separator_ = char_type('.'),
|
|
Translator tr = Translator());
|
|
|
|
// Default copying doesn't do the right thing with the iterator
|
|
@@ -162,23 +162,23 @@ namespace boost { namespace property_tree
|
|
};
|
|
|
|
template <typename String, typename Translator> inline
|
|
- string_path<String, Translator>::string_path(char_type separator)
|
|
- : m_separator(separator), m_start(m_value.begin())
|
|
+ string_path<String, Translator>::string_path(char_type separator_)
|
|
+ : m_separator(separator_), m_start(m_value.begin())
|
|
{}
|
|
|
|
template <typename String, typename Translator> inline
|
|
string_path<String, Translator>::string_path(const String &value,
|
|
- char_type separator,
|
|
+ char_type separator_,
|
|
Translator tr)
|
|
- : m_value(value), m_separator(separator),
|
|
+ : m_value(value), m_separator(separator_),
|
|
m_tr(tr), m_start(m_value.begin())
|
|
{}
|
|
|
|
template <typename String, typename Translator> inline
|
|
string_path<String, Translator>::string_path(const char_type *value,
|
|
- char_type separator,
|
|
+ char_type separator_,
|
|
Translator tr)
|
|
- : m_value(value), m_separator(separator),
|
|
+ : m_value(value), m_separator(separator_),
|
|
m_tr(tr), m_start(m_value.begin())
|
|
{}
|
|
|