add nlohmann modenjson (276b9a93) · Commits · derf / multipass

include/lib/modernjson/adl_serializer.hpp

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		#pragma once

		#include <utility>

		#include <lib/modernjson/detail/conversions/from_json.hpp>
		#include <lib/modernjson/detail/conversions/to_json.hpp>

		namespace nlohmann
		{
		template<typename, typename>
		struct adl_serializer
		{
		/*!
		@brief convert a JSON value to any value type

		This function is usually called by the `get()` function of the
		@ref basic_json class (either explicit or via conversion operators).

		@param[in] j JSON value to read from
		@param[in,out] val value to write to
		*/
		template<typename BasicJsonType, typename ValueType>
		static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
		noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val))) -> decltype(
		::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void()
		)
		{
		::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
		}

		/*!
		@brief convert any value type to a JSON value

		This function is usually called by the constructors of the @ref basic_json
		class.

		@param[in,out] j JSON value to write to
		@param[in] val value to read from
		*/
		template <typename BasicJsonType, typename ValueType>
		static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
		noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
		-> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)),
		void())
		{
		::nlohmann::to_json(j, std::forward<ValueType>(val));
		}
		};
		}

include/lib/modernjson/detail/conversions/from_json.hpp

0 → 100644

+370 −0

Original line number	Diff line number	Diff line
		#pragma once

		#include <algorithm> // transform
		#include <array> // array
		#include <ciso646> // and, not
		#include <forward_list> // forward_list
		#include <iterator> // inserter, front_inserter, end
		#include <map> // map
		#include <string> // string
		#include <tuple> // tuple, make_tuple
		#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
		#include <unordered_map> // unordered_map
		#include <utility> // pair, declval
		#include <valarray> // valarray

		#include <lib/modernjson/detail/exceptions.hpp>
		#include <lib/modernjson/detail/macro_scope.hpp>
		#include <lib/modernjson/detail/meta/cpp_future.hpp>
		#include <lib/modernjson/detail/meta/type_traits.hpp>
		#include <lib/modernjson/detail/value_t.hpp>

		namespace nlohmann
		{
		namespace detail
		{
		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
		{
		if (JSON_UNLIKELY(not j.is_null()))
		{
		JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
		}
		n = nullptr;
		}

		// overloads for basic_json template parameters
		template<typename BasicJsonType, typename ArithmeticType,
		enable_if_t<std::is_arithmetic<ArithmeticType>::value and
		not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
		int> = 0>
		void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
		{
		switch (static_cast<value_t>(j))
		{
		case value_t::number_unsigned:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_unsigned_t>());
		break;
		}
		case value_t::number_integer:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_integer_t>());
		break;
		}
		case value_t::number_float:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_float_t>());
		break;
		}

		default:
		JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
		}
		}

		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
		{
		if (JSON_UNLIKELY(not j.is_boolean()))
		{
		JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
		}
		b = j.template get_ptr<const typename BasicJsonType::boolean_t>();
		}

		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
		{
		if (JSON_UNLIKELY(not j.is_string()))
		{
		JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
		}
		s = j.template get_ptr<const typename BasicJsonType::string_t>();
		}

		template <
		typename BasicJsonType, typename CompatibleStringType,
		enable_if_t <
		is_compatible_string_type<BasicJsonType, CompatibleStringType>::value and
		not std::is_same<typename BasicJsonType::string_t,
		CompatibleStringType>::value,
		int > = 0 >
		void from_json(const BasicJsonType& j, CompatibleStringType& s)
		{
		if (JSON_UNLIKELY(not j.is_string()))
		{
		JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
		}

		s = j.template get_ptr<const typename BasicJsonType::string_t>();
		}

		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
		{
		get_arithmetic_value(j, val);
		}

		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
		{
		get_arithmetic_value(j, val);
		}

		template<typename BasicJsonType>
		void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
		{
		get_arithmetic_value(j, val);
		}

		template<typename BasicJsonType, typename EnumType,
		enable_if_t<std::is_enum<EnumType>::value, int> = 0>
		void from_json(const BasicJsonType& j, EnumType& e)
		{
		typename std::underlying_type<EnumType>::type val;
		get_arithmetic_value(j, val);
		e = static_cast<EnumType>(val);
		}

		// forward_list doesn't have an insert method
		template<typename BasicJsonType, typename T, typename Allocator,
		enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
		void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
		{
		if (JSON_UNLIKELY(not j.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
		}
		std::transform(j.rbegin(), j.rend(),
		std::front_inserter(l), [](const BasicJsonType & i)
		{
		return i.template get<T>();
		});
		}

		// valarray doesn't have an insert method
		template<typename BasicJsonType, typename T,
		enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
		void from_json(const BasicJsonType& j, std::valarray<T>& l)
		{
		if (JSON_UNLIKELY(not j.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
		}
		l.resize(j.size());
		std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
		}

		template<typename BasicJsonType>
		void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /unused/)
		{
		arr = j.template get_ptr<const typename BasicJsonType::array_t>();
		}

		template <typename BasicJsonType, typename T, std::size_t N>
		auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
		priority_tag<2> /unused/)
		-> decltype(j.template get<T>(), void())
		{
		for (std::size_t i = 0; i < N; ++i)
		{
		arr[i] = j.at(i).template get<T>();
		}
		}

		template<typename BasicJsonType, typename CompatibleArrayType>
		auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /unused/)
		-> decltype(
		arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
		j.template get<typename CompatibleArrayType::value_type>(),
		void())
		{
		using std::end;

		arr.reserve(j.size());
		std::transform(j.begin(), j.end(),
		std::inserter(arr, end(arr)), [](const BasicJsonType & i)
		{
		// get<BasicJsonType>() returns *this, this won't call a from_json
		// method when value_type is BasicJsonType
		return i.template get<typename CompatibleArrayType::value_type>();
		});
		}

		template <typename BasicJsonType, typename CompatibleArrayType>
		void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr,
		priority_tag<0> /unused/)
		{
		using std::end;

		std::transform(
		j.begin(), j.end(), std::inserter(arr, end(arr)),
		[](const BasicJsonType & i)
		{
		// get<BasicJsonType>() returns *this, this won't call a from_json
		// method when value_type is BasicJsonType
		return i.template get<typename CompatibleArrayType::value_type>();
		});
		}

		template <typename BasicJsonType, typename CompatibleArrayType,
		enable_if_t <
		is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and
		not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and
		not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and
		not is_basic_json<CompatibleArrayType>::value,
		int > = 0 >

		auto from_json(const BasicJsonType& j, CompatibleArrayType& arr)
		-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
		j.template get<typename CompatibleArrayType::value_type>(),
		void())
		{
		if (JSON_UNLIKELY(not j.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " +
		std::string(j.type_name())));
		}

		from_json_array_impl(j, arr, priority_tag<3> {});
		}

		template<typename BasicJsonType, typename CompatibleObjectType,
		enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
		void from_json(const BasicJsonType& j, CompatibleObjectType& obj)
		{
		if (JSON_UNLIKELY(not j.is_object()))
		{
		JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
		}

		auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
		using value_type = typename CompatibleObjectType::value_type;
		std::transform(
		inner_object->begin(), inner_object->end(),
		std::inserter(obj, obj.begin()),
		[](typename BasicJsonType::object_t::value_type const & p)
		{
		return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());
		});
		}

		// overload for arithmetic types, not chosen for basic_json template arguments
		// (BooleanType, etc..); note: Is it really necessary to provide explicit
		// overloads for boolean_t etc. in case of a custom BooleanType which is not
		// an arithmetic type?
		template<typename BasicJsonType, typename ArithmeticType,
		enable_if_t <
		std::is_arithmetic<ArithmeticType>::value and
		not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
		not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
		not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
		not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
		int> = 0>
		void from_json(const BasicJsonType& j, ArithmeticType& val)
		{
		switch (static_cast<value_t>(j))
		{
		case value_t::number_unsigned:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_unsigned_t>());
		break;
		}
		case value_t::number_integer:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_integer_t>());
		break;
		}
		case value_t::number_float:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::number_float_t>());
		break;
		}
		case value_t::boolean:
		{
		val = static_cast<ArithmeticType>(j.template get_ptr<const typename BasicJsonType::boolean_t>());
		break;
		}

		default:
		JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
		}
		}

		template<typename BasicJsonType, typename A1, typename A2>
		void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
		{
		p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
		}

		template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
		void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)
		{
		t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
		}

		template<typename BasicJsonType, typename... Args>
		void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
		{
		from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
		}

		template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
		typename = enable_if_t<not std::is_constructible<
		typename BasicJsonType::string_t, Key>::value>>
		void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
		{
		if (JSON_UNLIKELY(not j.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
		}
		for (const auto& p : j)
		{
		if (JSON_UNLIKELY(not p.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
		}
		m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
		}
		}

		template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
		typename = enable_if_t<not std::is_constructible<
		typename BasicJsonType::string_t, Key>::value>>
		void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
		{
		if (JSON_UNLIKELY(not j.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
		}
		for (const auto& p : j)
		{
		if (JSON_UNLIKELY(not p.is_array()))
		{
		JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
		}
		m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
		}
		}

		struct from_json_fn
		{
		template<typename BasicJsonType, typename T>
		auto operator()(const BasicJsonType& j, T& val) const
		noexcept(noexcept(from_json(j, val)))
		-> decltype(from_json(j, val), void())
		{
		return from_json(j, val);
		}
		};
		}

		/// namespace to hold default `from_json` function
		/// to see why this is required:
		/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
		namespace
		{
		constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
		}
		}

include/lib/modernjson/detail/conversions/to_chars.hpp

0 → 100644

+1095 −0

File added.

Preview size limit exceeded, changes collapsed.

include/lib/modernjson/detail/conversions/to_json.hpp

0 → 100644

+342 −0

File added.

Preview size limit exceeded, changes collapsed.

include/lib/modernjson/detail/exceptions.hpp

0 → 100644

+330 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message