beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/AK/JsonObjectSerializer.h

268 lines
7.2 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
Meta: Claim copyright for files created by me This changes copyright holder to myself for the source code files that I've created or have (almost) completely rewritten. Not included are the files that were significantly changed by others even though it was me who originally created them (think HtmlView), or the many other files I've contributed code to.
2020-01-24 13:45:29 +00:00
* Copyright (c) 2019-2020, Sergey Bugaev <bugaevc@serenityos.org>
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
* Copyright (c) 2022, Idan Horowitz <idan.horowitz@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
#pragma once
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
#include <AK/Error.h>
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
#include <AK/JsonArraySerializer.h>
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
#include <AK/Try.h>
Kernel: Don't compile JsonValue & friends into the kernel
2021-06-30 09:31:12 +00:00
#ifndef KERNEL
# include <AK/JsonValue.h>
#endif
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
namespace AK {
template<typename Builder>
class JsonObjectSerializer {
public:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
static ErrorOr<JsonObjectSerializer> try_create(Builder& builder)
{
if constexpr (IsLegacyBuilder<Builder>)
TRY(builder.try_append('{'));
else
TRY(builder.append('{'));
return JsonObjectSerializer { builder };
}
JsonObjectSerializer(JsonObjectSerializer&& other)
: m_builder(other.m_builder)
, m_empty(other.m_empty)
, m_finished(exchange(other.m_finished, true))
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
JsonObjectSerializer(JsonObjectSerializer const&) = delete;
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
Kernel: Don't compile JsonValue & friends into the kernel
2021-06-30 09:31:12 +00:00
#ifndef KERNEL
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> add(StringView key, JsonValue const& value)
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
value.serialize(m_builder);
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
return {};
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
Kernel: Don't compile JsonValue & friends into the kernel
2021-06-30 09:31:12 +00:00
#endif
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, StringView value)
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>) {
TRY(m_builder.try_append('"'));
TRY(m_builder.try_append_escaped_for_json(value));
TRY(m_builder.try_append('"'));
} else {
TRY(m_builder.append('"'));
TRY(m_builder.append_escaped_for_json(value));
TRY(m_builder.append('"'));
}
return {};
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
#ifndef KERNEL
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 14:19:34 +00:00
ErrorOr<void> add(StringView key, ByteString const& value)
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>) {
TRY(m_builder.try_append('"'));
TRY(m_builder.try_append_escaped_for_json(value));
TRY(m_builder.try_append('"'));
} else {
TRY(m_builder.append('"'));
TRY(m_builder.append_escaped_for_json(value));
TRY(m_builder.append('"'));
}
return {};
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
#endif
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> add(StringView key, char const* value)
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>) {
TRY(m_builder.try_append('"'));
Everywhere: Remove string.h include from AK/Traits.h and resolve fallout A lot of places were relying on AK/Traits.h to give it strnlen, memcmp, memcpy and other related declarations. In the quest to remove inclusion of LibC headers from Kernel files, deal with all the fallout of this included-everywhere header including less things.
2023-01-07 20:57:33 +00:00
TRY(m_builder.try_append_escaped_for_json({ value, __builtin_strlen(value) }));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(m_builder.try_append('"'));
} else {
TRY(m_builder.append('"'));
Everywhere: Remove string.h include from AK/Traits.h and resolve fallout A lot of places were relying on AK/Traits.h to give it strnlen, memcmp, memcpy and other related declarations. In the quest to remove inclusion of LibC headers from Kernel files, deal with all the fallout of this included-everywhere header including less things.
2023-01-07 20:57:33 +00:00
TRY(m_builder.append_escaped_for_json({ value, __builtin_strlen(value) }));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(m_builder.append('"'));
}
return {};
Json: Add serializer fast-path for string values Passing these through the generic JsonValue path was causing us to instantiate temporary JsonValues that incurred a heap allocation. This avoids that by adding specialized overloads for string types.
2019-09-04 12:39:08 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, bool value)
AK: Add JsonObjectSerializer::add(key, bool) overload Without this, bools will get implicitly converted to integers, which is usually not what we want.
2020-02-08 01:48:27 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(m_builder.try_append(value ? "true"sv : "false"sv));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
else
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(m_builder.append(value ? "true"sv : "false"sv));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
return {};
AK: Add JsonObjectSerializer::add(key, bool) overload Without this, bools will get implicitly converted to integers, which is usually not what we want.
2020-02-08 01:48:27 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, int value)
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, unsigned value)
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, long value)
AK: Make JsonValue and JsonObjectSerializer speak int/long/long long While width-oriented integer types are nicer from the programmer's perspective, we have to accept that C++ thinks in int/long/long long.
2020-05-22 11:57:23 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Make JsonValue and JsonObjectSerializer speak int/long/long long While width-oriented integer types are nicer from the programmer's perspective, we have to accept that C++ thinks in int/long/long long.
2020-05-22 11:57:23 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, long unsigned value)
AK: Make JsonValue and JsonObjectSerializer speak int/long/long long While width-oriented integer types are nicer from the programmer's perspective, we have to accept that C++ thinks in int/long/long long.
2020-05-22 11:57:23 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Make JsonValue and JsonObjectSerializer speak int/long/long long While width-oriented integer types are nicer from the programmer's perspective, we have to accept that C++ thinks in int/long/long long.
2020-05-22 11:57:23 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, long long value)
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, long long unsigned value)
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: Add some integer overloads to JsonObjectSerializer This avoids constructing a temporary JsonValue just to append an int.
2020-02-01 09:55:16 +00:00
}
Kernel: Don't compile JsonValue & friends into the kernel
2021-06-30 09:31:12 +00:00
#ifndef KERNEL
AK: Add float support for JsonValue and JsonObjectSerializer
2022-03-06 12:18:26 +00:00
ErrorOr<void> add(StringView key, float value)
{
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> add(StringView key, double value)
AK: A few JSON improvements * Add double number to object serializer * Handle negative double numbers correctly * Handle \r and \n in quoted strings independently This improves the situation when keys contain \r or \n that currently has the effect that "a\rkey" and "a\nkey" in an JSON object are the same key value.
2020-03-31 11:30:09 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_appendff("{}", value));
else
TRY(m_builder.appendff("{}", value));
return {};
AK: A few JSON improvements * Add double number to object serializer * Handle negative double numbers correctly * Handle \r and \n in quoted strings independently This improves the situation when keys contain \r or \n that currently has the effect that "a\rkey" and "a\nkey" in an JSON object are the same key value.
2020-03-31 11:30:09 +00:00
}
Kernel: Don't compile JsonValue & friends into the kernel
2021-06-30 09:31:12 +00:00
#endif
AK: A few JSON improvements * Add double number to object serializer * Handle negative double numbers correctly * Handle \r and \n in quoted strings independently This improves the situation when keys contain \r or \n that currently has the effect that "a\rkey" and "a\nkey" in an JSON object are the same key value.
2020-03-31 11:30:09 +00:00
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<JsonArraySerializer<Builder>> add_array(StringView key)
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
return JsonArraySerializer<Builder>::try_create(m_builder);
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<JsonObjectSerializer<Builder>> add_object(StringView key)
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item(key));
return JsonObjectSerializer::try_create(m_builder);
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> finish()
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!m_finished);
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
m_finished = true;
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_append('}'));
else
TRY(m_builder.append('}'));
return {};
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
private:
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
explicit JsonObjectSerializer(Builder& builder)
: m_builder(builder)
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
}
ErrorOr<void> begin_item(StringView key)
{
VERIFY(!m_finished);
if (!m_empty) {
if constexpr (IsLegacyBuilder<Builder>)
TRY(m_builder.try_append(','));
else
TRY(m_builder.append(','));
}
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
m_empty = false;
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
if constexpr (IsLegacyBuilder<Builder>) {
TRY(m_builder.try_append('"'));
TRY(m_builder.try_append_escaped_for_json(key));
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(m_builder.try_append("\":"sv));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
} else {
TRY(m_builder.append('"'));
TRY(m_builder.append_escaped_for_json(key));
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(m_builder.append("\":"sv));
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
}
return {};
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
Builder& m_builder;
bool m_empty { true };
bool m_finished { false };
};
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
// Template magic to allow for JsonObjectSerializer<>::try_create(...) - Blame CxByte
template<>
struct JsonObjectSerializer<void> {
template<typename Builder>
static ErrorOr<JsonObjectSerializer<Builder>> try_create(Builder& builder)
{
return JsonObjectSerializer<Builder>::try_create(builder);
}
};
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
template<typename Builder>
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<JsonObjectSerializer<Builder>> JsonArraySerializer<Builder>::add_object()
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
{
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
TRY(begin_item());
return JsonObjectSerializer<Builder>::try_create(m_builder);
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
}
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#if USING_AK_GLOBALLY
JSON: Add JSON serializers These are two new types that allow serializing JSON on-the-fly as it's generated, without building the whole JSON in memory first.
2019-08-27 11:12:44 +00:00
using AK::JsonObjectSerializer;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#endif
Reference in a new issue Copy permalink