LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-12-28 21:54:40 +03:00
Code Issues Packages Projects Releases Wiki Activity

AK+Format: Remove TypeErasedFormatParams& from format function.

Browse Source
This commit is contained in:
asynts 2020-12-30 12:14:15 +01:00 committed by Andreas Kling
parent 865f5ed4f6
commit 7e62ffbc6e
Notes: sideshowbarker 2024-07-19 00:21:49 +09:00 
Author: https://github.com/asynts
Commit: https://github.com/SerenityOS/serenity/commit/7e62ffbc6ea
Pull-request: https://github.com/SerenityOS/serenity/pull/4663
27 changed files with 129 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
AK/Format.cpp
View File

@ -98,44 +98,32 @@ void vformat_impl(TypeErasedFormatParams& params, FormatBuilder& builder, Format
} // namespace AK::{anonymous}
size_t TypeErasedFormatParams::decode(size_t value, size_t default_value)
size_t TypeErasedParameter::to_size() const
{
if (value == StandardFormatter::value_not_set)
return default_value;
i64 svalue;
if (value == StandardFormatter::value_from_next_arg)
value = StandardFormatter::value_from_arg + take_next_index();
if (type == TypeErasedParameter::Type::UInt8)
svalue = *reinterpret_cast<const u8*>(value);
else if (type == TypeErasedParameter::Type::UInt16)
svalue = *reinterpret_cast<const u16*>(value);
else if (type == TypeErasedParameter::Type::UInt32)
svalue = *reinterpret_cast<const u32*>(value);
else if (type == TypeErasedParameter::Type::UInt64)
svalue = *reinterpret_cast<const u64*>(value);
else if (type == TypeErasedParameter::Type::Int8)
svalue = *reinterpret_cast<const i8*>(value);
else if (type == TypeErasedParameter::Type::Int16)
svalue = *reinterpret_cast<const i16*>(value);
else if (type == TypeErasedParameter::Type::Int32)
svalue = *reinterpret_cast<const i32*>(value);
else if (type == TypeErasedParameter::Type::Int64)
svalue = *reinterpret_cast<const i64*>(value);
else
ASSERT_NOT_REACHED();
if (value >= StandardFormatter::value_from_arg) {
const auto parameter = parameters().at(value - StandardFormatter::value_from_arg);
ASSERT(svalue >= 0);
Optional<i64> svalue;
if (parameter.type == TypeErasedParameter::Type::UInt8)
value = *reinterpret_cast<const u8*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::UInt16)
value = *reinterpret_cast<const u16*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::UInt32)
value = *reinterpret_cast<const u32*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::UInt64)
value = *reinterpret_cast<const u64*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::Int8)
svalue = *reinterpret_cast<const i8*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::Int16)
svalue = *reinterpret_cast<const i16*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::Int32)
svalue = *reinterpret_cast<const i32*>(parameter.value);
else if (parameter.type == TypeErasedParameter::Type::Int64)
svalue = *reinterpret_cast<const i64*>(parameter.value);
else
ASSERT_NOT_REACHED();
if (svalue.has_value()) {
ASSERT(svalue.value() >= 0);
value = static_cast<size_t>(svalue.value());
}
}
return value;
return static_cast<size_t>(svalue);
}
FormatParser::FormatParser(StringView input)
@ -467,7 +455,7 @@ void StandardFormatter::parse(TypeErasedFormatParams& params, FormatParser& pars
if (index == use_next_index)
index = params.take_next_index();
m_width = value_from_arg + index;
m_width = params.parameters().at(index).to_size();
} else if (size_t width = 0; parser.consume_number(width)) {
m_width = width;
}
@ -477,7 +465,7 @@ void StandardFormatter::parse(TypeErasedFormatParams& params, FormatParser& pars
if (index == use_next_index)
index = params.take_next_index();
m_precision = value_from_arg + index;
m_precision = params.parameters().at(index).to_size();
} else if (size_t precision = 0; parser.consume_number(precision)) {
m_precision = precision;
}
@ -514,7 +502,7 @@ void StandardFormatter::parse(TypeErasedFormatParams& params, FormatParser& pars
ASSERT(parser.is_eof());
}
void Formatter<StringView>::format(TypeErasedFormatParams& params, FormatBuilder& builder, StringView value)
void Formatter<StringView>::format(FormatBuilder& builder, StringView value)
{
if (m_sign_mode != FormatBuilder::SignMode::Default)
ASSERT_NOT_REACHED();
@ -524,17 +512,17 @@ void Formatter<StringView>::format(TypeErasedFormatParams& params, FormatBuilder
ASSERT_NOT_REACHED();
if (m_mode != Mode::Default && m_mode != Mode::String && m_mode != Mode::Character)
ASSERT_NOT_REACHED();
if (m_width != value_not_set && m_precision != value_not_set)
if (m_width.has_value() && m_precision.has_value())
ASSERT_NOT_REACHED();
const auto width = params.decode(m_width);
const auto precision = params.decode(m_precision, NumericLimits<size_t>::max());
m_width = m_width.value_or(0);
m_precision = m_precision.value_or(NumericLimits<size_t>::max());
builder.put_string(value, m_align, width, precision, m_fill);
builder.put_string(value, m_align, m_width.value(), m_precision.value(), m_fill);
}
template<typename T>
void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(TypeErasedFormatParams& params, FormatBuilder& builder, T value)
void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(FormatBuilder& builder, T value)
{
if (m_mode == Mode::Character) {
// FIXME: We just support ASCII for now, in the future maybe unicode?
@ -543,10 +531,10 @@ void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(TypeEra
m_mode = Mode::String;
Formatter<StringView> formatter { *this };
return formatter.format(params, builder, StringView { reinterpret_cast<const char*>(&value), 1 });
return formatter.format(builder, StringView { reinterpret_cast<const char*>(&value), 1 });
}
if (m_precision != NumericLimits<size_t>::max())
if (m_precision.has_value())
ASSERT_NOT_REACHED();
if (m_mode == Mode::Pointer) {
@ -556,7 +544,7 @@ void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(TypeEra
ASSERT_NOT_REACHED();
if (m_alternative_form)
ASSERT_NOT_REACHED();
if (m_width != value_not_set)
if (m_width.has_value())
ASSERT_NOT_REACHED();
m_mode = Mode::Hexadecimal;
@ -585,37 +573,37 @@ void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(TypeEra
ASSERT_NOT_REACHED();
}
const auto width = params.decode(m_width);
m_width = m_width.value_or(0);
if (IsSame<typename MakeUnsigned<T>::Type, T>::value)
builder.put_u64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, width, m_fill, m_sign_mode);
builder.put_u64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, m_width.value(), m_fill, m_sign_mode);
else
builder.put_i64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, width, m_fill, m_sign_mode);
builder.put_i64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, m_width.value(), m_fill, m_sign_mode);
}
void Formatter<char>::format(TypeErasedFormatParams& params, FormatBuilder& builder, char value)
void Formatter<char>::format(FormatBuilder& builder, char value)
{
if (m_mode == Mode::Binary || m_mode == Mode::BinaryUppercase || m_mode == Mode::Decimal || m_mode == Mode::Octal || m_mode == Mode::Hexadecimal || m_mode == Mode::HexadecimalUppercase) {
// Trick: signed char != char. (Sometimes weird features are actually helpful.)
Formatter<signed char> formatter { *this };
return formatter.format(params, builder, static_cast<signed char>(value));
return formatter.format(builder, static_cast<signed char>(value));
} else {
Formatter<StringView> formatter { *this };
return formatter.format(params, builder, { &value, 1 });
return formatter.format(builder, { &value, 1 });
}
}
void Formatter<bool>::format(TypeErasedFormatParams& params, FormatBuilder& builder, bool value)
void Formatter<bool>::format(FormatBuilder& builder, bool value)
{
if (m_mode == Mode::Binary || m_mode == Mode::BinaryUppercase || m_mode == Mode::Decimal || m_mode == Mode::Octal || m_mode == Mode::Hexadecimal || m_mode == Mode::HexadecimalUppercase) {
Formatter<u8> formatter { *this };
return formatter.format(params, builder, static_cast<u8>(value));
return formatter.format(builder, static_cast<u8>(value));
} else {
Formatter<StringView> formatter { *this };
return formatter.format(params, builder, value ? "true" : "false");
return formatter.format(builder, value ? "true" : "false");
}
}
#ifndef KERNEL
void Formatter<double>::format(TypeErasedFormatParams& params, FormatBuilder& builder, double value)
void Formatter<double>::format(FormatBuilder& builder, double value)
{
u8 base;
bool upper_case;
@ -632,15 +620,15 @@ void Formatter<double>::format(TypeErasedFormatParams& params, FormatBuilder& bu
ASSERT_NOT_REACHED();
}
const auto width = params.decode(m_width);
const auto precision = params.decode(m_precision, 6);
m_width = m_width.value_or(0);
m_precision = m_precision.value_or(6);
builder.put_f64(value, base, upper_case, m_align, width, precision, m_fill, m_sign_mode);
builder.put_f64(value, base, upper_case, m_align, m_width.value(), m_precision.value(), m_fill, m_sign_mode);
}
void Formatter<float>::format(TypeErasedFormatParams& params, FormatBuilder& builder, float value)
void Formatter<float>::format(FormatBuilder& builder, float value)
{
Formatter<double> formatter { *this };
formatter.format(params, builder, value);
formatter.format(builder, value);
}
#endif

