wpi::detail Namespace Reference

detail namespace with internal helper functions More...

Classes
struct	ConstantLog2
	A tiny meta function to compute the log2 of a compile time constant. More...
struct	ConstantLog2< 1 >
union	copy_construction_triviality_helper
	Internal utility to detect trivial copy construction. More...
struct	DenseMapPair
class	exception
	general exception of the json class More...
struct	external_constructor
struct	external_constructor< value_t::array >
struct	external_constructor< value_t::boolean >
struct	external_constructor< value_t::number_float >
struct	external_constructor< value_t::number_integer >
struct	external_constructor< value_t::number_unsigned >
struct	external_constructor< value_t::object >
struct	external_constructor< value_t::string >
struct	from_json_fn
struct	FutureThen
struct	FutureThen< To, void >
struct	FutureThen< void, From >
struct	FutureThen< void, void >
struct	has_from_json
struct	has_non_default_from_json
struct	has_to_json
struct	HasPointerLikeTypeTraits
struct	HasPointerLikeTypeTraits< T, decltype((sizeof(PointerLikeTypeTraits< T >)+sizeof(T)), void())>
struct	internal_iterator
	an iterator value More...
class	invalid_iterator
	exception indicating errors with iterators More...
struct	is_compatible_array_type
struct	is_compatible_complete_type
struct	is_compatible_integer_type
struct	is_compatible_integer_type_impl
struct	is_compatible_integer_type_impl< true, RealIntegerType, CompatibleNumberIntegerType >
struct	is_compatible_object_type
struct	is_compatible_object_type_impl
struct	is_compatible_object_type_impl< true, RealType, CompatibleObjectType >
struct	is_compatible_type
struct	is_complete_type
struct	is_complete_type< T, decltype(void(sizeof(T)))>
struct	is_json
struct	is_json< json >
struct	is_json_nested_type
struct	IsPointerLike
struct	IsPointerLike< T * >
class	iter_impl
	a template for a bidirectional iterator for the json class More...
class	iteration_proxy
	proxy class for the items() function More...
class	json_ref
class	json_reverse_iterator
	a template for a reverse iterator class More...
struct	LeadingZerosCounter
union	move_construction_triviality_helper
	Internal utility to detect trivial move construction. More...
class	other_error
	exception indicating other library errors More...
class	out_of_range
	exception indicating access out of the defined range More...
class	parse_error
	exception indicating a parse error More...
struct	PopulationCounter
struct	PopulationCounter< T, 8 >
class	primitive_iterator_t
struct	priority_tag
struct	priority_tag< 0 >
class	PromiseFactoryBase
class	SafeThreadOwnerBase
	Non-template owner base class for common owner code. More...
class	SafeThreadProxy
	A proxy for SafeThread. More...
class	SafeThreadProxyBase
	Non-template proxy base class for common proxy code. More...
struct	static_const
struct	to_json_fn
struct	TrailingZerosCounter
union	trivial_helper
class	type_error
	exception indicating executing a member function with a wrong type More...
struct	TypesAreDistinct
struct	TypesAreDistinct< T >
class	UniqueFunctionBase
struct	WorkerThreadAsync
struct	WorkerThreadAsync< void >
struct	WorkerThreadRequest
class	WorkerThreadThread

Typedefs
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<typename T >
using	uncvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
template<typename T >
using	EnableIfTrivial = std::enable_if_t< wpi::is_trivially_move_constructible< T >::value &&std::is_trivially_destructible< T >::value >
template<typename CallableT , typename ThisT >
using	EnableUnlessSameType = std::enable_if_t<!std::is_same< remove_cvref_t< CallableT >, ThisT >::value >
template<typename CallableT , typename Ret , typename... Params>
using	EnableIfCallable = std::enable_if_t< wpi::disjunction< std::is_void< Ret >, std::is_same< decltype(std::declval< CallableT >()(std::declval< Params >()...)), Ret >, std::is_same< const decltype(std::declval< CallableT >()(std::declval< Params >()...)), Ret >, std::is_convertible< decltype(std::declval< CallableT >()(std::declval< Params >()...)), Ret > >::value >

