Lines Matching refs:m_value
4337 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
4339 if (¤t->m_parent->m_value.array->operator[](i) == current)
4350 for (const auto& element : *current->m_parent->m_value.object)
5343 * j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an
5356 j.m_value.destroy(j.m_type);
5358 j.m_value = b;
5369 j.m_value.destroy(j.m_type);
5371 j.m_value = s;
5378 j.m_value.destroy(j.m_type);
5380 j.m_value = std::move(s);
5389 j.m_value.destroy(j.m_type);
5391 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
5402 j.m_value.destroy(j.m_type);
5404 j.m_value = typename BasicJsonType::binary_t(b);
5411 j.m_value.destroy(j.m_type);
5413 j.m_value = typename BasicJsonType::binary_t(std::move(b));
5424 j.m_value.destroy(j.m_type);
5426 j.m_value = val;
5437 j.m_value.destroy(j.m_type);
5439 j.m_value = val;
5450 j.m_value.destroy(j.m_type);
5452 j.m_value = val;
5463 j.m_value.destroy(j.m_type);
5465 j.m_value = arr;
5473 j.m_value.destroy(j.m_type);
5475 j.m_value = std::move(arr);
5488 j.m_value.destroy(j.m_type);
5490 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
5498 j.m_value.destroy(j.m_type);
5500 j.m_value = value_t::array;
5501 j.m_value.array->reserve(arr.size());
5504 j.m_value.array->push_back(x);
5505 j.set_parent(j.m_value.array->back());
5514 j.m_value.destroy(j.m_type);
5516 j.m_value = value_t::array;
5517 j.m_value.array->resize(arr.size());
5520 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
5533 j.m_value.destroy(j.m_type);
5535 j.m_value = obj;
5543 j.m_value.destroy(j.m_type);
5545 j.m_value = std::move(obj);
5557 j.m_value.destroy(j.m_type);
5559 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
6815 object_element = &(ref_stack.back()->m_value.object->operator[](val));
6890 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6891 return &(ref_stack.back()->m_value.array->back());
7010 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
7095 ref_stack.back()->m_value.array->pop_back();
7178 ref_stack.back()->m_value.array->emplace_back(std::move(value));
7179 return {true, &(ref_stack.back()->m_value.array->back())};
12991 m_it.object_iterator = m_object->m_value.object->begin();
12997 m_it.array_iterator = m_object->m_value.array->begin();
13035 m_it.object_iterator = m_object->m_value.object->end();
13041 m_it.array_iterator = m_object->m_value.array->end();
13074 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
13080 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
13118 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
13124 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
14070 ptr = &ptr->operator[](ptr->m_value.array->size());
14122 "array index '-' (", std::to_string(ptr->m_value.array->size()),
14179 JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_value.array->size()), ") is out of range"), ptr));
14229 "array index '-' (", std::to_string(ptr->m_value.array->size()),
14424 if (value.m_value.array->empty())
14432 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
14435 value.m_value.array->operator[](i), result);
14443 if (value.m_value.object->empty())
14451 for (const auto& element : *value.m_value.object)
14498 for (const auto& element : *value.m_value.object)
14981 write_bson_object(*j.m_value.object);
15016 oa->write_character(j.m_value.boolean
15024 if (j.m_value.number_integer >= 0)
15029 if (j.m_value.number_integer <= 0x17)
15031 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15033 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
15036 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15038 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
15041 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15043 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
15046 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15051 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15058 const auto positive_number = -1 - j.m_value.number_integer;
15059 if (j.m_value.number_integer >= -24)
15089 if (j.m_value.number_unsigned <= 0x17)
15091 write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
15093 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15096 write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
15098 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15101 write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
15103 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15106 write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
15111 write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
15118 if (std::isnan(j.m_value.number_float))
15125 else if (std::isinf(j.m_value.number_float))
15129 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
15134 write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
15142 const auto N = j.m_value.string->size();
15172 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15173 j.m_value.string->size());
15180 const auto N = j.m_value.array->size();
15209 for (const auto& el : *j.m_value.array)
15218 if (j.m_value.binary->has_subtype())
15220 if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
15223 write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
15225 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
15228 write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
15230 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
15233 write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
15235 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
15238 write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
15243 const auto N = j.m_value.binary->size();
15273 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15282 const auto N = j.m_value.object->size();
15311 for (const auto& el : *j.m_value.object)
15340 oa->write_character(j.m_value.boolean
15348 if (j.m_value.number_integer >= 0)
15353 if (j.m_value.number_unsigned < 128)
15356 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15358 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15362 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15364 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15368 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15370 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15374 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15376 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15380 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15385 if (j.m_value.number_integer >= -32)
15388 write_number(static_cast<std::int8_t>(j.m_value.number_integer));
15390 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
15391 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
15395 write_number(static_cast<std::int8_t>(j.m_value.number_integer));
15397 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
15398 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
15402 write_number(static_cast<std::int16_t>(j.m_value.number_integer));
15404 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
15405 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
15409 write_number(static_cast<std::int32_t>(j.m_value.number_integer));
15411 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
15412 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
15416 write_number(static_cast<std::int64_t>(j.m_value.number_integer));
15424 if (j.m_value.number_unsigned < 128)
15427 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15429 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15433 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15435 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15439 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15441 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15445 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15447 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15451 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15458 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
15465 const auto N = j.m_value.string->size();
15492 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15493 j.m_value.string->size());
15500 const auto N = j.m_value.array->size();
15520 for (const auto& el : *j.m_value.array)
15531 const bool use_ext = j.m_value.binary->has_subtype();
15534 const auto N = j.m_value.binary->size();
15599 write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
15604 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15613 const auto N = j.m_value.object->size();
15633 for (const auto& el : *j.m_value.object)
15673 oa->write_character(j.m_value.boolean
15682 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix, use_bjdata);
15688 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix, use_bjdata);
15694 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix, use_bjdata);
15704 write_number_with_ubjson_prefix(j.m_value.string->size(), true, use_bjdata);
15706 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15707 j.m_value.string->size());
15719 if (use_type && !j.m_value.array->empty())
15742 write_number_with_ubjson_prefix(j.m_value.array->size(), true, use_bjdata);
15745 for (const auto& el : *j.m_value.array)
15765 if (use_type && !j.m_value.binary->empty())
15775 write_number_with_ubjson_prefix(j.m_value.binary->size(), true, use_bjdata);
15781 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15782 j.m_value.binary->size());
15786 for (size_t i = 0; i < j.m_value.binary->size(); ++i)
15789 oa->write_character(j.m_value.binary->data()[i]);
15803 if (use_bjdata && j.m_value.object->size() == 3 && j.m_value.object->find("_ArrayType_") != j.m_value.object->end() && j.m_value.object->find("_ArraySize_") != j.m_value.object->end() && j.m_value.object->find("_ArrayData_") != j.m_value.object->end())
15805 if (!write_bjdata_ndarray(*j.m_value.object, use_count, use_type)) // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
15817 if (use_type && !j.m_value.object->empty())
15840 write_number_with_ubjson_prefix(j.m_value.object->size(), true, use_bjdata);
15843 for (const auto& el : *j.m_value.object)
15993 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
15996 write_number<std::int32_t>(static_cast<std::int32_t>(j.m_value.number_unsigned), true);
15998 else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16001 write_number<std::int64_t>(static_cast<std::int64_t>(j.m_value.number_unsigned), true);
16005 JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
16086 return header_size + calc_bson_object_size(*j.m_value.object);
16089 return header_size + calc_bson_array_size(*j.m_value.array);
16092 return header_size + calc_bson_binary_size(*j.m_value.binary);
16101 return header_size + calc_bson_integer_size(j.m_value.number_integer);
16104 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
16107 return header_size + calc_bson_string_size(*j.m_value.string);
16133 return write_bson_object_entry(name, *j.m_value.object);
16136 return write_bson_array(name, *j.m_value.array);
16139 return write_bson_binary(name, *j.m_value.binary);
16142 return write_bson_boolean(name, j.m_value.boolean);
16145 return write_bson_double(name, j.m_value.number_float);
16148 return write_bson_integer(name, j.m_value.number_integer);
16154 return write_bson_string(name, *j.m_value.string);
16427 return j.m_value.boolean ? 'T' : 'F';
16431 if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
16435 if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
16439 if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
16443 if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
16447 if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
16451 if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
16455 if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
16465 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
16469 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
16473 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
16477 if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
16481 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16485 if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
16489 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16493 if (use_bjdata && j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
16502 return get_ubjson_float_prefix(j.m_value.number_float);
16551 len *= static_cast<std::size_t>(el.m_value.number_unsigned);
16573 write_number(static_cast<std::uint8_t>(el.m_value.number_unsigned), true);
16580 write_number(static_cast<std::int8_t>(el.m_value.number_integer), true);
16587 write_number(static_cast<std::uint16_t>(el.m_value.number_unsigned), true);
16594 write_number(static_cast<std::int16_t>(el.m_value.number_integer), true);
16601 write_number(static_cast<std::uint32_t>(el.m_value.number_unsigned), true);
16608 write_number(static_cast<std::int32_t>(el.m_value.number_integer), true);
16615 write_number(static_cast<std::uint64_t>(el.m_value.number_unsigned), true);
16622 write_number(static_cast<std::int64_t>(el.m_value.number_integer), true);
16629 write_number(static_cast<float>(el.m_value.number_float), true);
16636 write_number(static_cast<double>(el.m_value.number_float), true);
18001 if (val.m_value.object->empty())
18019 auto i = val.m_value.object->cbegin();
18020 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
18031 JSON_ASSERT(i != val.m_value.object->cend());
18032 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
18048 auto i = val.m_value.object->cbegin();
18049 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
18059 JSON_ASSERT(i != val.m_value.object->cend());
18060 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
18074 if (val.m_value.array->empty())
18092 for (auto i = val.m_value.array->cbegin();
18093 i != val.m_value.array->cend() - 1; ++i)
18101 JSON_ASSERT(!val.m_value.array->empty());
18103 dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
18114 for (auto i = val.m_value.array->cbegin();
18115 i != val.m_value.array->cend() - 1; ++i)
18122 JSON_ASSERT(!val.m_value.array->empty());
18123 dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
18134 dump_escaped(*val.m_value.string, ensure_ascii);
18156 if (!val.m_value.binary->empty())
18158 for (auto i = val.m_value.binary->cbegin();
18159 i != val.m_value.binary->cend() - 1; ++i)
18164 dump_integer(val.m_value.binary->back());
18171 if (val.m_value.binary->has_subtype())
18173 dump_integer(val.m_value.binary->subtype());
18187 if (!val.m_value.binary->empty())
18189 for (auto i = val.m_value.binary->cbegin();
18190 i != val.m_value.binary->cend() - 1; ++i)
18195 dump_integer(val.m_value.binary->back());
18199 if (val.m_value.binary->has_subtype())
18201 dump_integer(val.m_value.binary->subtype());
18214 if (val.m_value.boolean)
18227 dump_integer(val.m_value.number_integer);
18233 dump_integer(val.m_value.number_unsigned);
18239 dump_float(val.m_value.number_float);
19258 @invariant The member variables @a m_value and @a m_type have the following
19260 - If `m_type == value_t::object`, then `m_value.object != nullptr`.
19261 - If `m_type == value_t::array`, then `m_value.array != nullptr`.
19262 - If `m_type == value_t::string`, then `m_value.string != nullptr`.
19764 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
19766 current_item.m_value.array->clear();
19770 for (auto&& it : *current_item.m_value.object)
19775 current_item.m_value.object->clear();
19839 @a m_type and @a m_value.
19852 JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
19853 JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
19854 JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
19855 JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
19878 for (auto& element : *m_value.array)
19887 for (auto& element : *m_value.object)
19928 if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
19984 : m_type(v), m_value(v)
20102 m_value = value_t::object;
20107 m_value.object->emplace(
20108 std::move(*((*element.m_value.array)[0].m_value.string)),
20109 std::move((*element.m_value.array)[1]));
20116 m_value.array = create<array_t>(init.begin(), init.end());
20130 res.m_value = init;
20141 res.m_value = binary_t(init, subtype);
20152 res.m_value = std::move(init);
20163 res.m_value = binary_t(std::move(init), subtype);
20188 m_value.array = create<array_t>(cnt, val);
20242 m_value.number_integer = first.m_object->m_value.number_integer;
20248 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
20254 m_value.number_float = first.m_object->m_value.number_float;
20260 m_value.boolean = first.m_object->m_value.boolean;
20266 m_value = *first.m_object->m_value.string;
20272 m_value.object = create<object_t>(first.m_it.object_iterator,
20279 m_value.array = create<array_t>(first.m_it.array_iterator,
20286 m_value = *first.m_object->m_value.binary;
20322 m_value = *other.m_value.object;
20328 m_value = *other.m_value.array;
20334 m_value = *other.m_value.string;
20340 m_value = other.m_value.boolean;
20346 m_value = other.m_value.number_integer;
20352 m_value = other.m_value.number_unsigned;
20358 m_value = other.m_value.number_float;
20364 m_value = *other.m_value.binary;
20382 m_value(std::move(other.m_value))
20389 other.m_value = {};
20409 swap(m_value, other.m_value);
20421 m_value.destroy(m_type);
20574 return m_value.boolean;
20583 return is_object() ? m_value.object : nullptr;
20589 return is_object() ? m_value.object : nullptr;
20595 return is_array() ? m_value.array : nullptr;
20601 return is_array() ? m_value.array : nullptr;
20607 return is_string() ? m_value.string : nullptr;
20613 return is_string() ? m_value.string : nullptr;
20619 return is_boolean() ? &m_value.boolean : nullptr;
20625 return is_boolean() ? &m_value.boolean : nullptr;
20631 return is_number_integer() ? &m_value.number_integer : nullptr;
20637 return is_number_integer() ? &m_value.number_integer : nullptr;
20643 return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
20649 return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
20655 return is_number_float() ? &m_value.number_float : nullptr;
20661 return is_number_float() ? &m_value.number_float : nullptr;
20667 return is_binary() ? m_value.binary : nullptr;
20673 return is_binary() ? m_value.binary : nullptr;
21111 return set_parent(m_value.array->at(idx));
21134 return m_value.array->at(idx);
21158 auto it = m_value.object->find(key);
21159 if (it == m_value.object->end())
21178 auto it = m_value.object->find(std::forward<KeyType>(key));
21179 if (it == m_value.object->end())
21196 auto it = m_value.object->find(key);
21197 if (it == m_value.object->end())
21216 auto it = m_value.object->find(std::forward<KeyType>(key));
21217 if (it == m_value.object->end())
21232 m_value.array = create<array_t>();
21240 if (idx >= m_value.array->size())
21244 const auto old_size = m_value.array->size();
21245 const auto old_capacity = m_value.array->capacity();
21247 m_value.array->resize(idx + 1);
21250 if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
21264 return m_value.array->operator[](idx);
21277 return m_value.array->operator[](idx);
21291 m_value.object = create<object_t>();
21298 auto result = m_value.object->emplace(std::move(key), nullptr);
21312 auto it = m_value.object->find(key);
21313 JSON_ASSERT(it != m_value.object->end());
21344 m_value.object = create<object_t>();
21351 auto result = m_value.object->emplace(std::forward<KeyType>(key), nullptr);
21367 auto it = m_value.object->find(std::forward<KeyType>(key));
21368 JSON_ASSERT(it != m_value.object->end());
21622 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
21623 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
21624 m_value.string = nullptr;
21629 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
21630 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
21631 m_value.binary = nullptr;
21641 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
21647 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
21693 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
21694 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
21695 m_value.string = nullptr;
21700 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
21701 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
21702 m_value.binary = nullptr;
21712 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
21719 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
21744 return m_value.object->erase(std::forward<KeyType>(key));
21757 const auto it = m_value.object->find(std::forward<KeyType>(key));
21758 if (it != m_value.object->end())
21760 m_value.object->erase(it);
21798 m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
21824 result.m_it.object_iterator = m_value.object->find(key);
21838 result.m_it.object_iterator = m_value.object->find(key);
21854 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21870 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21881 return is_object() ? m_value.object->count(key) : 0;
21891 return is_object() ? m_value.object->count(std::forward<KeyType>(key)) : 0;
21898 return is_object() && m_value.object->find(key) != m_value.object->end();
21907 return is_object() && m_value.object->find(std::forward<KeyType>(key)) != m_value.object->end();
22088 return m_value.array->empty();
22094 return m_value.object->empty();
22127 return m_value.array->size();
22133 return m_value.object->size();
22160 return m_value.array->max_size();
22166 return m_value.object->max_size();
22203 m_value.number_integer = 0;
22209 m_value.number_unsigned = 0;
22215 m_value.number_float = 0.0;
22221 m_value.boolean = false;
22227 m_value.string->clear();
22233 m_value.binary->clear();
22239 m_value.array->clear();
22245 m_value.object->clear();
22270 m_value = value_t::array;
22275 const auto old_capacity = m_value.array->capacity();
22276 m_value.array->push_back(std::move(val));
22277 set_parent(m_value.array->back(), old_capacity);
22303 m_value = value_t::array;
22308 const auto old_capacity = m_value.array->capacity();
22309 m_value.array->push_back(val);
22310 set_parent(m_value.array->back(), old_capacity);
22335 m_value = value_t::object;
22340 auto res = m_value.object->insert(val);
22391 m_value = value_t::array;
22396 const auto old_capacity = m_value.array->capacity();
22397 m_value.array->emplace_back(std::forward<Args>(args)...);
22398 return set_parent(m_value.array->back(), old_capacity);
22416 m_value = value_t::object;
22421 auto res = m_value.object->emplace(std::forward<Args>(args)...);
22439 JSON_ASSERT(m_value.array != nullptr);
22441 auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
22442 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
22443 result.m_it.array_iterator = m_value.array->begin() + insert_pos;
22446 // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
22573 m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22591 m_value.object = create<object_t>();
22616 auto it2 = m_value.object->find(it.key());
22617 if (it2 != m_value.object->end())
22623 m_value.object->operator[](it.key()) = it.value();
22625 m_value.object->operator[](it.key()).m_parent = this;
22640 std::swap(m_value, other.m_value);
22667 swap(*(m_value.array), other);
22683 swap(*(m_value.object), other);
22699 swap(*(m_value.string), other);
22715 swap(*(m_value.binary), other);
22731 swap(*(m_value.binary), other);
22759 return (*lhs.m_value.array) op (*rhs.m_value.array); \
22762 return (*lhs.m_value.object) op (*rhs.m_value.object); \
22768 return (*lhs.m_value.string) op (*rhs.m_value.string); \
22771 return (lhs.m_value.boolean) op (rhs.m_value.boolean); \
22774 return (lhs.m_value.number_integer) op (rhs.m_value.number_integer); \
22777 return (lhs.m_value.number_unsigned) op (rhs.m_value.number_unsigned); \
22780 return (lhs.m_value.number_float) op (rhs.m_value.number_float); \
22783 return (*lhs.m_value.binary) op (*rhs.m_value.binary); \
22792 return static_cast<number_float_t>(lhs.m_value.number_integer) op rhs.m_value.number_float; \
22796 return lhs.m_value.number_float op static_cast<number_float_t>(rhs.m_value.number_integer); \
22800 return static_cast<number_float_t>(lhs.m_value.number_unsigned) op rhs.m_value.number_float; \
22804 return lhs.m_value.number_float op static_cast<number_float_t>(rhs.m_value.number_unsigned); \
22808 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) op rhs.m_value.number_integer; \
22812 return lhs.m_value.number_integer op static_cast<number_integer_t>(rhs.m_value.number_unsigned); \
22829 if ((lhs.is_number_float() && std::isnan(lhs.m_value.number_float) && rhs.is_number())
22830 || (rhs.is_number_float() && std::isnan(rhs.m_value.number_float) && lhs.is_number()))
23365 json_value m_value = {};
23994 auto it = val.m_value.object->find(member);
24000 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))