47
AK/Format.h
View File

@ -28,6 +28,7 @@
#include <AK/Array.h>
#include <AK/GenericLexer.h>
#include <AK/Optional.h>
#include <AK/StringView.h>
#ifndef KERNEL
@ -94,6 +95,10 @@ struct TypeErasedParameter {
return Type::Custom;
}
size_t to_size() const;
// FIXME: Getters and setters.
const void* value;
Type type;
void (*formatter)(TypeErasedFormatParams&, FormatBuilder&, FormatParser&, const void* value);
@ -197,8 +202,6 @@ public:
void set_parameters(Span<const TypeErasedParameter> parameters) { m_parameters = parameters; }
size_t take_next_index() { return m_next_index++; }
size_t decode(size_t value, size_t default_value = 0);
private:
Span<const TypeErasedParameter> m_parameters;
size_t m_next_index { 0 };
@ -210,7 +213,7 @@ void __format_value(TypeErasedFormatParams& params, FormatBuilder& builder, Form
Formatter<T> formatter;
formatter.parse(params, parser);
formatter.format(params, builder, *static_cast<const T*>(value));
formatter.format(builder, *static_cast<const T*>(value));
}
template<typename... Parameters>
@ -249,18 +252,14 @@ struct StandardFormatter {
HexfloatUppercase,
};
static constexpr size_t value_not_set = NumericLimits<size_t>::max();
static constexpr size_t value_from_next_arg = NumericLimits<size_t>::max() - 1;
static constexpr size_t value_from_arg = NumericLimits<size_t>::max() - max_format_arguments - 2;
FormatBuilder::Align m_align = FormatBuilder::Align::Default;
FormatBuilder::SignMode m_sign_mode = FormatBuilder::SignMode::OnlyIfNeeded;
Mode m_mode = Mode::Default;
bool m_alternative_form = false;
char m_fill = ' ';
bool m_zero_pad = false;
size_t m_width = value_not_set;
size_t m_precision = value_not_set;
Optional<size_t> m_width;
Optional<size_t> m_precision;
void parse(TypeErasedFormatParams&, FormatParser&);
};
@ -273,7 +272,7 @@ struct Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type> : StandardFor
{
}
void format(TypeErasedFormatParams&, FormatBuilder&, T value);
void format(FormatBuilder&, T value);
};
template<>
@ -284,17 +283,17 @@ struct Formatter<StringView> : StandardFormatter {
{
}
void format(TypeErasedFormatParams&, FormatBuilder&, StringView value);
void format(FormatBuilder&, StringView value);
};
template<>
struct Formatter<const char*> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const char* value)
void format(FormatBuilder& builder, const char* value)
{
if (m_mode == Mode::Pointer) {
Formatter<FlatPtr> formatter { *this };
formatter.format(params, builder, reinterpret_cast<FlatPtr>(value));
formatter.format(builder, reinterpret_cast<FlatPtr>(value));
} else {
Formatter<StringView>::format(params, builder, value);
Formatter<StringView>::format(builder, value);
}
}
};
@ -313,29 +312,29 @@ struct Formatter<FlyString> : Formatter<StringView> {
template<typename T>
struct Formatter<T*> : StandardFormatter {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, T* value)
void format(FormatBuilder& builder, T* value)
{
if (m_mode == Mode::Default)
m_mode = Mode::Pointer;
Formatter<FlatPtr> formatter { *this };
formatter.format(params, builder, reinterpret_cast<FlatPtr>(value));
formatter.format(builder, reinterpret_cast<FlatPtr>(value));
}
};
template<>
struct Formatter<char> : StandardFormatter {
void format(TypeErasedFormatParams&, FormatBuilder&, char value);
void format(FormatBuilder&, char value);
};
template<>
struct Formatter<bool> : StandardFormatter {
void format(TypeErasedFormatParams&, FormatBuilder&, bool value);
void format(FormatBuilder&, bool value);
};
#ifndef KERNEL
template<>
struct Formatter<float> : StandardFormatter {
void format(TypeErasedFormatParams&, FormatBuilder&, float value);
void format(FormatBuilder&, float value);
};
template<>
struct Formatter<double> : StandardFormatter {
@ -345,7 +344,7 @@ struct Formatter<double> : StandardFormatter {
{
}
void format(TypeErasedFormatParams&, FormatBuilder&, double value);
void format(FormatBuilder&, double value);
};
#endif
@ -409,16 +408,16 @@ private:
};
template<typename T, bool Supported = false>
struct __FormatIfSupported : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const FormatIfSupported<T>&)
void format(FormatBuilder& builder, const FormatIfSupported<T>&)
{
Formatter<StringView>::format(params, builder, "?");
Formatter<StringView>::format(builder, "?");
}
};
template<typename T>
struct __FormatIfSupported<T, true> : Formatter<T> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const FormatIfSupported<T>& value)
void format(FormatBuilder& builder, const FormatIfSupported<T>& value)
{
Formatter<T>::format(params, builder, value.value());
Formatter<T>::format(builder, value.value());
}
};
template<typename T>

