Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/Utf16String.h

197 lines
4.6 KiB
C
Raw Normal View History

LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
/*
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
* Copyright (c) 2021-2023, Tim Flynn <trflynn89@serenityos.org>
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
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 17:49:34 +03:30
#include <AK/ByteString.h>
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
#include <AK/NonnullRefPtr.h>
#include <AK/RefCounted.h>
#include <AK/Types.h>
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
#include <AK/Utf16View.h>
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
#include <AK/Vector.h>
AK+Everywhere: Make UTF-16 to UTF-8 converter fallible This could fail to allocate the underlying storage needed to store the UTF-8 data. Propagate this error.
2023-01-07 13:59:10 -05:00
#include <LibJS/Runtime/Completion.h>
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
namespace JS {
namespace Detail {
class Utf16StringImpl : public RefCounted<Utf16StringImpl> {
public:
~Utf16StringImpl() = default;
LibJS: Make Utf16String & related APIs infallible Work towards #20449.
2023-08-08 18:54:20 +02:00
[[nodiscard]] static NonnullRefPtr<Utf16StringImpl> create();
[[nodiscard]] static NonnullRefPtr<Utf16StringImpl> create(Utf16Data);
[[nodiscard]] static NonnullRefPtr<Utf16StringImpl> create(StringView);
[[nodiscard]] static NonnullRefPtr<Utf16StringImpl> create(Utf16View const&);
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
Utf16Data const& string() const;
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
Utf16View view() const;
LibJS: Cache UTF-16 strings on the VM We were already caching UTF-8 and byte strings, so let's add a cache for UTF-16 strings as well. This is particularly profitable whenever we run regular expressions, since the output of regex execution is a set of UTF-16 strings. Note that this is a weak cache like the other JS string caches, meaning that strings are removed from the cache as they are garbage collected. This avoids billions of PrimitiveString allocations across a run of WPT, significantly reducing GC activity.
2024-10-24 23:02:10 +02:00
[[nodiscard]] u32 hash() const
{
if (!m_has_hash) {
m_hash = compute_hash();
m_has_hash = true;
}
return m_hash;
}
[[nodiscard]] bool operator==(Utf16StringImpl const& other) const { return string() == other.string(); }
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
private:
Utf16StringImpl() = default;
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
explicit Utf16StringImpl(Utf16Data string);
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
LibJS: Cache UTF-16 strings on the VM We were already caching UTF-8 and byte strings, so let's add a cache for UTF-16 strings as well. This is particularly profitable whenever we run regular expressions, since the output of regex execution is a set of UTF-16 strings. Note that this is a weak cache like the other JS string caches, meaning that strings are removed from the cache as they are garbage collected. This avoids billions of PrimitiveString allocations across a run of WPT, significantly reducing GC activity.
2024-10-24 23:02:10 +02:00
[[nodiscard]] u32 compute_hash() const;
mutable bool m_has_hash { false };
mutable u32 m_hash { 0 };
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
Utf16Data m_string;
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
};
}
class Utf16String {
public:
LibJS: Make Utf16String & related APIs infallible Work towards #20449.
2023-08-08 18:54:20 +02:00
[[nodiscard]] static Utf16String create();
[[nodiscard]] static Utf16String create(Utf16Data);
[[nodiscard]] static Utf16String create(StringView);
[[nodiscard]] static Utf16String create(Utf16View const&);
LibJS: Make Optional<Utf16String> use less space By specializing the template, we can shrink it from 16 to 8 bytes. This makes PrimitiveString a measly 32 bytes. :^)
2025-03-30 00:27:45 +00:00
[[nodiscard]] static Utf16String invalid();
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
AK+LibJS+LibRegex: Define an alias for UTF-16 string data storage Instead of writing out "Vector<u16, 1>" everywhere, let's have a name for it.
2023-01-06 11:00:24 -05:00
Utf16Data const& string() const;
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
Utf16View view() const;
Utf16View substring_view(size_t code_unit_offset, size_t code_unit_length) const;
Utf16View substring_view(size_t code_unit_offset) const;
LibJS: Make Utf16String & related APIs infallible Work towards #20449.
2023-08-08 18:54:20 +02:00
[[nodiscard]] String to_utf8() const;
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 17:49:34 +03:30
[[nodiscard]] ByteString to_byte_string() const;
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
u16 code_unit_at(size_t index) const;
size_t length_in_code_units() const;
bool is_empty() const;
LibJS: Make Optional<Utf16String> use less space By specializing the template, we can shrink it from 16 to 8 bytes. This makes PrimitiveString a measly 32 bytes. :^)
2025-03-30 00:27:45 +00:00
bool is_valid() const { return m_string; }
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
LibJS: Cache UTF-16 strings on the VM We were already caching UTF-8 and byte strings, so let's add a cache for UTF-16 strings as well. This is particularly profitable whenever we run regular expressions, since the output of regex execution is a set of UTF-16 strings. Note that this is a weak cache like the other JS string caches, meaning that strings are removed from the cache as they are garbage collected. This avoids billions of PrimitiveString allocations across a run of WPT, significantly reducing GC activity.
2024-10-24 23:02:10 +02:00
[[nodiscard]] u32 hash() const { return m_string->hash(); }
[[nodiscard]] bool operator==(Utf16String const& other) const
{
if (m_string == other.m_string)
return true;
return *m_string == *other.m_string;
}
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
private:
LibJS: Make Optional<Utf16String> use less space By specializing the template, we can shrink it from 16 to 8 bytes. This makes PrimitiveString a measly 32 bytes. :^)
2025-03-30 00:27:45 +00:00
Utf16String() = default;
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
explicit Utf16String(NonnullRefPtr<Detail::Utf16StringImpl>);
LibJS: Make Optional<Utf16String> use less space By specializing the template, we can shrink it from 16 to 8 bytes. This makes PrimitiveString a measly 32 bytes. :^)
2025-03-30 00:27:45 +00:00
RefPtr<Detail::Utf16StringImpl> m_string;
LibJS: Add a simple reference-counted UTF-16 string To help alleviate memory usage when creating and copying large strings, create a simple wrapper around a Vector<u16> to reference count UTF-16 strings.
2021-08-09 08:58:31 -04:00
};
}
LibJS: Cache UTF-16 strings on the VM We were already caching UTF-8 and byte strings, so let's add a cache for UTF-16 strings as well. This is particularly profitable whenever we run regular expressions, since the output of regex execution is a set of UTF-16 strings. Note that this is a weak cache like the other JS string caches, meaning that strings are removed from the cache as they are garbage collected. This avoids billions of PrimitiveString allocations across a run of WPT, significantly reducing GC activity.
2024-10-24 23:02:10 +02:00
namespace AK {
template<>
struct Traits<JS::Utf16String> : public DefaultTraits<JS::Utf16String> {
static unsigned hash(JS::Utf16String const& s) { return s.hash(); }
};
LibJS: Make Optional<Utf16String> use less space By specializing the template, we can shrink it from 16 to 8 bytes. This makes PrimitiveString a measly 32 bytes. :^)
2025-03-30 00:27:45 +00:00
template<>
class Optional<JS::Utf16String> : public OptionalBase<JS::Utf16String> {
template<typename U>
friend class Optional;
public:
using ValueType = JS::Utf16String;
Optional() = default;
template<SameAs<OptionalNone> V>
Optional(V) { }
Optional(Optional<JS::Utf16String> const& other)
{
if (other.has_value())
m_value = other.m_value;
}
Optional(Optional&& other)
: m_value(other.m_value)
{
}
template<typename U = JS::Utf16String>
requires(!IsSame<OptionalNone, RemoveCVReference<U>>)
explicit(!IsConvertible<U&&, JS::Utf16String>) Optional(U&& value)
requires(!IsSame<RemoveCVReference<U>, Optional<JS::Utf16String>> && IsConstructible<JS::Utf16String, U &&>)
: m_value(forward<U>(value))
{
}
template<SameAs<OptionalNone> V>
Optional& operator=(V)
{
clear();
return *this;
}
Optional& operator=(Optional const& other)
{
if (this != &other) {
clear();
m_value = other.m_value;
}
return *this;
}
Optional& operator=(Optional&& other)
{
if (this != &other) {
clear();
m_value = other.m_value;
}
return *this;
}
void clear()
{
m_value = JS::Utf16String::invalid();
}
[[nodiscard]] bool has_value() const
{
return m_value.is_valid();
}
[[nodiscard]] JS::Utf16String& value() &
{
VERIFY(has_value());
return m_value;
}
[[nodiscard]] JS::Utf16String const& value() const&
{
VERIFY(has_value());
return m_value;
}
[[nodiscard]] JS::Utf16String value() &&
{
return release_value();
}
[[nodiscard]] JS::Utf16String release_value()
{
VERIFY(has_value());
JS::Utf16String released_value = m_value;
clear();
return released_value;
}
private:
JS::Utf16String m_value { JS::Utf16String::invalid() };
};
LibJS: Cache UTF-16 strings on the VM We were already caching UTF-8 and byte strings, so let's add a cache for UTF-16 strings as well. This is particularly profitable whenever we run regular expressions, since the output of regex execution is a set of UTF-16 strings. Note that this is a weak cache like the other JS string caches, meaning that strings are removed from the cache as they are garbage collected. This avoids billions of PrimitiveString allocations across a run of WPT, significantly reducing GC activity.
2024-10-24 23:02:10 +02:00
}
Reference in a new issue Copy permalink