erase() [3/4]

template<template< typename U, typename V, typename... Args > class ObjectType = std::map, template< typename U, typename... Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator, template< typename T, typename SFINAE=void > class JSONSerializer = adl_serializer, class BinaryType = std::vector<std::uint8_t>>

template<class IteratorType , typename std::enable_if< std::is_same< IteratorType, typename basic_json_t::iterator >::value||std::is_same< IteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>

IteratorType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType >::erase ( IteratorType  first, IteratorType  last  )

inline

remove elements given an iterator range

Removes the element specified by the range [first; last). The iterator first does not need to be dereferenceable if first == last: erasing an empty range is a no-op.

If called on a primitive type other than null, the resulting JSON value will be null.

Parameters

[in]	first	iterator to the beginning of the range to remove
[in]	last	iterator past the end of the range to remove

Returns

Iterator following the last removed element. If the iterator second refers to the last element, the end() iterator is returned.

Template Parameters

IteratorType

an iterator or const_iterator

Postcondition

Invalidates iterators and references at or after the point of the erase, including the end() iterator.

Exceptions

type_error.307	if called on a null value; example: "cannot use erase() with null"
invalid_iterator.203	if called on iterators which does not belong to the current JSON value; example: "iterators do not fit current value"
invalid_iterator.204	if called on a primitive type with invalid iterators (i.e., if first != begin() and last != end()); example: "iterators out of range"

@complexity The complexity depends on the type:

• objects: log(size()) + std::distance(first, last)
• arrays: linear in the distance between first and last, plus linear in the distance between last and end of the container
• strings and binary: linear in the length of the member
• other types: constant

@liveexample{The example shows the result of erase() for different JSON types.,erase__IteratorType_IteratorType}

See also

see erase(IteratorType) – removes the element at a given position

see erase(const typename object_t::key_type&) – removes the element from an object at the given key

see erase(const size_type) – removes the element from an array at the given index

Since

version 1.0.0

Definition at line 22036 of file json.hpp.

    {
        // make sure iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
        {
            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
        }
 
        IteratorType result = end();
 
        switch (m_type)
        {
            case value_t::boolean:
            case value_t::number_float:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::string:
            case value_t::binary:
            {
                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
                                       || !last.m_it.primitive_iterator.is_end()))
                {
                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
                }
 
                if (is_string())
                {
                    AllocatorType<string_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
                    m_value.string = nullptr;
                }
 
                else if (is_binary())
                {
                    AllocatorType<binary_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
                    m_value.binary = nullptr;
                }
 
                m_type = value_t::null;
                assert_invariant();
                break;
            }
 
            case value_t::object:
            {
                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
                                              last.m_it.object_iterator);
                break;
            }
 
            case value_t::array:
            {
                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
                                             last.m_it.array_iterator);
                break;
            }
 
            case value_t::null:
            case value_t::discarded:
            default:
                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
        }
 
        return result;
    }