4
AK/JsonValue.h
View File

@ -263,9 +263,9 @@ private:
template<>
struct Formatter<JsonValue> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const JsonValue& value)
void format(FormatBuilder& builder, const JsonValue& value)
{
Formatter<StringView>::format(params, builder, value.to_string());
Formatter<StringView>::format(builder, value.to_string());
}
};

4
AK/LexicalPath.h
View File

@ -66,9 +66,9 @@ private:
template<>
struct Formatter<LexicalPath> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const LexicalPath& value)
void format(FormatBuilder& builder, const LexicalPath& value)
{
Formatter<StringView>::format(params, builder, value.string());
Formatter<StringView>::format(builder, value.string());
}
};

4
AK/NonnullOwnPtr.h
View File

@ -197,9 +197,9 @@ inline void swap(NonnullOwnPtr<T>& a, NonnullOwnPtr<U>& b)
template<typename T>
struct Formatter<NonnullOwnPtr<T>> : Formatter<const T*> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const NonnullOwnPtr<T>& value)
void format(FormatBuilder& builder, const NonnullOwnPtr<T>& value)
{
Formatter<const T*>::format(params, builder, value.ptr());
Formatter<const T*>::format(builder, value.ptr());
}
};

4
AK/NonnullRefPtr.h
View File

