nlohmann::json_pointer< BasicJsonType > Class Template Reference

JSON Pointer. More...

#include <json.hpp>

Public Member Functions
	json_pointer (const std::string &s="")
	create JSON pointer More...
std::string	to_string () const
	return a string representation of the JSON pointer More...
	operator std::string () const
	return a string representation of the JSON pointer More...

Static Public Member Functions
static int	array_index (const std::string &s)

Private Member Functions
std::string	pop_back ()
	remove and return last reference pointer More...
bool	is_root () const noexcept
	return whether pointer points to the root document More...
json_pointer	top () const
BasicJsonType &	get_and_create (BasicJsonType &j) const
	create and return a reference to the pointed to value More...
BasicJsonType &	get_unchecked (BasicJsonType *ptr) const
	return a reference to the pointed to value More...
BasicJsonType &	get_checked (BasicJsonType *ptr) const
const BasicJsonType &	get_unchecked (const BasicJsonType *ptr) const
	return a const reference to the pointed to value More...
const BasicJsonType &	get_checked (const BasicJsonType *ptr) const

Static Private Member Functions
static std::vector< std::string >	split (const std::string &reference_string)
	split the string input to reference tokens More...
static void	replace_substring (std::string &s, const std::string &f, const std::string &t)
	replace all occurrences of a substring by another string More...
static std::string	escape (std::string s)
	escape "~" to "~0" and "/" to "~1" More...
static void	unescape (std::string &s)
	unescape "~1" to tilde and "~0" to slash (order is important!) More...
static void	flatten (const std::string &reference_string, const BasicJsonType &value, BasicJsonType &result)
static BasicJsonType	unflatten (const BasicJsonType &value)

Private Attributes
std::vector< std::string >	reference_tokens
	the reference tokens More...

Friends
template<template< typename, typename, typename... > class ObjectType, template< typename, typename... > class ArrayType, class StringType , class BooleanType , class NumberIntegerType , class NumberUnsignedType , class NumberFloatType , template< typename > class AllocatorType, template< typename, typename=void > class JSONSerializer>
class	basic_json
bool	operator== (json_pointer const &lhs, json_pointer const &rhs) noexcept
bool	operator!= (json_pointer const &lhs, json_pointer const &rhs) noexcept

Detailed Description

template<typename BasicJsonType>
class nlohmann::json_pointer< BasicJsonType >

JSON Pointer.

A JSON pointer defines a string syntax for identifying a specific value within a JSON document. It can be used with functions at and operator[]. Furthermore, JSON pointers are the base for JSON patches.

See also

RFC 6901

Since

version 2.0.0

Definition at line 100 of file json.hpp.

Constructor & Destructor Documentation

template<typename BasicJsonType >

nlohmann::json_pointer< BasicJsonType >::json_pointer ( const std::string &  s = "" )

inlineexplicit

create JSON pointer

Create a JSON pointer according to the syntax described in Section 3 of RFC6901.

Parameters

[in]

s

string representing the JSON pointer; if omitted, the empty string is assumed which references the whole JSON value

Exceptions

parse_error.107	if the given JSON pointer s is nonempty and does not begin with a slash (/); see example below
parse_error.108	if a tilde (~) in the given JSON pointer s is not followed by 0 (representing ~) or 1 (representing /); see example below

{The example shows the construction several valid JSON pointers as well as the exceptional behavior.,json_pointer}

Since

version 2.0.0

Definition at line 11623 of file json.hpp.

        : reference_tokens(split(s))
    {}

Member Function Documentation

template<typename BasicJsonType >

static int nlohmann::json_pointer< BasicJsonType >::array_index ( const std::string &  s )

inlinestatic

Parameters

[in]

s

reference token to be converted into an array index

Returns

integer representation of s

Exceptions

out_of_range.404

if string s could not be converted to an integer

Definition at line 11665 of file json.hpp.

