Import libucl 0.9.3vendor/libucl/0.9.3vendor/libucl

1 files changed, 305 insertions, 263 deletions

diff --git a/include/ucl++.h b/include/ucl++.h
index fb63430d400d..215e61b3807e 100644
--- a/include/ucl++.h
+++ b/include/ucl++.h
@@ -37,57 +37,57 @@
 
 namespace ucl {
 
-struct ucl_map_construct_t { };
+struct ucl_map_construct_t {};
 constexpr ucl_map_construct_t ucl_map_construct = ucl_map_construct_t();
-struct ucl_array_construct_t { };
+struct ucl_array_construct_t {};
 constexpr ucl_array_construct_t ucl_array_construct = ucl_array_construct_t();
 
 class Ucl final {
 private:
-
 	struct ucl_deleter {
-		void operator() (ucl_object_t *obj) {
-			ucl_object_unref (obj);
+		void operator()(ucl_object_t *obj)
+		{
+			ucl_object_unref(obj);
 		}
 	};
 
 	static int
-	append_char (unsigned char c, size_t nchars, void *ud)
+	append_char(unsigned char c, size_t nchars, void *ud)
 	{
 		std::string *out = reinterpret_cast<std::string *>(ud);
 
-		out->append (nchars, (char)c);
+		out->append(nchars, (char) c);
 
 		return nchars;
 	}
 	static int
-	append_len (unsigned const char *str, size_t len, void *ud)
+	append_len(unsigned const char *str, size_t len, void *ud)
 	{
 		std::string *out = reinterpret_cast<std::string *>(ud);
 
-		out->append ((const char *)str, len);
+		out->append((const char *) str, len);
 
 		return len;
 	}
 	static int
-	append_int (int64_t elt, void *ud)
+	append_int(int64_t elt, void *ud)
 	{
 		std::string *out = reinterpret_cast<std::string *>(ud);
-		auto nstr = std::to_string (elt);
+		auto nstr = std::to_string(elt);
 
-		out->append (nstr);
+		out->append(nstr);
 
-		return nstr.size ();
+		return nstr.size();
 	}
 	static int
-	append_double (double elt, void *ud)
+	append_double(double elt, void *ud)
 	{
 		std::string *out = reinterpret_cast<std::string *>(ud);
-		auto nstr = std::to_string (elt);
+		auto nstr = std::to_string(elt);
 
-		out->append (nstr);
+		out->append(nstr);
 
-		return nstr.size ();
+		return nstr.size();
 	}
 
 	static struct ucl_emitter_functions default_emit_funcs()
@@ -98,26 +98,25 @@ private:
 			Ucl::append_int,
 			Ucl::append_double,
 			nullptr,
-			nullptr
-		};
+			nullptr};
 
 		return func;
 	};
 
 	static bool ucl_variable_getter(const unsigned char *data, size_t len,
-			unsigned char ** /*replace*/, size_t * /*replace_len*/, bool *need_free, void* ud)
+									unsigned char ** /*replace*/, size_t * /*replace_len*/, bool *need_free, void *ud)
 	{
 		*need_free = false;
 
 		auto vars = reinterpret_cast<std::set<std::string> *>(ud);
 		if (vars && data && len != 0) {
-			vars->emplace (data, data + len);
+			vars->emplace(data, data + len);
 		}
 		return false;
 	}
 
-	static bool ucl_variable_replacer (const unsigned char *data, size_t len,
-			unsigned char **replace, size_t *replace_len, bool *need_free, void* ud)
+	static bool ucl_variable_replacer(const unsigned char *data, size_t len,
+									  unsigned char **replace, size_t *replace_len, bool *need_free, void *ud)
 	{
 		*need_free = false;
 
@@ -126,89 +125,96 @@ private:
 			return false;
 		}
 