@ -348,9 +348,9 @@ inline const LogStream& operator<<(const LogStream& stream, const NonnullRefPtr<
template<typename T>
struct Formatter<NonnullRefPtr<T>> : Formatter<const T*> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const NonnullRefPtr<T>& value)
void format(FormatBuilder& builder, const NonnullRefPtr<T>& value)
{
Formatter<const T*>::format(params, builder, value.ptr());
Formatter<const T*>::format(builder, value.ptr());
}
};

4
AK/StringImpl.h
View File

@ -132,9 +132,9 @@ constexpr u32 string_hash(const char* characters, size_t length)
template<>
struct Formatter<StringImpl> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const StringImpl& value)
void format(FormatBuilder& builder, const StringImpl& value)
{
Formatter<StringView>::format(params, builder, { value.characters(), value.length() });
Formatter<StringView>::format(builder, { value.characters(), value.length() });
}
};

4
AK/Tests/TestFormat.cpp
View File

@ -213,9 +213,9 @@ struct B {
};
template<>
struct AK::Formatter<B> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, B)
void format(FormatBuilder& builder, B)
{
Formatter<StringView>::format(params, builder, "B");
Formatter<StringView>::format(builder, "B");
}
};

4
AK/URL.h
View File

@ -106,9 +106,9 @@ inline const LogStream& operator<<(const LogStream& stream, const URL& value)
template<>
struct Formatter<URL> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const URL& value)
void format(FormatBuilder& builder, const URL& value)
{
Formatter<StringView>::format(params, builder, value.to_string());
Formatter<StringView>::format(builder, value.to_string());
}
};