Enumerations
enum class	value_t : std::uint8_t {   null , object , array , string ,   boolean , number_integer , number_unsigned , number_float ,   discarded }
	the JSON type enumeration More...

Functions
template<typename R , typename... T>
void	RunWorkerThreadRequest (WorkerThreadThread< R, T... > &thr, WorkerThreadRequest< R, T... > &req)
template<typename... T>
void	RunWorkerThreadRequest (WorkerThreadThread< void, T... > &thr, WorkerThreadRequest< void, T... > &req)
void	swap (SafeThreadOwnerBase &lhs, SafeThreadOwnerBase &rhs) noexcept
	NLOHMANN_JSON_HAS_HELPER (mapped_type)
	NLOHMANN_JSON_HAS_HELPER (key_type)
	NLOHMANN_JSON_HAS_HELPER (value_type)
	NLOHMANN_JSON_HAS_HELPER (iterator)
bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types More...
template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, bool >::value, int > = 0>
void	get_arithmetic_value (const BasicJsonType &j, ArithmeticType &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, bool &b)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, std::string &s)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, double &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, uint64_t &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, int64_t &val)
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	from_json (const BasicJsonType &j, EnumType &e)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::array_t &arr)
template<typename BasicJsonType , typename CompatibleArrayType >
void	from_json_array_impl (const BasicJsonType &j, CompatibleArrayType &arr, priority_tag< 0 >)
template<typename BasicJsonType , typename CompatibleArrayType >
auto	from_json_array_impl (const BasicJsonType &j, CompatibleArrayType &arr, priority_tag< 1 >) -> decltype(arr.reserve(std::declval< typename CompatibleArrayType::size_type >()), void())
template<typename BasicJsonType , typename T , std::size_t N>
void	from_json_array_impl (const BasicJsonType &j, std::array< T, N > &arr, priority_tag< 2 >)
template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value and not std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value and std::is_constructible< BasicJsonType, typename CompatibleArrayType::value_type >::value, int > = 0>
void	from_json (const BasicJsonType &j, CompatibleArrayType &arr)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::object_t &obj)
template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value and not std::is_same< typename BasicJsonType::object_t, CompatibleObjectType >::value, int > = 0>
void	from_json (const BasicJsonType &j, CompatibleObjectType &obj)
template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, uint64_t >::value and not std::is_same< ArithmeticType, int64_t >::value and not std::is_same< ArithmeticType, double >::value and not std::is_same< ArithmeticType, bool >::value, int > = 0>
void	from_json (const BasicJsonType &j, ArithmeticType &val)
template<typename BasicJsonType , typename A1 , typename A2 >
void	from_json (const BasicJsonType &j, std::pair< A1, A2 > &p)
template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	from_json_tuple_impl (const BasicJsonType &j, Tuple &t, std::index_sequence< Idx... >)
template<typename BasicJsonType , typename... Args>
void	from_json (const BasicJsonType &j, std::tuple< Args... > &t)
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, bool >::value, int > = 0>
void	to_json (BasicJsonType &j, T b) noexcept
template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< std::string_view, CompatibleString >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleString &s)
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< std::string, T >::value, int > = 0>
void	to_json (BasicJsonType &j, T &&s)
template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>
void	to_json (BasicJsonType &j, FloatType val) noexcept
template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< uint64_t, CompatibleNumberUnsignedType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberUnsignedType val) noexcept
template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< int64_t, CompatibleNumberIntegerType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberIntegerType val) noexcept
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	to_json (BasicJsonType &j, EnumType e) noexcept
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, const std::vector< bool > &e)
template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value or std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleArrayType &arr)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::array_t &&arr)
template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleObjectType &obj)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::object_t &&obj)
template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< not std::is_constructible< std::string_view, T(&)[N]>::value, int > = 0>
void	to_json (BasicJsonType &j, T(&arr)[N])
template<typename BasicJsonType , typename... Args>
void	to_json (BasicJsonType &j, const std::pair< Args... > &p)
template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	to_json_tuple_impl (BasicJsonType &j, const Tuple &t, std::index_sequence< Idx... >)
template<typename BasicJsonType , typename... Args>
void	to_json (BasicJsonType &j, const std::tuple< Args... > &t)
bool	GetAsUnsignedInteger (std::string_view str, unsigned radix, unsigned long long &result) noexcept
bool	GetAsSignedInteger (std::string_view str, unsigned radix, long long &result) noexcept
bool	ConsumeUnsignedInteger (std::string_view &str, unsigned radix, unsigned long long &result) noexcept
bool	ConsumeSignedInteger (std::string_view &str, unsigned radix, long long &result) noexcept
static unsigned	combineHashValue (unsigned a, unsigned b)
	Simplistic combination of 32-bit hash values into 32-bit hash values. More...

