mirror of
https://github.com/nlohmann/json.git
synced 2026-08-28 20:07:32 +00:00
Niels Lohmann
ccb290facf
Several members were required only because of how the library happened to be written, not because the functionality needs them. Dropping them widens the set of usable string and array types, and one of them was also a performance problem. string_t: - c_str() is gone. Every call site already knew the length and passed it along, so data() is enough. The one place that did not, the diagnostics path in exceptions.hpp, now builds the token from data() and size(), which also stops it from truncating keys that contain a null byte. - back() is gone; the serializer indexes the last character instead. - find(str, pos), replace(), and substr() are gone. escape() and unescape() rebuilt the string with one replace() per escaped character, which moves the tail every time: escaping a string of n characters that all need escaping cost O(n^2). Both now scan with find_first_of() -- a member the pointer parser already required -- and append whole runs, so the common case is one search and one copy. Escaping 64000 tildes drops from 717 ms to 20 ms; a string with nothing to escape gets faster too (8.4 ms to 5.8 ms), because the scan is still a single memchr per pass. json_pointer::split() takes its reference tokens with the (const char*, size_type) constructor rather than substr(). - json_pointer::to_string() accumulates with concat<string_t> instead of letting concat default to std::string and converting afterwards, so streaming a json_pointer no longer requires string_t to be assignable from a std::string. array_t: - at(size_type) is gone. basic_json::at(size_type) checked the index by calling array_t::at() and translating std::out_of_range, which also required the array type to throw that exact exception. It now compares against size() and uses operator[]. The thrown exception, its message, and the behaviour under JSON_NOEXCEPTION are unchanged. The BSON writer wrote the terminating null byte out of the string's own buffer (size() + 1). It now writes the byte itself, so string_t::data() need not be null-terminated for to_bson(). The tests pin the reduced API: alt_string loses the five dropped members and gains coverage of the escaping paths, and a std::vector whose at() is hidden is used as an ArrayType. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
110 lines
2.9 KiB
C++
110 lines
2.9 KiB
C++
// __ _____ _____ _____
|
|
// __| | __| | | | JSON for Modern C++
|
|
// | | |__ | | | | | | version 3.12.0
|
|
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
|
//
|
|
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#pragma once
|
|
|
|
#include <cstddef> // size_t
|
|
|
|
#include <nlohmann/detail/abi_macros.hpp>
|
|
|
|
NLOHMANN_JSON_NAMESPACE_BEGIN
|
|
namespace detail
|
|
{
|
|
|
|
/*!
|
|
* @brief string escaping as described in RFC 6901 (Sect. 4)
|
|
* @param[in] s string to escape
|
|
* @return escaped string
|
|
*
|
|
* Note the order of escaping "~" to "~0" and "/" to "~1" is important.
|
|
*
|
|
* The string is rebuilt in a single pass, appending whole runs between the
|
|
* characters that need escaping. Scanning with find_first_of() keeps the
|
|
* common case -- nothing to escape -- as fast as a single search, while
|
|
* repeated replace() calls would move the tail of the string once per
|
|
* escaped character.
|
|
*/
|
|
template<typename StringType>
|
|
inline StringType escape(const StringType& s)
|
|
{
|
|
auto next_special = [&s](std::size_t from)
|
|
{
|
|
const auto tilde = s.find_first_of('~', from);
|
|
const auto slash = s.find_first_of('/', from);
|
|
return tilde < slash ? tilde : slash; // npos is the largest value
|
|
};
|
|
|
|
auto pos = next_special(0);
|
|
if (pos == StringType::npos)
|
|
{
|
|
return s;
|
|
}
|
|
|
|
StringType result;
|
|
result.reserve(s.size() + 2);
|
|
|
|
std::size_t run = 0;
|
|
while (pos != StringType::npos)
|
|
{
|
|
result.append(s.data() + run, pos - run);
|
|
result.append(s[pos] == '~' ? "~0" : "~1", 2);
|
|
run = pos + 1;
|
|
pos = next_special(run);
|
|
}
|
|
result.append(s.data() + run, s.size() - run);
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
* @brief string unescaping as described in RFC 6901 (Sect. 4)
|
|
* @param[in] s string to unescape
|
|
* @return unescaped string
|
|
*
|
|
* Note the order of escaping "~1" to "/" and "~0" to "~" is important.
|
|
*
|
|
* Rebuilt in a single pass, see @ref escape. A "~" that is followed by
|
|
* neither "0" nor "1" is passed through unchanged; @ref json_pointer rejects
|
|
* such input before it gets here.
|
|
*/
|
|
template<typename StringType>
|
|
inline void unescape(StringType& s)
|
|
{
|
|
auto pos = s.find_first_of('~', 0);
|
|
if (pos == StringType::npos)
|
|
{
|
|
return;
|
|
}
|
|
|
|
StringType result;
|
|
result.reserve(s.size());
|
|
|
|
std::size_t run = 0;
|
|
while (pos != StringType::npos)
|
|
{
|
|
result.append(s.data() + run, pos - run);
|
|
|
|
const auto next = pos + 1;
|
|
if (next < s.size() && (s[next] == '0' || s[next] == '1'))
|
|
{
|
|
result.append(s[next] == '0' ? "~" : "/", 1);
|
|
run = pos + 2;
|
|
}
|
|
else
|
|
{
|
|
result.append("~", 1);
|
|
run = pos + 1;
|
|
}
|
|
pos = s.find_first_of('~', run);
|
|
}
|
|
result.append(s.data() + run, s.size() - run);
|
|
s = result;
|
|
}
|
|
|
|
} // namespace detail
|
|
NLOHMANN_JSON_NAMESPACE_END
|