contains()

template<typename BasicJsonType >

bool nlohmann::json_pointer< BasicJsonType >::contains ( 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

Definition at line 13245 of file json.hpp.

    {
        for (const auto &reference_token : reference_tokens)
        {
            switch (ptr->type())
            {
                case detail::value_t::object:
                {
                    if (!ptr->contains(reference_token))
                    {
                        // we did not find the key in the object
                        return false;
                    }
 
                    ptr = &ptr->operator[](reference_token);
                    break;
                }
 
                case detail::value_t::array:
                {
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
                        return false;
                    }
 
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
                    {
                        // invalid char
                        return false;
                    }
 
                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
                    {
                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
                        {
                            // first char should be between '1' and '9'
                            return false;
                        }
 
                        for (std::size_t i = 1; i < reference_token.size(); i++)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
                            {
                                // other char should be between '0' and '9'
                                return false;
                            }
                        }
                    }
 
                    const auto idx = array_index(reference_token);
 
                    if (idx >= ptr->size())
                    {
                        // index out of range
                        return false;
                    }
 
                    ptr = &ptr->operator[](idx);
                    break;
                }
 
                case detail::value_t::null:
                case detail::value_t::string:
                case detail::value_t::boolean:
                case detail::value_t::number_integer:
                case detail::value_t::number_unsigned:
                case detail::value_t::number_float:
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
                {
                    // we do not expect primitive values if there is still a
                    // reference token to process
                    return false;
                }
            }
        }
 
        // no reference token left means we found a primitive value
        return true;
    }