References nlohmann::detail::out_of_range::create(), JSON_THROW, and JSON_UNLIKELY.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch().

    {
        std::size_t processed_chars = 0;
        const int res = std::stoi(s, &processed_chars);

        // check if the string was completely read
        if (JSON_UNLIKELY(processed_chars != s.size()))
        {
            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
        }

        return res;
    }

template<typename BasicJsonType >

static std::string nlohmann::json_pointer< BasicJsonType >::escape ( std::string  s )

inlinestaticprivate

escape "~" to "~0" and "/" to "~1"

Definition at line 12150 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::diff().

    {
        replace_substring(s, "~", "~0");
        replace_substring(s, "/", "~1");
        return s;
    }

template<typename BasicJsonType >

static void nlohmann::json_pointer< BasicJsonType >::flatten ( const std::string &  reference_string, const BasicJsonType &  value, BasicJsonType &  result  )

inlinestaticprivate

Parameters

[in]	reference_string	the reference string to the current value
[in]	value	the value to consider
[in,out]	result	the result object to insert values to

Note

Empty objects or arrays are flattened to null.

Definition at line 12171 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::object, and Catch::Generators::value().

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::flatten().

    {
        switch (value.m_type)
        {
            case detail::value_t::array:
            {
                if (value.m_value.array->empty())
                {
                    // flatten empty array as null
                    result[reference_string] = nullptr;
                }
                else
                {
                    // iterate array and use index as reference string
                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
                    {
                        flatten(reference_string + "/" + std::to_string(i),
                                value.m_value.array->operator[](i), result);
                    }
                }
                break;
            }

            case detail::value_t::object:
            {
                if (value.m_value.object->empty())
                {
                    // flatten empty object as null
                    result[reference_string] = nullptr;
                }
                else
                {
                    // iterate object and use keys as reference string
                    for (const auto& element : *value.m_value.object)
                    {
                        flatten(reference_string + "/" + escape(element.first), element.second, result);
                    }
                }
                break;
            }

            default:
            {
                // add primitive value with its reference string
                result[reference_string] = value;
                break;
            }
        }
    }

template<typename BasicJsonType >

BasicJsonType& nlohmann::json_pointer< BasicJsonType >::get_and_create ( BasicJsonType &  j ) const

inlineprivate

create and return a reference to the pointed to value

Linear in the number of reference tokens.

Exceptions

parse_error.109	if array index is not a number
type_error.313	if value cannot be unflattened

Definition at line 11722 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::parse_error::create(), nlohmann::detail::type_error::create(), JSON_CATCH, JSON_THROW, JSON_TRY, nlohmann::detail::null, and nlohmann::detail::object.

Referenced by nlohmann::json_pointer< BasicJsonType >::unflatten().

    {
        using size_type = typename BasicJsonType::size_type;
        auto result = &j;

        // in case no reference tokens exist, return a reference to the JSON value
        // j which will be overwritten by a primitive value
        for (const auto& reference_token : reference_tokens)
        {
            switch (result->m_type)
            {
                case detail::value_t::null:
                {
                    if (reference_token == "0")
                    {
                        // start a new array if reference token is 0
                        result = &result->operator[](0);
                    }
                    else
                    {
                        // start a new object otherwise
                        result = &result->operator[](reference_token);
                    }
                    break;
                }

                case detail::value_t::object:
                {
                    // create an entry in the object
                    result = &result->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    // create an entry in the array
                    JSON_TRY
                    {
                        result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
                    }
                    JSON_CATCH(std::invalid_argument&)
                    {
                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                    }
                    break;
                }

                /*
                The following code is only reached if there exists a reference
                token _and_ the current value is primitive. In this case, we have
                an error situation, because primitive values may only occur as
                single value; that is, with an empty list of reference tokens.
                */
                default:
                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
            }
        }

        return *result;
    }

template<typename BasicJsonType >

BasicJsonType& nlohmann::json_pointer< BasicJsonType >::get_checked ( BasicJsonType *  ptr ) const