Detailed Description

detail namespace with internal helper functions

This namespace collects functions that should not be exposed, implementations of some json methods, and meta-programming helpers.

Since

version 2.1.0

Typedef Documentation

enable_if_t

template<bool B, typename T = void>

using wpi::detail::enable_if_t = typedef typename std::enable_if<B, T>::type

EnableIfCallable

template<typename CallableT , typename Ret , typename... Params>

using wpi::detail::EnableIfCallable = typedef std::enable_if_t<wpi::disjunction< std::is_void<Ret>, std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)), Ret>, std::is_same<const decltype(std::declval<CallableT>()( std::declval<Params>()...)), Ret>, std::is_convertible<decltype(std::declval<CallableT>()( std::declval<Params>()...)), Ret> >::value>

EnableIfTrivial

template<typename T >

using wpi::detail::EnableIfTrivial = typedef std::enable_if_t<wpi::is_trivially_move_constructible<T>::value && std::is_trivially_destructible<T>::value>

EnableUnlessSameType

template<typename CallableT , typename ThisT >

using wpi::detail::EnableUnlessSameType = typedef std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>

uncvref_t

template<typename T >

using wpi::detail::uncvref_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type

Enumeration Type Documentation

value_t

enum class wpi::detail::value_t : std::uint8_t

strong

the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions json::is_null(), json::is_object(), json::is_array(), json::is_string(), json::is_boolean(), json::is_number() (with json::is_number_integer(), json::is_number_unsigned(), and json::is_number_float()), json::is_discarded(), json::is_primitive(), and json::is_structured() rely on it.

Note

There are three enumeration entries (number_integer, number_unsigned, and number_float), because the library distinguishes these three types for numbers: uint64_t is used for unsigned integers, int64_t is used for signed integers, and double is used for floating-point numbers or to approximate integers which do not fit in the limits of their respective type.

See also

json::json(const value_t value_type) – create a JSON value with the default value for a given type

Since

version 1.0.0

Enumerator
null	null value
object	object (unordered set of name/value pairs)
array	array (ordered collection of values)
string	string value
boolean	boolean value
number_integer	number value (signed integer)
number_unsigned	number value (unsigned integer)
number_float	number value (floating-point)
discarded	discarded by the the parser callback function

Function Documentation

combineHashValue()

static unsigned wpi::detail::combineHashValue ( unsigned  a, unsigned  b  )

inlinestatic

Simplistic combination of 32-bit hash values into 32-bit hash values.

ConsumeSignedInteger()

bool wpi::detail::ConsumeSignedInteger ( std::string_view &  str, unsigned  radix, long long &  result  )

noexcept

ConsumeUnsignedInteger()

bool wpi::detail::ConsumeUnsignedInteger ( std::string_view &  str, unsigned  radix, unsigned long long &  result  )

noexcept