6
AK/WeakPtr.h
View File

@ -226,13 +226,13 @@ inline const LogStream& operator<<(const LogStream& stream, const WeakPtr<T>& va
template<typename T>
struct Formatter<WeakPtr<T>> : Formatter<const T*> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const WeakPtr<T>& value)
void format(FormatBuilder& builder, const WeakPtr<T>& value)
{
#ifdef KERNEL
auto ref = value.strong_ref();
Formatter<const T*>::format(params, builder, ref.ptr());
Formatter<const T*>::format(builder, ref.ptr());
#else
Formatter<const T*>::format(params, builder, value.ptr());
Formatter<const T*>::format(builder, value.ptr());
#endif
}
};

4
DevTools/UserspaceEmulator/ValueWithShadow.h
View File

@ -164,8 +164,8 @@ inline void ValueAndShadowReference<T>::operator=(const ValueWithShadow<T>& othe
template<typename T>
struct AK::Formatter<UserspaceEmulator::ValueWithShadow<T>> : AK::Formatter<T> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, UserspaceEmulator::ValueWithShadow<T> value)
void format(FormatBuilder& builder, UserspaceEmulator::ValueWithShadow<T> value)
{
return Formatter<T>::format(params, builder, value.value());
return Formatter<T>::format(builder, value.value());
}
};

4
Kernel/VirtualAddress.cpp
View File

@ -28,9 +28,9 @@
#include <Kernel/VirtualAddress.h>
namespace AK {
void Formatter<VirtualAddress>::format(TypeErasedFormatParams& params, FormatBuilder& builder, const VirtualAddress& value)
void Formatter<VirtualAddress>::format(FormatBuilder& builder, const VirtualAddress& value)
{
Formatter<StringView>::format(params, builder, String::formatted("V{:p}", value.get()));
Formatter<StringView>::format(builder, String::formatted("V{:p}", value.get()));
}
}

4
Kernel/VirtualAddress.h
View File

@ -77,8 +77,10 @@ inline const LogStream& operator<<(const LogStream& stream, VirtualAddress value
}
namespace AK {
template<>
struct Formatter<VirtualAddress> : Formatter<StringView> {
void format(TypeErasedFormatParams&, FormatBuilder&, const VirtualAddress&);
void format(FormatBuilder&, const VirtualAddress&);
};
}

4
Libraries/LibCore/Object.cpp
View File

