mirror of
https://github.com/SerenityOS/serenity
synced 2024-07-01 11:39:22 +00:00
a88799c032
Before this change, the global FlyString table looked like this:
HashMap<StringView, Detail::StringBase>
After this change, we have:
HashTable<Detail::StringData const*, FlyStringTableHashTraits>
The custom hash traits are used to extract the stored hash from
StringData which avoids having to rehash the StringView repeatedly like
we did before.
This necessitated a handful of smaller changes to make it work.
125 lines
3.0 KiB
C++
125 lines
3.0 KiB
C++
/*
|
|
* Copyright (c) 2023, Dan Klishch <danilklishch@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Badge.h>
|
|
#include <AK/FlyString.h>
|
|
#include <AK/StringBase.h>
|
|
#include <AK/StringData.h>
|
|
|
|
namespace AK::Detail {
|
|
|
|
ReadonlyBytes ShortString::bytes() const
|
|
{
|
|
return { storage, byte_count() };
|
|
}
|
|
|
|
size_t ShortString::byte_count() const
|
|
{
|
|
return byte_count_and_short_string_flag >> 1;
|
|
}
|
|
|
|
StringBase::StringBase(NonnullRefPtr<Detail::StringData const> data)
|
|
: m_data(&data.leak_ref())
|
|
{
|
|
}
|
|
|
|
StringBase::StringBase(StringBase const& other)
|
|
: m_data(other.m_data)
|
|
{
|
|
if (!is_short_string())
|
|
m_data->ref();
|
|
}
|
|
|
|
StringBase& StringBase::operator=(StringBase&& other)
|
|
{
|
|
if (!is_short_string())
|
|
m_data->unref();
|
|
|
|
m_data = exchange(other.m_data, nullptr);
|
|
other.m_short_string.byte_count_and_short_string_flag = SHORT_STRING_FLAG;
|
|
return *this;
|
|
}
|
|
|
|
StringBase& StringBase::operator=(StringBase const& other)
|
|
{
|
|
if (&other != this) {
|
|
if (!is_short_string())
|
|
m_data->unref();
|
|
|
|
m_data = other.m_data;
|
|
if (!is_short_string())
|
|
m_data->ref();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
ReadonlyBytes StringBase::bytes() const
|
|
{
|
|
if (is_short_string())
|
|
return m_short_string.bytes();
|
|
return m_data->bytes();
|
|
}
|
|
|
|
u32 StringBase::hash() const
|
|
{
|
|
if (is_short_string()) {
|
|
auto bytes = this->bytes();
|
|
return string_hash(reinterpret_cast<char const*>(bytes.data()), bytes.size());
|
|
}
|
|
return m_data->hash();
|
|
}
|
|
|
|
size_t StringBase::byte_count() const
|
|
{
|
|
if (is_short_string())
|
|
return m_short_string.byte_count_and_short_string_flag >> 1;
|
|
return m_data->byte_count();
|
|
}
|
|
|
|
bool StringBase::operator==(StringBase const& other) const
|
|
{
|
|
if (is_short_string())
|
|
return m_data == other.m_data;
|
|
if (other.is_short_string())
|
|
return false;
|
|
if (m_data->is_fly_string() && other.m_data->is_fly_string())
|
|
return m_data == other.m_data;
|
|
return bytes() == other.bytes();
|
|
}
|
|
|
|
ErrorOr<Bytes> StringBase::replace_with_uninitialized_buffer(size_t byte_count)
|
|
{
|
|
if (byte_count <= MAX_SHORT_STRING_BYTE_COUNT)
|
|
return replace_with_uninitialized_short_string(byte_count);
|
|
|
|
u8* buffer = nullptr;
|
|
destroy_string();
|
|
m_data = &TRY(StringData::create_uninitialized(byte_count, buffer)).leak_ref();
|
|
return Bytes { buffer, byte_count };
|
|
}
|
|
|
|
ErrorOr<StringBase> StringBase::substring_from_byte_offset_with_shared_superstring(size_t start, size_t length) const
|
|
{
|
|
VERIFY(start + length <= byte_count());
|
|
|
|
if (length == 0)
|
|
return StringBase {};
|
|
if (length <= MAX_SHORT_STRING_BYTE_COUNT) {
|
|
StringBase result;
|
|
bytes().slice(start, length).copy_to(result.replace_with_uninitialized_short_string(length));
|
|
return result;
|
|
}
|
|
return StringBase { TRY(Detail::StringData::create_substring(*m_data, start, length)) };
|
|
}
|
|
|
|
void StringBase::destroy_string()
|
|
{
|
|
if (!is_short_string())
|
|
m_data->unref();
|
|
}
|
|
|
|
}
|