from_json() [1/13]

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, uint64_t >::value and not std::is_same< ArithmeticType, int64_t >::value and not std::is_same< ArithmeticType, double >::value and not std::is_same< ArithmeticType, bool >::value, int > = 0>

void wpi::detail::from_json	(	const BasicJsonType &	j,
		ArithmeticType &	val
	)

from_json() [2/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		bool &	b
	)

from_json() [3/13]

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value and not std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value and std::is_constructible< BasicJsonType, typename CompatibleArrayType::value_type >::value, int > = 0>

void wpi::detail::from_json	(	const BasicJsonType &	j,
		CompatibleArrayType &	arr
	)

from_json() [4/13]

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value and not std::is_same< typename BasicJsonType::object_t, CompatibleObjectType >::value, int > = 0>

void wpi::detail::from_json	(	const BasicJsonType &	j,
		CompatibleObjectType &	obj
	)

from_json() [5/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		double &	val
	)

from_json() [6/13]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void wpi::detail::from_json	(	const BasicJsonType &	j,
		EnumType &	e
	)

from_json() [7/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		int64_t &	val
	)

from_json() [8/13]

template<typename BasicJsonType , typename A1 , typename A2 >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		std::pair< A1, A2 > &	p
	)

from_json() [9/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		std::string &	s
	)

from_json() [10/13]

template<typename BasicJsonType , typename... Args>

void wpi::detail::from_json	(	const BasicJsonType &	j,
		std::tuple< Args... > &	t
	)

from_json() [11/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::array_t &	arr
	)

from_json() [12/13]

template<typename BasicJsonType >

void wpi::detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::object_t &  obj  )

inline

from_json() [13/13]

template<typename BasicJsonType >

void wpi::detail::from_json	(	const BasicJsonType &	j,
		uint64_t &	val
	)

from_json_array_impl() [1/3]

template<typename BasicJsonType , typename CompatibleArrayType >

void wpi::detail::from_json_array_impl	(	const BasicJsonType &	j,
		CompatibleArrayType &	arr,
		priority_tag< 0 >
	)

from_json_array_impl() [2/3]

template<typename BasicJsonType , typename CompatibleArrayType >

auto wpi::detail::from_json_array_impl	(	const BasicJsonType &	j,
		CompatibleArrayType &	arr,
		priority_tag< 1 >
	)		-> decltype( arr.reserve(std::declval<typename CompatibleArrayType::size_type>()), void())

from_json_array_impl() [3/3]

template<typename BasicJsonType , typename T , std::size_t N>

void wpi::detail::from_json_array_impl	(	const BasicJsonType &	j,
		std::array< T, N > &	arr,
		priority_tag< 2 >
	)

from_json_tuple_impl()

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>

void wpi::detail::from_json_tuple_impl	(	const BasicJsonType &	j,
		Tuple &	t,
		std::index_sequence< Idx... >
	)

get_arithmetic_value()

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, bool >::value, int > = 0>

void wpi::detail::get_arithmetic_value	(	const BasicJsonType &	j,
		ArithmeticType &	val
	)

GetAsSignedInteger()

bool wpi::detail::GetAsSignedInteger ( std::string_view  str, unsigned  radix, long long &  result  )

noexcept

GetAsUnsignedInteger()

bool wpi::detail::GetAsUnsignedInteger ( std::string_view  str, unsigned  radix, unsigned long long &  result  )

noexcept

NLOHMANN_JSON_HAS_HELPER() [1/4]

wpi::detail::NLOHMANN_JSON_HAS_HELPER

(

iterator

)

NLOHMANN_JSON_HAS_HELPER() [2/4]

wpi::detail::NLOHMANN_JSON_HAS_HELPER

(

key_type

)

NLOHMANN_JSON_HAS_HELPER() [3/4]

wpi::detail::NLOHMANN_JSON_HAS_HELPER

(

mapped_type

)

NLOHMANN_JSON_HAS_HELPER() [4/4]