@ -273,9 +273,9 @@ const LogStream& operator<<(const LogStream& stream, const Object& object)
namespace AK {
void Formatter<Core::Object>::format(TypeErasedFormatParams& params, FormatBuilder& builder, const Core::Object& value)
void Formatter<Core::Object>::format(FormatBuilder& builder, const Core::Object& value)
{
Formatter<StringView>::format(params, builder, String::formatted("{}({})", value.class_name(), &value));
Formatter<StringView>::format(builder, String::formatted("{}({})", value.class_name(), &value));
}
}

2
Libraries/LibCore/Object.h
View File

@ -175,7 +175,7 @@ private:
namespace AK {
template<>
struct Formatter<Core::Object> : Formatter<StringView> {
void format(TypeErasedFormatParams&, FormatBuilder&, const Core::Object&);
void format(FormatBuilder&, const Core::Object&);
};
}

6
Libraries/LibGUI/ModelIndex.cpp
View File

@ -50,14 +50,14 @@ const LogStream& operator<<(const LogStream& stream, const ModelIndex& value)
namespace AK {
void Formatter<GUI::ModelIndex>::format(TypeErasedFormatParams& params, FormatBuilder& builder, const GUI::ModelIndex& value)
void Formatter<GUI::ModelIndex>::format(FormatBuilder& builder, const GUI::ModelIndex& value)
{
Formatter<StringView> formatter { *this };
if (value.internal_data())
formatter.format(params, builder, String::formatted("ModelIndex({},{},{:p})", value.row(), value.column(), value.internal_data()));
formatter.format(builder, String::formatted("ModelIndex({},{},{:p})", value.row(), value.column(), value.internal_data()));
else
formatter.format(params, builder, String::formatted("ModelIndex({},{})", value.row(), value.column()));
formatter.format(builder, String::formatted("ModelIndex({},{})", value.row(), value.column()));
}
}

2
Libraries/LibGUI/ModelIndex.h
View File

@ -83,7 +83,7 @@ namespace AK {
template<>
struct Formatter<GUI::ModelIndex> : Formatter<StringView> {
void format(TypeErasedFormatParams&, FormatBuilder&, const GUI::ModelIndex&);
void format(FormatBuilder&, const GUI::ModelIndex&);
};
template<>

6
Libraries/LibGUI/TextPosition.h
View File

@ -70,12 +70,12 @@ namespace AK {
template<>
struct Formatter<GUI::TextPosition> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const GUI::TextPosition& value)
void format(FormatBuilder& builder, const GUI::TextPosition& value)
{
if (value.is_valid())
Formatter<StringView>::format(params, builder, String::formatted("({},{})", value.line(), value.column()));
Formatter<StringView>::format(builder, String::formatted("({},{})", value.line(), value.column()));
else
Formatter<StringView>::format(params, builder, "GUI::TextPosition(Invalid)");
Formatter<StringView>::format(builder, "GUI::TextPosition(Invalid)");
}
};

6
Libraries/LibGUI/TextRange.h
View File

@ -98,12 +98,12 @@ namespace AK {
template<>
struct Formatter<GUI::TextRange> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const GUI::TextRange& value)
void format(FormatBuilder& builder, const GUI::TextRange& value)
{
if (value.is_valid())
Formatter<StringView>::format(params, builder, String::formatted("{}-{}", value.start(), value.end()));
Formatter<StringView>::format(builder, String::formatted("{}-{}", value.start(), value.end()));
else
Formatter<StringView>::format(params, builder, "GUI::TextRange(Invalid)");
Formatter<StringView>::format(builder, "GUI::TextRange(Invalid)");
}
};

4
Libraries/LibGfx/Color.cpp
View File

@ -434,7 +434,7 @@ bool IPC::decode(IPC::Decoder& decoder, Color& color)
return true;
}
void AK::Formatter<Gfx::Color>::format(TypeErasedFormatParams& params, FormatBuilder& builder, const Gfx::Color& value)
void AK::Formatter<Gfx::Color>::format(FormatBuilder& builder, const Gfx::Color& value)
{
Formatter<StringView>::format(params, builder, value.to_string());
Formatter<StringView>::format(builder, value.to_string());
}