-		std::string var_name (data, data + len);
-		if (!replacer->is_variable (var_name)) {
+		std::string var_name(data, data + len);
+		if (!replacer->is_variable(var_name)) {
 			return false;
 		}
 
-		std::string var_value = replacer->replace (var_name);
-		if (var_value.empty ()) {
+		std::string var_value = replacer->replace(var_name);
+		if (var_value.empty()) {
 			return false;
- 		}
+		}
 
-		*replace = (unsigned char *)UCL_ALLOC (var_value.size ());
-		memcpy (*replace, var_value.data (), var_value.size ());
+		*replace = (unsigned char *) UCL_ALLOC(var_value.size());
+		memcpy(*replace, var_value.data(), var_value.size());
 
-		*replace_len = var_value.size ();
+		*replace_len = var_value.size();
 		*need_free = true;
 
 		return true;
 	}
 
-	template <typename C, typename P>
-	static Ucl parse_with_strategy_function (C config_func, P parse_func, std::string &err)
+	template<typename C, typename P>
+	static Ucl parse_with_strategy_function(C config_func, P parse_func, std::string &err)
 	{
-		auto parser = ucl_parser_new (UCL_PARSER_DEFAULT);
+		auto parser = ucl_parser_new(UCL_PARSER_DEFAULT);
 
-		config_func (parser);
+		config_func(parser);
 
-		if (!parse_func (parser)) {
-			const char *error = ucl_parser_get_error (parser); //Assigning here without checking result first causes a
-			if( error != NULL ) err.assign(error);             //	crash if ucl_parser_get_error returns NULL
-			ucl_parser_free (parser);
+		if (!parse_func(parser)) {
+			const char *error = ucl_parser_get_error(parser);//Assigning here without checking result first causes a
+			if (error != NULL) err.assign(error);            //	crash if ucl_parser_get_error returns NULL
+			ucl_parser_free(parser);
 
 			return nullptr;
 		}
 
-		auto obj = ucl_parser_get_object (parser);
-		ucl_parser_free (parser);
+		auto obj = ucl_parser_get_object(parser);
+		ucl_parser_free(parser);
 
 		// Obj will handle ownership
-		return Ucl (obj);
+		return Ucl(obj);
 	}
 
 	std::unique_ptr<ucl_object_t, ucl_deleter> obj;
 
 public:
 	struct macro_handler_s {
-		ucl_macro_handler         handler;
+		ucl_macro_handler handler;
 		ucl_context_macro_handler ctx_handler;
 	};
 
 	struct macro_userdata_s {
-		ucl_parser    *parser;
-		void          *userdata;
+		ucl_parser *parser;
+		void *userdata;
 	};
 
 	class const_iterator {
 	private:
 		struct ucl_iter_deleter {
-			void operator() (ucl_object_iter_t it) {
-				ucl_object_iterate_free (it);
+			void operator()(ucl_object_iter_t it)
+			{
+				ucl_object_iterate_free(it);
 			}
 		};
 		std::shared_ptr<void> it;
 		std::unique_ptr<Ucl> cur;
+
 	public:
 		typedef std::forward_iterator_tag iterator_category;
 
-		const_iterator(const Ucl &obj) {
-			it = std::shared_ptr<void>(ucl_object_iterate_new (obj.obj.get()),
-				ucl_iter_deleter());
-			cur.reset (new Ucl(ucl_object_iterate_safe (it.get(), true)));
+		const_iterator(const Ucl &obj)
+		{
+			it = std::shared_ptr<void>(ucl_object_iterate_new(obj.obj.get()),
+									   ucl_iter_deleter());
+			cur.reset(new Ucl(ucl_object_iterate_safe(it.get(), true)));
 			if (!cur->obj) {
-				it.reset ();
-				cur.reset ();
+				it.reset();
+				cur.reset();
 			}
 		}
 
-		const_iterator() {}
+		const_iterator()
+		{
+		}
 		const_iterator(const const_iterator &other) = delete;
 		const_iterator(const_iterator &&other) = default;
-		~const_iterator() {}
+		~const_iterator()
+		{
+		}
 
-		const_iterator& operator=(const const_iterator &other) = delete;
-		const_iterator& operator=(const_iterator &&other) = default;
+		const_iterator &operator=(const const_iterator &other) = delete;
+		const_iterator &operator=(const_iterator &&other) = default;
 
 		bool operator==(const const_iterator &other) const
 		{
@@ -224,135 +230,154 @@ public:
 			return !(*this == other);
 		}
 
-		const_iterator& operator++()
+		const_iterator &operator++()
 		{
 			if (it) {
-				cur.reset (new Ucl(ucl_object_iterate_safe (it.get(), true)));
+				cur.reset(new Ucl(ucl_object_iterate_safe(it.get(), true)));
 			}
 
 			if (cur && !cur->obj) {
-				it.reset ();
-				cur.reset ();
+				it.reset();
+				cur.reset();
 			}
 
 			return *this;
 		}
 
-		const Ucl& operator*() const
+		const Ucl &operator*() const
 		{
 			return *cur;
 		}
-		const Ucl* operator->() const
+		const Ucl *operator->() const
 		{
 			return cur.get();
 		}
 	};
 
 	struct variable_replacer {
-		virtual ~variable_replacer() {}
+		virtual ~variable_replacer()
+		{
+		}
 
-		virtual bool is_variable (const std::string &str) const
+		virtual bool is_variable(const std::string &str) const
 		{
-			return !str.empty ();
+			return !str.empty();
 		}
 
-		virtual std::string replace (const std::string &var) const = 0;
+		virtual std::string replace(const std::string &var) const = 0;
 	};
 
 	// We grab ownership if get non-const ucl_object_t
-	Ucl(ucl_object_t *other) {
-		obj.reset (other);
+	Ucl(ucl_object_t *other)
+	{
+		obj.reset(other);
 	}
 
 	// Shared ownership
-	Ucl(const ucl_object_t *other) {
-		obj.reset (ucl_object_ref (other));
+	Ucl(const ucl_object_t *other)
+	{
+		obj.reset(ucl_object_ref(other));
 	}
 
-	Ucl(const Ucl &other) {
-		obj.reset (ucl_object_ref (other.obj.get()));
+	Ucl(const Ucl &other)
+	{
+		obj.reset(ucl_object_ref(other.obj.get()));
 	}
 
-	Ucl(Ucl &&other) {
-		obj.swap (other.obj);
+	Ucl(Ucl &&other)
+	{
+		obj.swap(other.obj);
 	}
 
-	Ucl() noexcept {
-		obj.reset (ucl_object_typed_new (UCL_NULL));
+	Ucl() noexcept
+	{
+		obj.reset(ucl_object_typed_new(UCL_NULL));
 	}
-	Ucl(std::nullptr_t) noexcept {
-		obj.reset (ucl_object_typed_new (UCL_NULL));
+	Ucl(std::nullptr_t) noexcept
+	{
+		obj.reset(ucl_object_typed_new(UCL_NULL));
 	}
-	Ucl(double value) {
-		obj.reset (ucl_object_typed_new (UCL_FLOAT));
+	Ucl(double value)
+	{
+		obj.reset(ucl_object_typed_new(UCL_FLOAT));
 		obj->value.dv = value;
 	}
-	Ucl(int64_t value) {
-		obj.reset (ucl_object_typed_new (UCL_INT));
+	Ucl(int64_t value)
+	{
+		obj.reset(ucl_object_typed_new(UCL_INT));
 		obj->value.iv = value;
 	}
-	Ucl(bool value) {
-		obj.reset (ucl_object_typed_new (UCL_BOOLEAN));
+	Ucl(bool value)
+	{
+		obj.reset(ucl_object_typed_new(UCL_BOOLEAN));
 		obj->value.iv = static_cast<int64_t>(value);
 	}
-	Ucl(const std::string &value) {
-		obj.reset (ucl_object_fromstring_common (value.data (), value.size (),
-				UCL_STRING_RAW));
+	Ucl(const std::string &value)
+	{
+		obj.reset(ucl_object_fromstring_common(value.data(), value.size(),
+											   UCL_STRING_RAW));
 	}
-	Ucl(const char *value) {
-		obj.reset (ucl_object_fromstring_common (value, 0, UCL_STRING_RAW));
+	Ucl(const char *value)
+	{
+		obj.reset(ucl_object_fromstring_common(value, 0, UCL_STRING_RAW));
 	}
 
 	// Implicit constructor: anything with a to_json() function.
-	template <class T, class = decltype(&T::to_ucl)>
-	Ucl(const T &t) : Ucl(t.to_ucl()) {}
+	template<class T, class = decltype(&T::to_ucl)>
+	Ucl(const T &t)
+		: Ucl(t.to_ucl())
+	{
+	}
 
 	// Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
-	template <class M, typename std::enable_if<
-		std::is_constructible<std::string, typename M::key_type>::value
-		&& std::is_constructible<Ucl, typename M::mapped_type>::value,
-		int>::type = 0>
-	Ucl(const M &m) {
-		obj.reset (ucl_object_typed_new (UCL_OBJECT));
-		auto cobj = obj.get ();
+	template<class M, typename std::enable_if<
+						  std::is_constructible<std::string, typename M::key_type>::value && std::is_constructible<Ucl, typename M::mapped_type>::value,
+						  int>::type = 0>
+	Ucl(const M &m)
+	{
+		obj.reset(ucl_object_typed_new(UCL_OBJECT));
+		auto cobj = obj.get();
 
-		for (const auto &e : m) {
-			ucl_object_insert_key (cobj, ucl_object_ref (e.second.obj.get()),
-					e.first.data (), e.first.size (), true);
+		for (const auto &e: m) {
+			ucl_object_insert_key(cobj, ucl_object_ref(e.second.obj.get()),
+								  e.first.data(), e.first.size(), true);
 		}
 	}
 
 	// Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
-	template <class V, typename std::enable_if<
-		std::is_constructible<Ucl, typename V::value_type>::value,
-		int>::type = 0>
-	Ucl(const V &v) {
-		obj.reset (ucl_object_typed_new (UCL_ARRAY));
-		auto cobj = obj.get ();
+	template<class V, typename std::enable_if<
+						  std::is_constructible<Ucl, typename V::value_type>::value,
+						  int>::type = 0>
+	Ucl(const V &v)
+	{
+		obj.reset(ucl_object_typed_new(UCL_ARRAY));
+		auto cobj = obj.get();
 
-		for (const auto &e : v) {
-			ucl_array_append (cobj, ucl_object_ref (e.obj.get()));
+		for (const auto &e: v) {
+			ucl_array_append(cobj, ucl_object_ref(e.obj.get()));
 		}
 	}
 
-	ucl_type_t type () const {
+	ucl_type_t type() const
+	{
 		if (obj) {
-			return ucl_object_type (obj.get ());
+			return ucl_object_type(obj.get());
 		}
 		return UCL_NULL;
 	}
 
-	std::string key () const {
+	std::string key() const
+	{
 		std::string res;
 
 		if (obj->key) {
-			res.assign (obj->key, obj->keylen);
+			res.assign(obj->key, obj->keylen);
 		}
 
 		return res;
 	}
 
-	double number_value (const double default_val = 0.0) const
+	double number_value(const double default_val = 0.0) const
 	{
 		double res;
 
@@ -363,7 +388,7 @@ public:
 		return default_val;
 	}
 
-	int64_t int_value (const int64_t default_val = 0) const
+	int64_t int_value(const int64_t default_val = 0) const
 	{
 		int64_t res;
 
@@ -374,7 +399,7 @@ public:
 		return default_val;
 	}
 
-	bool bool_value (const bool default_val = false) const
+	bool bool_value(const bool default_val = false) const
 	{
 		bool res;
 
@@ -385,9 +410,9 @@ public:
 		return default_val;
 	}
 
-	std::string string_value (const std::string& default_val = "") const
+	std::string string_value(const std::string &default_val = "") const
 	{
-		const char* res = nullptr;
+		const char *res = nullptr;
 
 		if (ucl_object_tostring_safe(obj.get(), &res)) {
 			return res;
@@ -396,35 +421,40 @@ public:
 		return default_val;
 	}
 
-	size_t size () const
+	std::string forced_string_value() const
+	{
+		return ucl_object_tostring_forced(obj.get());
+	}
+
+	size_t size() const
 	{
-		if (type () == UCL_ARRAY) {
-			return ucl_array_size (obj.get());
+		if (type() == UCL_ARRAY) {
+			return ucl_array_size(obj.get());
 		}
 
 		return 0;
 	}
 
-	Ucl at (size_t i) const
+	Ucl at(size_t i) const
 	{
-		if (type () == UCL_ARRAY) {
-			return Ucl (ucl_array_find_index (obj.get(), i));
+		if (type() == UCL_ARRAY) {
+			return Ucl(ucl_array_find_index(obj.get(), i));
 		}
 
-		return Ucl (nullptr);
+		return Ucl(nullptr);
 	}
 
-	Ucl lookup (const std::string &key) const
+	Ucl lookup(const std::string &key) const
 	{
-		if (type () == UCL_OBJECT) {
-			return Ucl (ucl_object_lookup_len (obj.get(),
-					key.data (), key.size ()));
+		if (type() == UCL_OBJECT) {
+			return Ucl(ucl_object_lookup_len(obj.get(),
+											 key.data(), key.size()));
 		}
 
-		return Ucl (nullptr);
+		return Ucl(nullptr);
 	}
 
-	inline Ucl operator[] (size_t i) const
+	inline Ucl operator[](size_t i) const
 	{
 		return at(i);
 	}
@@ -434,285 +464,297 @@ public:
 		return lookup(key);
 	}
 	// Serialize.
-	void dump (std::string &out, ucl_emitter_t type = UCL_EMIT_JSON) const
+	void dump(std::string &out, ucl_emitter_t type = UCL_EMIT_JSON) const
 	{
 		struct ucl_emitter_functions cbdata;
 
 		cbdata = Ucl::default_emit_funcs();
 		cbdata.ud = reinterpret_cast<void *>(&out);
 
-		ucl_object_emit_full (obj.get(), type, &cbdata, nullptr);
+		ucl_object_emit_full(obj.get(), type, &cbdata, nullptr);
 	}
 
-	std::string dump (ucl_emitter_t type = UCL_EMIT_JSON) const
+	std::string dump(ucl_emitter_t type = UCL_EMIT_JSON) const
 	{
 		std::string out;
 
-		dump (out, type);
+		dump(out, type);
 
 		return out;
 	}
 
-	static Ucl parse (const std::string &in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), err, duplicate_strategy);
 	}
 
-	static Ucl parse (const std::string &in, const std::map<std::string, std::string> &vars,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const std::map<std::string, std::string> &vars,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		std::vector< std::tuple< std::string, macro_handler_s, void * > > emptyVector;
-		return parse ( in, vars, emptyVector, err, duplicate_strategy );
+		std::vector<std::tuple<std::string, macro_handler_s, void *>> emptyVector;
+		return parse(in, vars, emptyVector, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const std::string &in,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const std::string &in, const std::map<std::string, std::string> &vars,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const std::map<std::string, std::string> &vars,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
 		//Preserve macro_userdata_s memory for later use in parse_with_strategy_function()
 		std::vector<macro_userdata_s> userdata_list;
-		userdata_list.reserve (macros.size());
-		auto config_func = [&userdata_list, &vars, &macros] (ucl_parser *parser) {
-			for (const auto & item : vars) {
-				ucl_parser_register_variable (parser, item.first.c_str (), item.second.c_str ());
+		userdata_list.reserve(macros.size());
+		auto config_func = [&userdata_list, &vars, &macros](ucl_parser *parser) {
+			for (const auto &item: vars) {
+				ucl_parser_register_variable(parser, item.first.c_str(), item.second.c_str());
 			}
-			for (auto & macro : macros) {
-				userdata_list.push_back ({parser, std::get<2>(macro)});
+			for (auto &macro: macros) {
+				userdata_list.push_back({parser, std::get<2>(macro)});
 				if (std::get<1>(macro).handler != NULL) {
-					ucl_parser_register_macro (parser,
-								std::get<0>(macro).c_str(),
-								std::get<1>(macro).handler,
-								reinterpret_cast<void*>(&userdata_list.back()));
+					ucl_parser_register_macro(parser,
+											  std::get<0>(macro).c_str(),
+											  std::get<1>(macro).handler,
+											  reinterpret_cast<void *>(&userdata_list.back()));
 				}
 				else if (std::get<1>(macro).ctx_handler != NULL) {
-					ucl_parser_register_context_macro (parser,
-									std::get<0>(macro).c_str(),
-									std::get<1>(macro).ctx_handler,
-									reinterpret_cast<void*>(&userdata_list.back()));
+					ucl_parser_register_context_macro(parser,
+													  std::get<0>(macro).c_str(),
+													  std::get<1>(macro).ctx_handler,
+													  reinterpret_cast<void *>(&userdata_list.back()));
 				}
 			}
 		};
 
-		auto parse_func = [&in, &duplicate_strategy] (struct ucl_parser *parser) -> bool {
-			return ucl_parser_add_chunk_full (parser,
-							(unsigned char *) in.data (),
-							in.size (),
-							(unsigned int)ucl_parser_get_default_priority (parser),
-							duplicate_strategy,
-							UCL_PARSE_UCL);
+		auto parse_func = [&in, &duplicate_strategy](struct ucl_parser *parser) -> bool {
+			return ucl_parser_add_chunk_full(parser,
+											 (unsigned char *) in.data(),
+											 in.size(),
+											 (unsigned int) ucl_parser_get_default_priority(parser),
+											 duplicate_strategy,
+											 UCL_PARSE_UCL);
 		};
 
-		return parse_with_strategy_function (config_func, parse_func, err);
+		return parse_with_strategy_function(config_func, parse_func, err);
 	}
 
-	static Ucl parse (const std::string &in, const variable_replacer &replacer,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const variable_replacer &replacer,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		std::vector< std::tuple< std::string, macro_handler_s, void * > > emptyVector;
-		return parse ( in, replacer, emptyVector, err, duplicate_strategy );
+		std::vector<std::tuple<std::string, macro_handler_s, void *>> emptyVector;
+		return parse(in, replacer, emptyVector, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const std::string &in, const variable_replacer &replacer,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const variable_replacer &replacer,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
 		//Preserve macro_userdata_s memory for later use in parse_with_strategy_function()
 		std::vector<macro_userdata_s> userdata_list;
-		userdata_list.reserve (macros.size());
-		auto config_func = [&userdata_list, &replacer, &macros] (ucl_parser *parser) {
-			ucl_parser_set_variables_handler (parser, ucl_variable_replacer, &const_cast<variable_replacer &>(replacer));
-			for (auto & macro : macros) {
-				userdata_list.push_back ({parser, std::get<2>(macro)});
+		userdata_list.reserve(macros.size());
+		auto config_func = [&userdata_list, &replacer, &macros](ucl_parser *parser) {
+			ucl_parser_set_variables_handler(parser, ucl_variable_replacer, &const_cast<variable_replacer &>(replacer));
+			for (auto &macro: macros) {
+				userdata_list.push_back({parser, std::get<2>(macro)});
 				if (std::get<1>(macro).handler != NULL) {
-					ucl_parser_register_macro (parser,
-								std::get<0>(macro).c_str(),
-								std::get<1>(macro).handler,
-								reinterpret_cast<void*>(&userdata_list.back()));
+					ucl_parser_register_macro(parser,
+											  std::get<0>(macro).c_str(),
+											  std::get<1>(macro).handler,
+											  reinterpret_cast<void *>(&userdata_list.back()));
 				}
 				else if (std::get<1>(macro).ctx_handler != NULL) {
-					ucl_parser_register_context_macro (parser,
-									std::get<0>(macro).c_str(),
-									std::get<1>(macro).ctx_handler,
-									reinterpret_cast<void*>(&userdata_list.back()));
+					ucl_parser_register_context_macro(parser,
+													  std::get<0>(macro).c_str(),
+													  std::get<1>(macro).ctx_handler,
+													  reinterpret_cast<void *>(&userdata_list.back()));
 				}
 			}
 		};
 
-		auto parse_func = [&in, &duplicate_strategy] (struct ucl_parser *parser) -> bool {
-			return ucl_parser_add_chunk_full (parser,
-							(unsigned char *) in.data (),
-							in.size (),
-							(unsigned int)ucl_parser_get_default_priority (parser),
-							duplicate_strategy,
-							UCL_PARSE_UCL);
+		auto parse_func = [&in, &duplicate_strategy](struct ucl_parser *parser) -> bool {
+			return ucl_parser_add_chunk_full(parser,
+											 (unsigned char *) in.data(),
+											 in.size(),
+											 (unsigned int) ucl_parser_get_default_priority(parser),
+											 duplicate_strategy,
+											 UCL_PARSE_UCL);
 		};
 
-		return parse_with_strategy_function (config_func, parse_func, err);
+		return parse_with_strategy_function(config_func, parse_func, err);
 	}
 
-	static Ucl parse (const char *in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), err, duplicate_strategy);
 	}
 
-	static Ucl parse (const char *in, const std::map<std::string, std::string> &vars, std::string &err)
+	static Ucl parse(const char *in, const std::map<std::string, std::string> &vars, std::string &err)
 	{
 		if (!in) {
 			err = "null input";
 			return nullptr;
 		}
-		return parse (std::string (in), vars, err);
+		return parse(std::string(in), vars, err);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const char *in,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const char *in, const std::map<std::string, std::string> &vars,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, const std::map<std::string, std::string> &vars,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
 		if (!in) {
 			err = "null input";
 			return nullptr;
 		}
-		return parse (std::string (in), vars, macros, err, duplicate_strategy);
+		return parse(std::string(in), vars, macros, err, duplicate_strategy);
 	}
 
-	static Ucl parse (const char *in, const variable_replacer &replacer,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, const variable_replacer &replacer,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
 		if (!in) {
 			err = "null input";
 			return nullptr;
 		}
-		return parse (std::string(in), replacer, err, duplicate_strategy);
+		return parse(std::string(in), replacer, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const char *in, const variable_replacer &replacer,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, const variable_replacer &replacer,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
 		if (!in) {
 			err = "null input";
 			return nullptr;
 		}
-		return parse (std::string (in), replacer, macros, err, duplicate_strategy);
+		return parse(std::string(in), replacer, macros, err, duplicate_strategy);
 	}
 
-	static Ucl parse_from_file (const std::string &filename, std::string &err)
+	static Ucl parse_from_file(const std::string &filename, std::string &err)
 	{
-		return parse_from_file (filename, std::map<std::string, std::string>(), err);
+		return parse_from_file(filename, std::map<std::string, std::string>(), err);
 	}
 
-	static Ucl parse_from_file (const std::string &filename, const std::map<std::string, std::string> &vars, std::string &err)
+	static Ucl parse_from_file(const std::string &filename, const std::map<std::string, std::string> &vars, std::string &err)
 	{
-		auto config_func = [&vars] (ucl_parser *parser) {
-			for (const auto & item : vars) {
-				ucl_parser_register_variable (parser, item.first.c_str (), item.second.c_str ());
-            }
+		auto config_func = [&vars](ucl_parser *parser) {
+			for (const auto &item: vars) {
+				ucl_parser_register_variable(parser, item.first.c_str(), item.second.c_str());
+			}
 		};
 
-		auto parse_func = [&filename] (ucl_parser *parser) {
-			return ucl_parser_add_file (parser, filename.c_str ());
+		auto parse_func = [&filename](ucl_parser *parser) {
+			return ucl_parser_add_file(parser, filename.c_str());
 		};
 
-		return parse_with_strategy_function (config_func, parse_func, err);
+		return parse_with_strategy_function(config_func, parse_func, err);
 	}
 
-	static Ucl parse_from_file (const std::string &filename, const variable_replacer &replacer, std::string &err)
+	static Ucl parse_from_file(const std::string &filename, const variable_replacer &replacer, std::string &err)
 	{
-		auto config_func = [&replacer] (ucl_parser *parser) {
-			ucl_parser_set_variables_handler (parser, ucl_variable_replacer,
-				&const_cast<variable_replacer &>(replacer));
+		auto config_func = [&replacer](ucl_parser *parser) {
+			ucl_parser_set_variables_handler(parser, ucl_variable_replacer,
+											 &const_cast<variable_replacer &>(replacer));
 		};
 
-		auto parse_func = [&filename] (ucl_parser *parser) {
-			return ucl_parser_add_file (parser, filename.c_str ());
+		auto parse_func = [&filename](ucl_parser *parser) {
+			return ucl_parser_add_file(parser, filename.c_str());
 		};
 
-		return parse_with_strategy_function (config_func, parse_func, err);
+		return parse_with_strategy_function(config_func, parse_func, err);
 	}
 
-	static std::vector<std::string> find_variable (const std::string &in)
+	static std::vector<std::string> find_variable(const std::string &in)
 	{
-		auto parser = ucl_parser_new (UCL_PARSER_DEFAULT);
+		auto parser = ucl_parser_new(UCL_PARSER_DEFAULT);
 
 		std::set<std::string> vars;
-		ucl_parser_set_variables_handler (parser, ucl_variable_getter, &vars);
-		ucl_parser_add_chunk (parser, (const unsigned char *)in.data (), in.size ());
-		ucl_parser_free (parser);
+		ucl_parser_set_variables_handler(parser, ucl_variable_getter, &vars);
+		ucl_parser_add_chunk(parser, (const unsigned char *) in.data(), in.size());
+		ucl_parser_free(parser);
 
 		std::vector<std::string> result;
-		std::move (vars.begin (), vars.end (), std::back_inserter (result));
+		std::move(vars.begin(), vars.end(), std::back_inserter(result));
 		return result;
 	}
 
-	static std::vector<std::string> find_variable (const char *in)
+	static std::vector<std::string> find_variable(const char *in)
 	{
 		if (!in) {
 			return std::vector<std::string>();
 		}
-		return find_variable (std::string (in));
+		return find_variable(std::string(in));
 	}
 
-	static std::vector<std::string> find_variable_from_file (const std::string &filename)
+	static std::vector<std::string> find_variable_from_file(const std::string &filename)
 	{
-		auto parser = ucl_parser_new (UCL_PARSER_DEFAULT);
+		auto parser = ucl_parser_new(UCL_PARSER_DEFAULT);
 
 		std::set<std::string> vars;
-		ucl_parser_set_variables_handler (parser, ucl_variable_getter, &vars);
-		ucl_parser_add_file (parser, filename.c_str ());
-		ucl_parser_free (parser);
+		ucl_parser_set_variables_handler(parser, ucl_variable_getter, &vars);
+		ucl_parser_add_file(parser, filename.c_str());
+		ucl_parser_free(parser);
 
 		std::vector<std::string> result;
-		std::move (vars.begin (), vars.end (), std::back_inserter (result));
+		std::move(vars.begin(), vars.end(), std::back_inserter(result));
 		return result;
 	}
 
-	Ucl& operator= (Ucl rhs)
+	Ucl &operator=(Ucl rhs)
 	{
-		obj.swap (rhs.obj);
+		obj.swap(rhs.obj);
 		return *this;
 	}
 
-	bool operator== (const Ucl &rhs) const
+	bool operator==(const Ucl &rhs) const
+	{
+		return ucl_object_compare(obj.get(), rhs.obj.get()) == 0;
+	}
+	bool operator<(const Ucl &rhs) const
+	{
+		return ucl_object_compare(obj.get(), rhs.obj.get()) < 0;
+	}
+	bool operator!=(const Ucl &rhs) const
 	{
-		return ucl_object_compare (obj.get(), rhs.obj.get ()) == 0;
+		return !(*this == rhs);
 	}
-	bool operator< (const Ucl &rhs) const
+	bool operator<=(const Ucl &rhs) const
 	{
-		return ucl_object_compare (obj.get(), rhs.obj.get ()) < 0;
+		return !(rhs < *this);
+	}
+	bool operator>(const Ucl &rhs) const
+	{
+		return (rhs < *this);
+	}
+	bool operator>=(const Ucl &rhs) const
+	{
+		return !(*this < rhs);
 	}
-	bool operator!= (const Ucl &rhs) const { return !(*this == rhs); }
-	bool operator<= (const Ucl &rhs) const { return !(rhs < *this); }
-	bool operator> (const Ucl &rhs) const { return (rhs < *this); }
-	bool operator>= (const Ucl &rhs) const { return !(*this < rhs); }
 
-	explicit operator bool () const
+	explicit operator bool() const
 	{
 		if (!obj || type() == UCL_NULL) {
 			return false;
 		}
 
-		if (type () == UCL_BOOLEAN) {
-			return bool_value ();
+		if (type() == UCL_BOOLEAN) {
+			return bool_value();
 		}
 
 		return true;
@@ -736,4 +778,4 @@ public:
 	}
 };
 
-};
+};// namespace ucl