inlineprivate

Exceptions

parse_error.106	if an array index begins with '0'
parse_error.109	if an array index was not a number
out_of_range.402	if the array index '-' is used
out_of_range.404	if the JSON pointer can not be resolved

Definition at line 11878 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::parse_error::create(), nlohmann::detail::out_of_range::create(), JSON_CATCH, JSON_THROW, JSON_TRY, JSON_UNLIKELY, and nlohmann::detail::object.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::at(), and nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value().

    {
        using size_type = typename BasicJsonType::size_type;
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->m_type)
            {
                case detail::value_t::object:
                {
                    // note: at performs range check
                    ptr = &ptr->at(reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        JSON_THROW(detail::out_of_range::create(402,
                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
                                                                ") is out of range"));
                    }

                    // error condition (cf. RFC 6901, Sect. 4)
                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                    {
                        JSON_THROW(detail::parse_error::create(106, 0,
                                                               "array index '" + reference_token +
                                                               "' must not begin with '0'"));
                    }

                    // note: at performs range check
                    JSON_TRY
                    {
                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
                    }
                    JSON_CATCH(std::invalid_argument&)
                    {
                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                    }
                    break;
                }

                default:
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
            }
        }

        return *ptr;
    }

template<typename BasicJsonType >

const BasicJsonType& nlohmann::json_pointer< BasicJsonType >::get_checked ( const BasicJsonType *  ptr ) const

inlineprivate

Exceptions

parse_error.106	if an array index begins with '0'
parse_error.109	if an array index was not a number
out_of_range.402	if the array index '-' is used
out_of_range.404	if the JSON pointer can not be resolved

Definition at line 12002 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::parse_error::create(), nlohmann::detail::out_of_range::create(), JSON_CATCH, JSON_THROW, JSON_TRY, JSON_UNLIKELY, and nlohmann::detail::object.

    {
        using size_type = typename BasicJsonType::size_type;
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->m_type)
            {
                case detail::value_t::object:
                {
                    // note: at performs range check
                    ptr = &ptr->at(reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        JSON_THROW(detail::out_of_range::create(402,
                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
                                                                ") is out of range"));
                    }

                    // error condition (cf. RFC 6901, Sect. 4)
                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                    {
                        JSON_THROW(detail::parse_error::create(106, 0,
                                                               "array index '" + reference_token +
                                                               "' must not begin with '0'"));
                    }

                    // note: at performs range check
                    JSON_TRY
                    {
                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
                    }
                    JSON_CATCH(std::invalid_argument&)
                    {
                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                    }
                    break;
                }

                default:
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
            }
        }

        return *ptr;
    }

template<typename BasicJsonType >

BasicJsonType& nlohmann::json_pointer< BasicJsonType >::get_unchecked ( BasicJsonType *  ptr ) const

inlineprivate

return a reference to the pointed to value

Note

This version does not throw if a value is not present, but tries to create nested values instead. For instance, calling this function with pointer "/this/that" on a null value is equivalent to calling operator[]("this").operator[]("that") on that value, effectively changing the null value to an object.

Parameters

[in]

ptr

a JSON value

Returns

reference to the JSON value pointed to by the JSON pointer

Linear in the length of the JSON pointer.

Exceptions

parse_error.106	if an array index begins with '0'
parse_error.109	if an array index was not a number
out_of_range.404	if the JSON pointer can not be resolved

