WPILibC++  2019.3.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
wpi::detail Namespace Reference

detail namespace with internal helper functions More...

Classes

class  AlignerImpl
 
class  concat_range
 Helper to store a sequence of ranges being concatenated and access them. More...
 
struct  conjunction
 
struct  conjunction< B1 >
 
struct  conjunction< B1, Bn...>
 
struct  ConstantLog2
 A tiny meta function to compute the log2 of a compile time constant. More...
 
struct  ConstantLog2< 1 >
 
struct  DenseMapPair
 
class  enumerator
 
class  enumerator_iter
 
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  fwd_or_bidi_tag
 Helper which sets its type member to forward_iterator_tag if the category of IterT does not derive from bidirectional_iterator_tag, and to bidirectional_iterator_tag otherwise. More...
 
struct  fwd_or_bidi_tag_impl
 
struct  fwd_or_bidi_tag_impl< true >
 
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  index_sequence
 
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
 
struct  make_index_sequence
 
struct  make_index_sequence< 0 >
 
struct  make_index_sequence< 1 >
 
struct  merge_and_renumber
 
struct  merge_and_renumber< index_sequence< I1...>, index_sequence< I2...> >
 
struct  negation
 
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
 
struct  result_pair
 
class  SafeThreadOwnerBase
 
class  SafeThreadProxy
 
class  SafeThreadProxyBase
 
union  SizerImpl
 
struct  static_const
 
struct  to_json_fn
 
struct  TrailingZerosCounter
 
class  type_error
 exception indicating executing a member function with a wrong type More...
 
struct  WorkerThreadAsync
 
struct  WorkerThreadAsync< void >
 
struct  WorkerThreadRequest
 
class  WorkerThreadThread
 
struct  zip_common
 
struct  zip_first
 
class  zip_shortest
 
class  zippy
 
struct  ZipTupleType
 

Typedefs

template<typename RangeT >
using IterOfRange = decltype(std::begin(std::declval< RangeT & >()))
 
template<typename RangeT >
using ValueOfRange = typename std::remove_reference< decltype(*std::begin(std::declval< RangeT & >()))>::type
 
template<typename ZipType , typename... Iters>
using zip_traits = iterator_facade_base< ZipType, typename std::common_type< std::bidirectional_iterator_tag, typename std::iterator_traits< Iters >::iterator_category...>::type, typename ZipTupleType< Iters...>::type, typename std::iterator_traits< typename std::tuple_element< 0, std::tuple< Iters...>>::type >::difference_type, typename ZipTupleType< Iters...>::type *, typename ZipTupleType< Iters...>::type >
 
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... Ts>
using index_sequence_for = make_index_sequence< sizeof...(Ts)>
 

Enumerations

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

Functions

template<typename N >
bool to_float (const Twine &T, N &Num, N(*StrTo)(const char *, char **))
 
template<typename IteratorT >
std::string join_impl (IteratorT Begin, IteratorT End, StringRef Separator, std::input_iterator_tag)
 
template<typename IteratorT >
std::string join_impl (IteratorT Begin, IteratorT End, StringRef Separator, std::forward_iterator_tag)
 
template<typename Sep >
void join_items_impl (std::string &Result, Sep Separator)
 
template<typename Sep , typename Arg >
void join_items_impl (std::string &Result, Sep Separator, const Arg &Item)
 
template<typename Sep , typename Arg1 , typename... Args>
void join_items_impl (std::string &Result, Sep Separator, const Arg1 &A1, Args &&...Items)
 
size_t join_one_item_size (char C)
 
size_t join_one_item_size (const char *S)
 
template<typename T >
size_t join_one_item_size (const T &Str)
 
size_t join_items_size ()
 
template<typename A1 >
size_t join_items_size (const A1 &A)
 
template<typename A1 , typename... Args>
size_t join_items_size (const A1 &A, Args &&...Items)
 
void swap (SafeThreadOwnerBase &lhs, SafeThreadOwnerBase &rhs) noexcept
 
template<typename F , typename Tuple , std::size_t... I>
auto apply_tuple_impl (F &&f, Tuple &&t, index_sequence< I...>) -> decltype(std::forward< F >(f)(std::get< I >(std::forward< Tuple >(t))...))
 
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)
 
 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 andnot 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 andnot std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value andstd::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 andnot 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 andnot std::is_same< ArithmeticType, uint64_t >::value andnot std::is_same< ArithmeticType, int64_t >::value andnot std::is_same< ArithmeticType, double >::value andnot 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, 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< StringRef, 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 orstd::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< StringRef, 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, index_sequence< Idx...>)
 
template<typename BasicJsonType , typename... Args>
void to_json (BasicJsonType &j, const std::tuple< Args...> &t)
 

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

Enumeration Type Documentation

enum 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

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