6
Libraries/LibGfx/Color.h
View File

@ -317,13 +317,17 @@ const LogStream& operator<<(const LogStream&, Color);
using Gfx::Color;
namespace AK {
template<>
struct Formatter<Gfx::Color> : public Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const Gfx::Color& value);
void format(FormatBuilder& builder, const Gfx::Color& value);
};
}
namespace IPC {
bool encode(Encoder&, const Gfx::Color&);
bool decode(Decoder&, Gfx::Color&);
}

4
Libraries/LibGfx/Rect.h
View File

@ -455,9 +455,9 @@ namespace AK {
template<typename T>
struct Formatter<Gfx::Rect<T>> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const Gfx::Rect<T>& value)
void format(FormatBuilder& builder, const Gfx::Rect<T>& value)
{
Formatter<StringView>::format(params, builder, value.to_string());
Formatter<StringView>::format(builder, value.to_string());
}
};

6
Libraries/LibJS/Runtime/Cell.h
View File

@ -78,12 +78,12 @@ namespace AK {
template<>
struct Formatter<JS::Cell> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const JS::Cell* cell)
void format(FormatBuilder& builder, const JS::Cell* cell)
{
if (!cell)
Formatter<StringView>::format(params, builder, "Cell{nullptr}");
Formatter<StringView>::format(builder, "Cell{nullptr}");
else
Formatter<StringView>::format(params, builder, String::formatted("{}{{{}}}", cell->class_name(), static_cast<const void*>(cell)));
Formatter<StringView>::format(builder, String::formatted("{}{{{}}}", cell->class_name(), static_cast<const void*>(cell)));
}
};

4
Libraries/LibJS/Runtime/PropertyAttributes.h
View File

@ -95,9 +95,9 @@ namespace AK {
template<>
struct Formatter<JS::PropertyAttributes> : Formatter<u8> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const JS::PropertyAttributes& attributes)
void format(FormatBuilder& builder, const JS::PropertyAttributes& attributes)
{
Formatter<u8>::format(params, builder, attributes.bits());
Formatter<u8>::format(builder, attributes.bits());
}
};

4
Libraries/LibJS/Runtime/Value.h
View File

@ -345,9 +345,9 @@ namespace AK {
template<>
struct Formatter<JS::Value> : Formatter<StringView> {
void format(TypeErasedFormatParams& params, FormatBuilder& builder, const JS::Value& value)
void format(FormatBuilder& builder, const JS::Value& value)
{
Formatter<StringView>::format(params, builder, value.is_empty() ? "<empty>" : value.to_string_without_side_effects());
Formatter<StringView>::format(builder, value.is_empty() ? "<empty>" : value.to_string_without_side_effects());
}
};

6
Shell/AST.cpp
View File

@ -37,7 +37,7 @@
//#define EXECUTE_DEBUG
void AK::Formatter<Shell::AST::Command>::format(TypeErasedFormatParams&, FormatBuilder& builder, const Shell::AST::Command& value)
void AK::Formatter<Shell::AST::Command>::format(FormatBuilder& builder, const Shell::AST::Command& value)
{
if (m_sign_mode != FormatBuilder::SignMode::Default)
ASSERT_NOT_REACHED();
@ -47,7 +47,9 @@ void AK::Formatter<Shell::AST::Command>::format(TypeErasedFormatParams&, FormatB
ASSERT_NOT_REACHED();
if (m_mode != Mode::Default && m_mode != Mode::String)
ASSERT_NOT_REACHED();
if (m_width != value_not_set && m_precision != value_not_set)
if (m_width.has_value())
ASSERT_NOT_REACHED();
if (m_precision.has_value())
ASSERT_NOT_REACHED();
if (value.argv.is_empty()) {

2
Shell/AST.h
View File

@ -1301,7 +1301,7 @@ struct Formatter<Shell::AST::Command> : StandardFormatter {
{
}
void format(TypeErasedFormatParams&, FormatBuilder&, const Shell::AST::Command& value);
void format(FormatBuilder&, const Shell::AST::Command& value);
};
}