Definition at line 11802 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::parse_error::create(), nlohmann::detail::out_of_range::create(), JSON_CATCH, JSON_THROW, JSON_TRY, JSON_UNLIKELY, nlohmann::detail::null, nlohmann::detail::object, and x.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::operator[]().

    {
        using size_type = typename BasicJsonType::size_type;
        for (const auto& reference_token : reference_tokens)
        {
            // convert null values to arrays or objects before continuing
            if (ptr->m_type == detail::value_t::null)
            {
                // check if reference token is a number
                const bool nums =
                    std::all_of(reference_token.begin(), reference_token.end(),
                                [](const char x)
                {
                    return (x >= '0' and x <= '9');
                });

                // change value to array for numbers or "-" or to object otherwise
                *ptr = (nums or reference_token == "-")
                       ? detail::value_t::array
                       : detail::value_t::object;
            }

            switch (ptr->m_type)
            {
                case detail::value_t::object:
                {
                    // use unchecked object access
                    ptr = &ptr->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    // error condition (cf. RFC 6901, Sect. 4)
                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                    {
                        JSON_THROW(detail::parse_error::create(106, 0,
                                                               "array index '" + reference_token +
                                                               "' must not begin with '0'"));
                    }

                    if (reference_token == "-")
                    {
                        // explicitly treat "-" as index beyond the end
                        ptr = &ptr->operator[](ptr->m_value.array->size());
                    }
                    else
                    {
                        // convert array index to number; unchecked access
                        JSON_TRY
                        {
                            ptr = &ptr->operator[](
                                static_cast<size_type>(array_index(reference_token)));
                        }
                        JSON_CATCH(std::invalid_argument&)
                        {
                            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                        }
                    }
                    break;
                }

                default:
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
            }
        }

        return *ptr;
    }

template<typename BasicJsonType >

const BasicJsonType& nlohmann::json_pointer< BasicJsonType >::get_unchecked ( const BasicJsonType *  ptr ) const

inlineprivate

return a const reference to the pointed to value

Parameters

[in]

ptr

a JSON value

Returns

const reference to the JSON value pointed to by the JSON pointer

Exceptions

parse_error.106	if an array index begins with '0'
parse_error.109	if an array index was not a number
out_of_range.402	if the array index '-' is used
out_of_range.404	if the JSON pointer can not be resolved

Definition at line 11943 of file json.hpp.

References nlohmann::detail::array, nlohmann::detail::parse_error::create(), nlohmann::detail::out_of_range::create(), JSON_CATCH, JSON_THROW, JSON_TRY, JSON_UNLIKELY, and nlohmann::detail::object.

    {
        using size_type = typename BasicJsonType::size_type;
        for (const auto& reference_token : reference_tokens)
        {
            switch (ptr->m_type)
            {
                case detail::value_t::object:
                {
                    // use unchecked object access
                    ptr = &ptr->operator[](reference_token);
                    break;
                }

                case detail::value_t::array:
                {
                    if (JSON_UNLIKELY(reference_token == "-"))
                    {
                        // "-" cannot be used for const access
                        JSON_THROW(detail::out_of_range::create(402,
                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
                                                                ") is out of range"));
                    }

                    // error condition (cf. RFC 6901, Sect. 4)
                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
                    {
                        JSON_THROW(detail::parse_error::create(106, 0,
                                                               "array index '" + reference_token +
                                                               "' must not begin with '0'"));
                    }

                    // use unchecked array access
                    JSON_TRY
                    {
                        ptr = &ptr->operator[](
                            static_cast<size_type>(array_index(reference_token)));
                    }
                    JSON_CATCH(std::invalid_argument&)
                    {
                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
                    }
                    break;
                }

                default:
                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
            }
        }

        return *ptr;
    }

template<typename BasicJsonType >

bool nlohmann::json_pointer< BasicJsonType >::is_root ( ) const

inlineprivatenoexcept

return whether pointer points to the root document

Definition at line 11697 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch().

    {
        return reference_tokens.empty();
    }

template<typename BasicJsonType >

nlohmann::json_pointer< BasicJsonType >::operator std::string ( ) const

inline

return a string representation of the JSON pointer

Invariant

For each JSON pointer ptr, it holds:

ptr == json_pointer(ptr.to_string());

Returns

a string representation of the JSON pointer

{The example shows the result of to_string., json_pointer__to_string}

Since

version 2.0.0

Definition at line 11653 of file json.hpp.

    {
        return to_string();
    }