wpi::detail::NLOHMANN_JSON_HAS_HELPER

(

value_type

)

operator<()

bool wpi::detail::operator< ( const value_t  lhs, const value_t  rhs  )

inlinenoexcept

comparison operator for JSON types

Returns an ordering that is similar to Python:

• order: null < boolean < number < object < array < string
• furthermore, each type is not smaller than itself
• discarded values are not comparable

Since

version 1.0.0

RunWorkerThreadRequest() [1/2]

template<typename R , typename... T>

void wpi::detail::RunWorkerThreadRequest	(	WorkerThreadThread< R, T... > &	thr,
		WorkerThreadRequest< R, T... > &	req
	)

RunWorkerThreadRequest() [2/2]

template<typename... T>

void wpi::detail::RunWorkerThreadRequest	(	WorkerThreadThread< void, T... > &	thr,
		WorkerThreadRequest< void, T... > &	req
	)

swap()

void wpi::detail::swap ( SafeThreadOwnerBase &  lhs, SafeThreadOwnerBase &  rhs  )

noexcept

to_json() [1/15]

template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< int64_t, CompatibleNumberIntegerType >::value, int > = 0>

void wpi::detail::to_json ( BasicJsonType &  j, CompatibleNumberIntegerType  val  )

noexcept

to_json() [2/15]

template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< uint64_t, CompatibleNumberUnsignedType >::value, int > = 0>

void wpi::detail::to_json ( BasicJsonType &  j, CompatibleNumberUnsignedType  val  )

noexcept

to_json() [3/15]

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value or std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value, int > = 0>

void wpi::detail::to_json	(	BasicJsonType &	j,
		const CompatibleArrayType &	arr
	)

to_json() [4/15]

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value, int > = 0>

void wpi::detail::to_json	(	BasicJsonType &	j,
		const CompatibleObjectType &	obj
	)

to_json() [5/15]

template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< std::string_view, CompatibleString >::value, int > = 0>

void wpi::detail::to_json	(	BasicJsonType &	j,
		const CompatibleString &	s
	)

to_json() [6/15]

template<typename BasicJsonType , typename... Args>

void wpi::detail::to_json	(	BasicJsonType &	j,
		const std::pair< Args... > &	p
	)

to_json() [7/15]

template<typename BasicJsonType , typename... Args>

void wpi::detail::to_json	(	BasicJsonType &	j,
		const std::tuple< Args... > &	t
	)

to_json() [8/15]

template<typename BasicJsonType >

void wpi::detail::to_json	(	BasicJsonType &	j,
		const std::vector< bool > &	e
	)

to_json() [9/15]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void wpi::detail::to_json ( BasicJsonType &  j, EnumType  e  )

noexcept

to_json() [10/15]

template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>

void wpi::detail::to_json ( BasicJsonType &  j, FloatType  val  )

noexcept

to_json() [11/15]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< std::string, T >::value, int > = 0>

void wpi::detail::to_json	(	BasicJsonType &	j,
		T &&	s
	)

to_json() [12/15]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, bool >::value, int > = 0>

void wpi::detail::to_json ( BasicJsonType &  j, T  b  )

noexcept

to_json() [13/15]

template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< not std::is_constructible< std::string_view, T(&)[N]>::value, int > = 0>

void wpi::detail::to_json	(	BasicJsonType &	j,
		T(&)	arr[N]
	)

to_json() [14/15]

template<typename BasicJsonType >

void wpi::detail::to_json	(	BasicJsonType &	j,
		typename BasicJsonType::array_t &&	arr
	)

to_json() [15/15]

template<typename BasicJsonType >

void wpi::detail::to_json	(	BasicJsonType &	j,
		typename BasicJsonType::object_t &&	obj
	)

to_json_tuple_impl()

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>

void wpi::detail::to_json_tuple_impl	(	BasicJsonType &	j,
		const Tuple &	t,
		std::index_sequence< Idx... >
	)