template<typename BasicJsonType >

std::string nlohmann::json_pointer< BasicJsonType >::pop_back ( )

inlineprivate

remove and return last reference pointer

Exceptions

out_of_range.405

if JSON pointer has no parent

Definition at line 11684 of file json.hpp.

References nlohmann::detail::out_of_range::create(), JSON_THROW, and JSON_UNLIKELY.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch().

    {
        if (JSON_UNLIKELY(is_root()))
        {
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
        }

        auto last = reference_tokens.back();
        reference_tokens.pop_back();
        return last;
    }

template<typename BasicJsonType >

static void nlohmann::json_pointer< BasicJsonType >::replace_substring ( std::string &  s, const std::string &  f, const std::string &  t  )

inlinestaticprivate

replace all occurrences of a substring by another string

Parameters

[in,out]	s	the string to manipulate; changed so that all occurrences of f are replaced with t
[in]	f	the substring to replace with t
[in]	t	the string to replace f

Precondition

The search string f must not be empty. This precondition is enforced with an assertion.

Since

version 2.0.0

Definition at line 12138 of file json.hpp.

    {
        assert(not f.empty());
        for (auto pos = s.find(f);                // find first occurrence of f
                pos != std::string::npos;         // make sure f was found
                s.replace(pos, f.size(), t),      // replace with t, and
                pos = s.find(f, pos + t.size()))  // find next occurrence of f
        {}
    }

template<typename BasicJsonType >

static std::vector<std::string> nlohmann::json_pointer< BasicJsonType >::split ( const std::string &  reference_string )

inlinestaticprivate

split the string input to reference tokens

Note

This function is only called by the json_pointer constructor. All exceptions below are documented there.

Exceptions

parse_error.107	if the pointer is not empty or begins with '/'
parse_error.108	if character '~' is not followed by '0' or '1'

Definition at line 12063 of file json.hpp.

References nlohmann::detail::parse_error::create(), JSON_THROW, and JSON_UNLIKELY.

    {
        std::vector<std::string> result;

        // special case: empty reference string -> no reference tokens
        if (reference_string.empty())
        {
            return result;
        }

        // check if nonempty reference string begins with slash
        if (JSON_UNLIKELY(reference_string[0] != '/'))
        {
            JSON_THROW(detail::parse_error::create(107, 1,
                                                   "JSON pointer must be empty or begin with '/' - was: '" +
                                                   reference_string + "'"));
        }

        // extract the reference tokens:
        // - slash: position of the last read slash (or end of string)
        // - start: position after the previous slash
        for (
            // search for the first slash after the first character
            std::size_t slash = reference_string.find_first_of('/', 1),
            // set the beginning of the first reference token
            start = 1;
            // we can stop if start == 0 (if slash == std::string::npos)
            start != 0;
            // set the beginning of the next reference token
            // (will eventually be 0 if slash == std::string::npos)
            start = (slash == std::string::npos) ? 0 : slash + 1,
            // find next slash
            slash = reference_string.find_first_of('/', start))
        {
            // use the text between the beginning of the reference token
            // (start) and the last slash (slash).
            auto reference_token = reference_string.substr(start, slash - start);

            // check reference tokens are properly escaped
            for (std::size_t pos = reference_token.find_first_of('~');
                    pos != std::string::npos;
                    pos = reference_token.find_first_of('~', pos + 1))
            {
                assert(reference_token[pos] == '~');

                // ~ must be followed by 0 or 1
                if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
                                  (reference_token[pos + 1] != '0' and
                                   reference_token[pos + 1] != '1')))
                {
                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
                }
            }

            // finally, store the reference token
            unescape(reference_token);
            result.push_back(reference_token);
        }

        return result;
    }

template<typename BasicJsonType >

std::string nlohmann::json_pointer< BasicJsonType >::to_string ( ) const

inline

return a string representation of the JSON pointer

Invariant

For each JSON pointer ptr, it holds:

ptr == json_pointer(ptr.to_string());

Returns

a string representation of the JSON pointer

{The example shows the result of to_string., json_pointer__to_string}

Since

version 2.0.0

Definition at line 11642 of file json.hpp.

References nlohmann::detail::string.

    {
        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
                               std::string{},
                               [](const std::string & a, const std::string & b)
        {
            return a + "/" + escape(b);
        });
    }

template<typename BasicJsonType >

json_pointer nlohmann::json_pointer< BasicJsonType >::top ( ) const

inlineprivate

Definition at line 11702 of file json.hpp.

References nlohmann::detail::out_of_range::create(), JSON_THROW, JSON_UNLIKELY, and nlohmann::json_pointer< BasicJsonType >::reference_tokens.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch().

    {
        if (JSON_UNLIKELY(is_root()))
        {
            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
        }

        json_pointer result = *this;
        result.reference_tokens = {reference_tokens[0]};
        return result;
    }

template<typename BasicJsonType >

static void nlohmann::json_pointer< BasicJsonType >::unescape ( std::string &  s )

inlinestaticprivate

unescape "~1" to tilde and "~0" to slash (order is important!)

Definition at line 12158 of file json.hpp.

    {
        replace_substring(s, "~1", "/");
        replace_substring(s, "~0", "~");
    }

template<typename BasicJsonType >

static BasicJsonType nlohmann::json_pointer< BasicJsonType >::unflatten ( const BasicJsonType &  value )

inlinestaticprivate

Parameters

[in]

value

flattened JSON

Returns

unflattened JSON

Exceptions

parse_error.109	if array index is not a number
type_error.314	if value is not an object
type_error.315	if object values are not primitive
type_error.313	if value cannot be unflattened

Definition at line 12234 of file json.hpp.

References nlohmann::detail::type_error::create(), nlohmann::json_pointer< BasicJsonType >::get_and_create(), JSON_THROW, and JSON_UNLIKELY.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::unflatten().

    {
        if (JSON_UNLIKELY(not value.is_object()))
        {
            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
        }

        BasicJsonType result;

        // iterate the JSON object values
        for (const auto& element : *value.m_value.object)
        {
            if (JSON_UNLIKELY(not element.second.is_primitive()))
            {
                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
            }

            // assign value to reference pointed to by JSON pointer; Note that if
            // the JSON pointer is "" (i.e., points to the whole value), function
            // get_and_create returns a reference to result itself. An assignment
            // will then create a primitive value.
            json_pointer(element.first).get_and_create(result) = element.second;
        }

        return result;
    }

Friends And Related Function Documentation

template<typename BasicJsonType >

template<template< typename, typename, typename... > class ObjectType, template< typename, typename... > class ArrayType, class StringType , class BooleanType , class NumberIntegerType , class NumberUnsignedType , class NumberFloatType , template< typename > class AllocatorType, template< typename, typename=void > class JSONSerializer>

friend class basic_json

friend

Definition at line 11599 of file json.hpp.

template<typename BasicJsonType >

bool operator!= ( json_pointer< BasicJsonType > const &  lhs, json_pointer< BasicJsonType > const &  rhs  )

friend

Definition at line 12267 of file json.hpp.

    {
        return not (lhs == rhs);
    }

template<typename BasicJsonType >

bool operator== ( json_pointer< BasicJsonType > const &  lhs, json_pointer< BasicJsonType > const &  rhs  )

friend

Definition at line 12261 of file json.hpp.

    {
        return (lhs.reference_tokens == rhs.reference_tokens);
    }

Member Data Documentation

template<typename BasicJsonType >

std::vector<std::string> nlohmann::json_pointer< BasicJsonType >::reference_tokens

private

the reference tokens

Definition at line 12274 of file json.hpp.

Referenced by nlohmann::json_pointer< BasicJsonType >::top().

---

The documentation for this class was generated from the following file:

• src/3party/JSON/json.hpp