RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 19:27:44 +00:00
Code Issues Activity Actions

LibPDF: Convert to east-const to comply with the recent style changes

Browse source
This commit is contained in:
Matthew Olsson 2021-06-01 11:16:11 -07:00 • committed by Ali Mohammad Pur
parent 0a4d8ef98d
commit 612b183703
17 changed files with 120 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Userland/Libraries/LibPDF/ColorSpace.cpp
View file

@ -15,7 +15,7 @@ RefPtr<DeviceGrayColorSpace> DeviceGrayColorSpace::the()
return instance; return instance;
} }
Color DeviceGrayColorSpace::color(const Vector<Value>& arguments) const Color DeviceGrayColorSpace::color(Vector<Value> const& arguments) const
{ {
VERIFY(arguments.size() == 1); VERIFY(arguments.size() == 1);
auto gray = static_cast<u8>(arguments[0].to_float() * 255.0f); auto gray = static_cast<u8>(arguments[0].to_float() * 255.0f);
@ -28,7 +28,7 @@ RefPtr<DeviceRGBColorSpace> DeviceRGBColorSpace::the()
return instance; return instance;
} }
Color DeviceRGBColorSpace::color(const Vector<Value>& arguments) const Color DeviceRGBColorSpace::color(Vector<Value> const& arguments) const
{ {
VERIFY(arguments.size() == 3); VERIFY(arguments.size() == 3);
auto r = static_cast<u8>(arguments[0].to_float() * 255.0f); auto r = static_cast<u8>(arguments[0].to_float() * 255.0f);
@ -43,7 +43,7 @@ RefPtr<DeviceCMYKColorSpace> DeviceCMYKColorSpace::the()
return instance; return instance;
} }
Color DeviceCMYKColorSpace::color(const Vector<Value>& arguments) const Color DeviceCMYKColorSpace::color(Vector<Value> const& arguments) const
{ {
VERIFY(arguments.size() == 4); VERIFY(arguments.size() == 4);
auto c = arguments[0].to_float(); auto c = arguments[0].to_float();
@ -196,7 +196,7 @@ constexpr Array<float, 3> convert_to_srgb(Array<float, 3> xyz)
return matrix_multiply(conversion_matrix, xyz); return matrix_multiply(conversion_matrix, xyz);
} }
Color CalRGBColorSpace::color(const Vector<Value>& arguments) const Color CalRGBColorSpace::color(Vector<Value> const& arguments) const
{ {
VERIFY(arguments.size() == 3); VERIFY(arguments.size() == 3);
auto a = clamp(arguments[0].to_float(), 0.0f, 1.0f); auto a = clamp(arguments[0].to_float(), 0.0f, 1.0f);

10
Userland/Libraries/LibPDF/ColorSpace.h
View file

@ -30,7 +30,7 @@ class ColorSpace : public RefCounted<ColorSpace> {
public: public:
virtual ~ColorSpace() = default; virtual ~ColorSpace() = default;
virtual Color color(const Vector<Value>& arguments) const = 0; virtual Color color(Vector<Value> const& arguments) const = 0;
}; };
class DeviceGrayColorSpace final : public ColorSpace { class DeviceGrayColorSpace final : public ColorSpace {
@ -39,7 +39,7 @@ public:
virtual ~DeviceGrayColorSpace() override = default; virtual ~DeviceGrayColorSpace() override = default;
virtual Color color(const Vector<Value>& arguments) const override; virtual Color color(Vector<Value> const& arguments) const override;
private: private:
DeviceGrayColorSpace() = default; DeviceGrayColorSpace() = default;
@ -51,7 +51,7 @@ public:
virtual ~DeviceRGBColorSpace() override = default; virtual ~DeviceRGBColorSpace() override = default;
virtual Color color(const Vector<Value>& arguments) const override; virtual Color color(Vector<Value> const& arguments) const override;
private: private:
DeviceRGBColorSpace() = default; DeviceRGBColorSpace() = default;
@ -63,7 +63,7 @@ public:
virtual ~DeviceCMYKColorSpace() override = default; virtual ~DeviceCMYKColorSpace() override = default;
virtual Color color(const Vector<Value>& arguments) const override; virtual Color color(Vector<Value> const& arguments) const override;
private: private:
DeviceCMYKColorSpace() = default; DeviceCMYKColorSpace() = default;
@ -74,7 +74,7 @@ public:
static RefPtr<CalRGBColorSpace> create(RefPtr<Document>, Vector<Value>&& parameters); static RefPtr<CalRGBColorSpace> create(RefPtr<Document>, Vector<Value>&& parameters);
virtual ~CalRGBColorSpace() override = default; virtual ~CalRGBColorSpace() override = default;
virtual Color color(const Vector<Value>& arguments) const override; virtual Color color(Vector<Value> const& arguments) const override;
private: private:
CalRGBColorSpace() = default; CalRGBColorSpace() = default;

6
Userland/Libraries/LibPDF/Command.h
View file

@ -96,7 +96,7 @@ enum class CommandType {
class Command { class Command {
public: public:
static CommandType command_type_from_symbol(const StringView& symbol_string) static CommandType command_type_from_symbol(StringView const& symbol_string)
{ {
#define V(name, snake_name, symbol) \ #define V(name, snake_name, symbol) \
if (symbol_string == #symbol) \ if (symbol_string == #symbol) \
@ -152,7 +152,7 @@ public:
} }
[[nodiscard]] ALWAYS_INLINE CommandType command_type() const { return m_command_type; } [[nodiscard]] ALWAYS_INLINE CommandType command_type() const { return m_command_type; }
[[nodiscard]] ALWAYS_INLINE const Vector<Value>& arguments() const { return m_arguments; } [[nodiscard]] ALWAYS_INLINE Vector<Value> const& arguments() const { return m_arguments; }
private: private:
CommandType m_command_type; CommandType m_command_type;
@ -165,7 +165,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::Command> : Formatter<StringView> { struct Formatter<PDF::Command> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::Command& command) void format(FormatBuilder& format_builder, PDF::Command const& command)
{ {
StringBuilder builder; StringBuilder builder;
builder.appendff("{} ({})", builder.appendff("{} ({})",

12
Userland/Libraries/LibPDF/Document.cpp
View file

@ -34,7 +34,7 @@ String OutlineItem::to_string(int indent) const
return builder.to_string(); return builder.to_string();
} }
RefPtr<Document> Document::create(const ReadonlyBytes& bytes) RefPtr<Document> Document::create(ReadonlyBytes const& bytes)
{ {
auto parser = adopt_ref(*new Parser({}, bytes)); auto parser = adopt_ref(*new Parser({}, bytes));
auto document = adopt_ref(*new Document(parser)); auto document = adopt_ref(*new Document(parser));
@ -49,7 +49,7 @@ RefPtr<Document> Document::create(const ReadonlyBytes& bytes)
return document; return document;
} }
Document::Document(const NonnullRefPtr<Parser>& parser) Document::Document(NonnullRefPtr<Parser> const& parser)
: m_parser(parser) : m_parser(parser)
{ {
m_parser->set_document(this); m_parser->set_document(this);
@ -131,7 +131,7 @@ Page Document::get_page(u32 index)
return page; return page;
} }
Value Document::resolve(const Value& value) Value Document::resolve(Value const& value)
{ {
if (value.is_ref()) { if (value.is_ref()) {
// FIXME: Surely indirect PDF objects can't contain another indirect PDF object, // FIXME: Surely indirect PDF objects can't contain another indirect PDF object,
@ -159,7 +159,7 @@ bool Document::build_page_tree()
return add_page_tree_node_to_page_tree(page_tree); return add_page_tree_node_to_page_tree(page_tree);
} }
bool Document::add_page_tree_node_to_page_tree(NonnullRefPtr<DictObject> page_tree) bool Document::add_page_tree_node_to_page_tree(NonnullRefPtr<DictObject> const& page_tree)
{ {
if (!page_tree->contains(CommonNames::Kids) || !page_tree->contains(CommonNames::Count)) if (!page_tree->contains(CommonNames::Kids) || !page_tree->contains(CommonNames::Count))
return false; return false;
@ -216,7 +216,7 @@ void Document::build_outline()
m_outline->count = outline_dict->get_value(CommonNames::Count).as_int(); m_outline->count = outline_dict->get_value(CommonNames::Count).as_int();
} }
NonnullRefPtr<OutlineItem> Document::build_outline_item(NonnullRefPtr<DictObject> outline_item_dict) NonnullRefPtr<OutlineItem> Document::build_outline_item(NonnullRefPtr<DictObject> const& outline_item_dict)
{ {
auto outline_item = adopt_ref(*new OutlineItem {}); auto outline_item = adopt_ref(*new OutlineItem {});
@ -284,7 +284,7 @@ NonnullRefPtr<OutlineItem> Document::build_outline_item(NonnullRefPtr<DictObject
return outline_item; return outline_item;
} }
NonnullRefPtrVector<OutlineItem> Document::build_outline_item_chain(const Value& first_ref, const Value& last_ref) NonnullRefPtrVector<OutlineItem> Document::build_outline_item_chain(Value const& first_ref, Value const& last_ref)
{ {
VERIFY(first_ref.is_ref()); VERIFY(first_ref.is_ref());
VERIFY(last_ref.is_ref()); VERIFY(last_ref.is_ref());

26
Userland/Libraries/LibPDF/Document.h
View file

@ -72,9 +72,9 @@ struct OutlineDict final : public RefCounted<OutlineDict> {
class Document final : public RefCounted<Document> { class Document final : public RefCounted<Document> {
public: public:
static RefPtr<Document> create(const ReadonlyBytes& bytes); static RefPtr<Document> create(ReadonlyBytes const& bytes);
ALWAYS_INLINE const RefPtr<OutlineDict>& outline() const { return m_outline; } ALWAYS_INLINE RefPtr<OutlineDict> const& outline() const { return m_outline; }
[[nodiscard]] Value get_or_load_value(u32 index); [[nodiscard]] Value get_or_load_value(u32 index);
@ -92,12 +92,12 @@ public:
// Strips away the layer of indirection by turning indirect value // Strips away the layer of indirection by turning indirect value
// refs into the value they reference, and indirect values into // refs into the value they reference, and indirect values into
// the value being wrapped. // the value being wrapped.
Value resolve(const Value& value); Value resolve(Value const& value);
// Like resolve, but unwraps the Value into the given type. Accepts // Like resolve, but unwraps the Value into the given type. Accepts
// any object type, and the three primitive Value types. // any object type, and the three primitive Value types.
template<IsValueType T> template<IsValueType T>
UnwrappedValueType<T> resolve_to(const Value& value) UnwrappedValueType<T> resolve_to(Value const& value)
{ {
auto resolved = resolve(value); auto resolved = resolve(value);
@ -114,7 +114,7 @@ public:
} }
private: private:
explicit Document(const NonnullRefPtr<Parser>& parser); explicit Document(NonnullRefPtr<Parser> const& parser);
// FIXME: Currently, to improve performance, we don't load any pages at Document // FIXME: Currently, to improve performance, we don't load any pages at Document
// construction, rather we just load the page structure and populate // construction, rather we just load the page structure and populate
@ -123,11 +123,11 @@ private:
// improve lookup time. This would reduce the initial overhead by not loading // improve lookup time. This would reduce the initial overhead by not loading
// every page tree node of, say, a 1000+ page PDF file. // every page tree node of, say, a 1000+ page PDF file.
bool build_page_tree(); bool build_page_tree();
bool add_page_tree_node_to_page_tree(NonnullRefPtr<DictObject> page_tree); bool add_page_tree_node_to_page_tree(NonnullRefPtr<DictObject> const& page_tree);
void build_outline(); void build_outline();
NonnullRefPtr<OutlineItem> build_outline_item(NonnullRefPtr<DictObject> outline_item_dict); NonnullRefPtr<OutlineItem> build_outline_item(NonnullRefPtr<DictObject> const& outline_item_dict);
NonnullRefPtrVector<OutlineItem> build_outline_item_chain(const Value& first_ref, const Value& last_ref); NonnullRefPtrVector<OutlineItem> build_outline_item_chain(Value const& first_ref, Value const& last_ref);
NonnullRefPtr<Parser> m_parser; NonnullRefPtr<Parser> m_parser;
RefPtr<DictObject> m_catalog; RefPtr<DictObject> m_catalog;
@ -143,7 +143,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::Rectangle> : Formatter<StringView> { struct Formatter<PDF::Rectangle> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::Rectangle& rectangle) void format(FormatBuilder& builder, PDF::Rectangle const& rectangle)
{ {
Formatter<StringView>::format(builder, Formatter<StringView>::format(builder,
String::formatted("Rectangle {{ ll=({}, {}), ur=({}, {}) }}", String::formatted("Rectangle {{ ll=({}, {}), ur=({}, {}) }}",
@ -156,7 +156,7 @@ struct Formatter<PDF::Rectangle> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::Page> : Formatter<StringView> { struct Formatter<PDF::Page> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::Page& page) void format(FormatBuilder& builder, PDF::Page const& page)
{ {
constexpr auto fmt_string = "Page {{\n resources={}\n contents={}\n media_box={}\n crop_box={}\n user_unit={}\n rotate={}\n}}"; constexpr auto fmt_string = "Page {{\n resources={}\n contents={}\n media_box={}\n crop_box={}\n user_unit={}\n rotate={}\n}}";
auto str = String::formatted(fmt_string, auto str = String::formatted(fmt_string,
@ -172,7 +172,7 @@ struct Formatter<PDF::Page> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::Destination> : Formatter<StringView> { struct Formatter<PDF::Destination> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::Destination& destination) void format(FormatBuilder& builder, PDF::Destination const& destination)
{ {
String type_str; String type_str;
switch (destination.type) { switch (destination.type) {
@ -213,7 +213,7 @@ struct Formatter<PDF::Destination> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::OutlineItem> : Formatter<StringView> { struct Formatter<PDF::OutlineItem> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::OutlineItem& item) void format(FormatBuilder& builder, PDF::OutlineItem const& item)
{ {
Formatter<StringView>::format(builder, item.to_string(0)); Formatter<StringView>::format(builder, item.to_string(0));
} }
@ -221,7 +221,7 @@ struct Formatter<PDF::OutlineItem> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::OutlineDict> : Formatter<StringView> { struct Formatter<PDF::OutlineDict> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::OutlineDict& dict) void format(FormatBuilder& builder, PDF::OutlineDict const& dict)
{ {
StringBuilder child_builder; StringBuilder child_builder;
child_builder.append('['); child_builder.append('[');

22
Userland/Libraries/LibPDF/Filter.cpp
View file

@ -11,7 +11,7 @@
namespace PDF { namespace PDF {
Optional<ByteBuffer> Filter::decode(const ReadonlyBytes& bytes, const FlyString& encoding_type) Optional<ByteBuffer> Filter::decode(ReadonlyBytes const& bytes, FlyString const& encoding_type)
{ {
if (encoding_type == CommonNames::ASCIIHexDecode) if (encoding_type == CommonNames::ASCIIHexDecode)
return decode_ascii_hex(bytes); return decode_ascii_hex(bytes);
@ -37,7 +37,7 @@ Optional<ByteBuffer> Filter::decode(const ReadonlyBytes& bytes, const FlyString&
return {}; return {};
} }
Optional<ByteBuffer> Filter::decode_ascii_hex(const ReadonlyBytes& bytes) Optional<ByteBuffer> Filter::decode_ascii_hex(ReadonlyBytes const& bytes)
{ {
if (bytes.size() % 2 == 0) if (bytes.size() % 2 == 0)
return decode_hex(bytes); return decode_hex(bytes);
@ -64,7 +64,7 @@ Optional<ByteBuffer> Filter::decode_ascii_hex(const ReadonlyBytes& bytes)
return output; return output;
}; };
Optional<ByteBuffer> Filter::decode_ascii85(const ReadonlyBytes& bytes) Optional<ByteBuffer> Filter::decode_ascii85(ReadonlyBytes const& bytes)
{ {
Vector<u8> buff; Vector<u8> buff;
buff.ensure_capacity(bytes.size()); buff.ensure_capacity(bytes.size());
@ -119,13 +119,13 @@ Optional<ByteBuffer> Filter::decode_ascii85(const ReadonlyBytes& bytes)
return ByteBuffer::copy(buff.span()); return ByteBuffer::copy(buff.span());
}; };
Optional<ByteBuffer> Filter::decode_lzw(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_lzw(ReadonlyBytes const&)
{ {
dbgln("LZW decoding is not supported"); dbgln("LZW decoding is not supported");
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
}; };
Optional<ByteBuffer> Filter::decode_flate(const ReadonlyBytes& bytes) Optional<ByteBuffer> Filter::decode_flate(ReadonlyBytes const& bytes)
{ {
// FIXME: The spec says Flate decoding is "based on" zlib, does that mean they // FIXME: The spec says Flate decoding is "based on" zlib, does that mean they
// aren't exactly the same? // aren't exactly the same?
@ -135,37 +135,37 @@ Optional<ByteBuffer> Filter::decode_flate(const ReadonlyBytes& bytes)
return buff.value(); return buff.value();
}; };
Optional<ByteBuffer> Filter::decode_run_length(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_run_length(ReadonlyBytes const&)
{ {
// FIXME: Support RunLength decoding // FIXME: Support RunLength decoding
TODO(); TODO();
}; };
Optional<ByteBuffer> Filter::decode_ccitt(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_ccitt(ReadonlyBytes const&)
{ {
// FIXME: Support CCITT decoding // FIXME: Support CCITT decoding
TODO(); TODO();
}; };
Optional<ByteBuffer> Filter::decode_jbig2(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_jbig2(ReadonlyBytes const&)
{ {
// FIXME: Support JBIG2 decoding // FIXME: Support JBIG2 decoding
TODO(); TODO();
}; };
Optional<ByteBuffer> Filter::decode_dct(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_dct(ReadonlyBytes const&)
{ {
// FIXME: Support dct decoding // FIXME: Support dct decoding
TODO(); TODO();
}; };
Optional<ByteBuffer> Filter::decode_jpx(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_jpx(ReadonlyBytes const&)
{ {
// FIXME: Support JPX decoding // FIXME: Support JPX decoding
TODO(); TODO();
}; };
Optional<ByteBuffer> Filter::decode_crypt(const ReadonlyBytes&) Optional<ByteBuffer> Filter::decode_crypt(ReadonlyBytes const&)
{ {
// FIXME: Support Crypt decoding // FIXME: Support Crypt decoding
TODO(); TODO();

22
Userland/Libraries/LibPDF/Filter.h
View file

@ -13,19 +13,19 @@ namespace PDF {
class Filter { class Filter {
public: public:
static Optional<ByteBuffer> decode(const ReadonlyBytes& bytes, const FlyString& encoding_type); static Optional<ByteBuffer> decode(ReadonlyBytes const& bytes, FlyString const& encoding_type);
private: private:
static Optional<ByteBuffer> decode_ascii_hex(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_ascii_hex(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_ascii85(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_ascii85(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_lzw(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_lzw(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_flate(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_flate(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_run_length(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_run_length(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_ccitt(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_ccitt(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_jbig2(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_jbig2(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_dct(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_dct(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_jpx(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_jpx(ReadonlyBytes const& bytes);
static Optional<ByteBuffer> decode_crypt(const ReadonlyBytes& bytes); static Optional<ByteBuffer> decode_crypt(ReadonlyBytes const& bytes);
}; };
} }

4
Userland/Libraries/LibPDF/Object.cpp
View file

@ -15,7 +15,7 @@ NonnullRefPtr<Object> ArrayObject::get_object_at(Document* document, size_t inde
return document->resolve_to<Object>(m_elements[index]); return document->resolve_to<Object>(m_elements[index]);
} }
NonnullRefPtr<Object> DictObject::get_object(Document* document, const FlyString& key) const NonnullRefPtr<Object> DictObject::get_object(Document* document, FlyString const& key) const
{ {
return document->resolve_to<Object>(get_value(key)); return document->resolve_to<Object>(get_value(key));
} }
@ -26,7 +26,7 @@ NonnullRefPtr<Object> DictObject::get_object(Document* document, const FlyString
return document->resolve_to<class_name>(m_elements[index]); \ return document->resolve_to<class_name>(m_elements[index]); \
} \ } \
\ \
NonnullRefPtr<class_name> DictObject::get_##snake_name(Document* document, const FlyString& key) const \ NonnullRefPtr<class_name> DictObject::get_##snake_name(Document* document, FlyString const& key) const \
{ \ { \
return document->resolve_to<class_name>(get(key).value()); \ return document->resolve_to<class_name>(get(key).value()); \
} }

32
Userland/Libraries/LibPDF/Object.h
View file

@ -46,7 +46,7 @@ public:
~StringObject() override = default; ~StringObject() override = default;
[[nodiscard]] ALWAYS_INLINE const String& string() const { return m_string; } [[nodiscard]] ALWAYS_INLINE String const& string() const { return m_string; }
[[nodiscard]] ALWAYS_INLINE bool is_binary() const { return m_is_binary; } [[nodiscard]] ALWAYS_INLINE bool is_binary() const { return m_is_binary; }
ALWAYS_INLINE bool is_string() const override { return true; } ALWAYS_INLINE bool is_string() const override { return true; }
@ -67,7 +67,7 @@ public:
~NameObject() override = default; ~NameObject() override = default;
[[nodiscard]] ALWAYS_INLINE const FlyString& name() const { return m_name; } [[nodiscard]] ALWAYS_INLINE FlyString const& name() const { return m_name; }
ALWAYS_INLINE bool is_name() const override { return true; } ALWAYS_INLINE bool is_name() const override { return true; }
ALWAYS_INLINE const char* type_name() const override { return "name"; } ALWAYS_INLINE const char* type_name() const override { return "name"; }
@ -92,8 +92,8 @@ public:
ALWAYS_INLINE auto begin() const { return m_elements.begin(); } ALWAYS_INLINE auto begin() const { return m_elements.begin(); }
ALWAYS_INLINE auto end() const { return m_elements.end(); } ALWAYS_INLINE auto end() const { return m_elements.end(); }
ALWAYS_INLINE const Value& operator[](size_t index) const { return at(index); } ALWAYS_INLINE Value const& operator[](size_t index) const { return at(index); }
ALWAYS_INLINE const Value& at(size_t index) const { return m_elements[index]; } ALWAYS_INLINE Value const& at(size_t index) const { return m_elements[index]; }
NonnullRefPtr<Object> get_object_at(Document*, size_t index) const; NonnullRefPtr<Object> get_object_at(Document*, size_t index) const;
@ -122,24 +122,24 @@ public:
~DictObject() override = default; ~DictObject() override = default;
[[nodiscard]] ALWAYS_INLINE const HashMap<FlyString, Value>& map() const { return m_map; } [[nodiscard]] ALWAYS_INLINE HashMap<FlyString, Value> const& map() const { return m_map; }
template<typename... Args> template<typename... Args>
bool contains(Args&&... keys) const { return (m_map.contains(keys) && ...); } bool contains(Args&&... keys) const { return (m_map.contains(keys) && ...); }
ALWAYS_INLINE Optional<Value> get(const FlyString& key) const { return m_map.get(key); } ALWAYS_INLINE Optional<Value> get(FlyString const& key) const { return m_map.get(key); }
Value get_value(const FlyString& key) const Value get_value(FlyString const& key) const
{ {
auto value = get(key); auto value = get(key);
VERIFY(value.has_value()); VERIFY(value.has_value());
return value.value(); return value.value();
} }
NonnullRefPtr<Object> get_object(Document*, const FlyString& key) const; NonnullRefPtr<Object> get_object(Document*, FlyString const& key) const;
#define DEFINE_GETTER(class_name, snake_name) \ #define DEFINE_GETTER(class_name, snake_name) \
NonnullRefPtr<class_name> get_##snake_name(Document*, const FlyString& key) const; NonnullRefPtr<class_name> get_##snake_name(Document*, FlyString const& key) const;
ENUMERATE_OBJECT_TYPES(DEFINE_GETTER) ENUMERATE_OBJECT_TYPES(DEFINE_GETTER)
#undef DEFINE_GETTER #undef DEFINE_GETTER
@ -156,7 +156,7 @@ private:
class StreamObject : public Object { class StreamObject : public Object {
public: public:
explicit StreamObject(const NonnullRefPtr<DictObject>& dict) explicit StreamObject(NonnullRefPtr<DictObject> const& dict)
: m_dict(dict) : m_dict(dict)
{ {
} }
@ -176,7 +176,7 @@ private:
class PlainTextStreamObject final : public StreamObject { class PlainTextStreamObject final : public StreamObject {
public: public:
PlainTextStreamObject(const NonnullRefPtr<DictObject>& dict, const ReadonlyBytes& bytes) PlainTextStreamObject(NonnullRefPtr<DictObject> const& dict, ReadonlyBytes const& bytes)
: StreamObject(dict) : StreamObject(dict)
, m_bytes(bytes) , m_bytes(bytes)
{ {
@ -192,7 +192,7 @@ private:
class EncodedStreamObject final : public StreamObject { class EncodedStreamObject final : public StreamObject {
public: public:
EncodedStreamObject(const NonnullRefPtr<DictObject>& dict, ByteBuffer&& buffer) EncodedStreamObject(NonnullRefPtr<DictObject> const& dict, ByteBuffer&& buffer)
: StreamObject(dict) : StreamObject(dict)
, m_buffer(buffer) , m_buffer(buffer)
{ {
@ -208,7 +208,7 @@ private:
class IndirectValue final : public Object { class IndirectValue final : public Object {
public: public:
IndirectValue(u32 index, u32 generation_index, const Value& value) IndirectValue(u32 index, u32 generation_index, Value const& value)
: m_index(index) : m_index(index)
, m_value(value) , m_value(value)
{ {
@ -218,7 +218,7 @@ public:
~IndirectValue() override = default; ~IndirectValue() override = default;
[[nodiscard]] ALWAYS_INLINE u32 index() const { return m_index; } [[nodiscard]] ALWAYS_INLINE u32 index() const { return m_index; }
[[nodiscard]] ALWAYS_INLINE const Value& value() const { return m_value; } [[nodiscard]] ALWAYS_INLINE Value const& value() const { return m_value; }
ALWAYS_INLINE bool is_indirect_value() const override { return true; } ALWAYS_INLINE bool is_indirect_value() const override { return true; }
ALWAYS_INLINE const char* type_name() const override { return "indirect_object"; } ALWAYS_INLINE const char* type_name() const override { return "indirect_object"; }
@ -257,7 +257,7 @@ namespace AK {
template<PDF::IsObject T> template<PDF::IsObject T>
struct Formatter<T> : Formatter<StringView> { struct Formatter<T> : Formatter<StringView> {
void format(FormatBuilder& builder, const T& object) void format(FormatBuilder& builder, T const& object)
{ {
Formatter<StringView>::format(builder, object.to_string(0)); Formatter<StringView>::format(builder, object.to_string(0));
} }
@ -265,7 +265,7 @@ struct Formatter<T> : Formatter<StringView> {
template<PDF::IsObject T> template<PDF::IsObject T>
struct Formatter<NonnullRefPtr<T>> : Formatter<T> { struct Formatter<NonnullRefPtr<T>> : Formatter<T> {
void format(FormatBuilder& builder, const NonnullRefPtr<T>& object) void format(FormatBuilder& builder, NonnullRefPtr<T> const& object)
{ {
Formatter<T>::format(builder, *object); Formatter<T>::format(builder, *object);
} }

16
Userland/Libraries/LibPDF/Parser.cpp
View file

@ -24,18 +24,18 @@ static NonnullRefPtr<T> make_object(Args... args) requires(IsBaseOf<Object, T>)
return adopt_ref(*new T(forward<Args>(args)...)); return adopt_ref(*new T(forward<Args>(args)...));
} }
Vector<Command> Parser::parse_graphics_commands(const ReadonlyBytes& bytes) Vector<Command> Parser::parse_graphics_commands(ReadonlyBytes const& bytes)
{ {
auto parser = adopt_ref(*new Parser(bytes)); auto parser = adopt_ref(*new Parser(bytes));
return parser->parse_graphics_commands(); return parser->parse_graphics_commands();
} }
Parser::Parser(Badge<Document>, const ReadonlyBytes& bytes) Parser::Parser(Badge<Document>, ReadonlyBytes const& bytes)
: m_reader(bytes) : m_reader(bytes)
{ {
} }
Parser::Parser(const ReadonlyBytes& bytes) Parser::Parser(ReadonlyBytes const& bytes)
: m_reader(bytes) : m_reader(bytes)
{ {
} }
@ -390,7 +390,7 @@ RefPtr<DictObject> Parser::parse_file_trailer()
return dict; return dict;
} }
Optional<Parser::PageOffsetHintTable> Parser::parse_page_offset_hint_table(const ReadonlyBytes& hint_stream_bytes) Optional<Parser::PageOffsetHintTable> Parser::parse_page_offset_hint_table(ReadonlyBytes const& hint_stream_bytes)
{ {
if (hint_stream_bytes.size() < sizeof(PageOffsetHintTable)) if (hint_stream_bytes.size() < sizeof(PageOffsetHintTable))
return {}; return {};
@ -438,7 +438,7 @@ Optional<Parser::PageOffsetHintTable> Parser::parse_page_offset_hint_table(const
return hint_table; return hint_table;
} }
Optional<Vector<Parser::PageOffsetHintTableEntry>> Parser::parse_all_page_offset_hint_table_entries(const PageOffsetHintTable& hint_table, const ReadonlyBytes& hint_stream_bytes) Optional<Vector<Parser::PageOffsetHintTableEntry>> Parser::parse_all_page_offset_hint_table_entries(PageOffsetHintTable const& hint_table, ReadonlyBytes const& hint_stream_bytes)
{ {
InputMemoryStream input_stream(hint_stream_bytes); InputMemoryStream input_stream(hint_stream_bytes);
input_stream.seek(sizeof(PageOffsetHintTable)); input_stream.seek(sizeof(PageOffsetHintTable));
@ -1167,7 +1167,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::Parser::LinearizationDictionary> : Formatter<StringView> { struct Formatter<PDF::Parser::LinearizationDictionary> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::Parser::LinearizationDictionary& dict) void format(FormatBuilder& format_builder, PDF::Parser::LinearizationDictionary const& dict)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("{\n"); builder.append("{\n");
@ -1188,7 +1188,7 @@ struct Formatter<PDF::Parser::LinearizationDictionary> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::Parser::PageOffsetHintTable> : Formatter<StringView> { struct Formatter<PDF::Parser::PageOffsetHintTable> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::Parser::PageOffsetHintTable& table) void format(FormatBuilder& format_builder, PDF::Parser::PageOffsetHintTable const& table)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("{\n"); builder.append("{\n");
@ -1212,7 +1212,7 @@ struct Formatter<PDF::Parser::PageOffsetHintTable> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::Parser::PageOffsetHintTableEntry> : Formatter<StringView> { struct Formatter<PDF::Parser::PageOffsetHintTableEntry> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::Parser::PageOffsetHintTableEntry& entry) void format(FormatBuilder& format_builder, PDF::Parser::PageOffsetHintTableEntry const& entry)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("{\n"); builder.append("{\n");

14
Userland/Libraries/LibPDF/Parser.h
View file

@ -18,12 +18,12 @@ class Document;
class Parser final : public RefCounted<Parser> { class Parser final : public RefCounted<Parser> {
public: public:
static Vector<Command> parse_graphics_commands(const ReadonlyBytes&); static Vector<Command> parse_graphics_commands(ReadonlyBytes const&);
Parser(Badge<Document>, const ReadonlyBytes&); Parser(Badge<Document>, ReadonlyBytes const&);
[[nodiscard]] ALWAYS_INLINE const RefPtr<DictObject>& trailer() const { return m_trailer; } [[nodiscard]] ALWAYS_INLINE RefPtr<DictObject> const& trailer() const { return m_trailer; }
void set_document(const RefPtr<Document>& document) { m_document = document; } void set_document(RefPtr<Document> const& document) { m_document = document; }
// Parses the header and initializes the xref table and trailer // Parses the header and initializes the xref table and trailer
bool initialize(); bool initialize();
@ -80,15 +80,15 @@ private:
friend struct AK::Formatter<PageOffsetHintTable>; friend struct AK::Formatter<PageOffsetHintTable>;
friend struct AK::Formatter<PageOffsetHintTableEntry>; friend struct AK::Formatter<PageOffsetHintTableEntry>;
explicit Parser(const ReadonlyBytes&); explicit Parser(ReadonlyBytes const&);
bool parse_header(); bool parse_header();
bool initialize_linearization_dict(); bool initialize_linearization_dict();
bool initialize_linearized_xref_table(); bool initialize_linearized_xref_table();
bool initialize_non_linearized_xref_table(); bool initialize_non_linearized_xref_table();
bool initialize_hint_tables(); bool initialize_hint_tables();
Optional<PageOffsetHintTable> parse_page_offset_hint_table(const ReadonlyBytes& hint_stream_bytes); Optional<PageOffsetHintTable> parse_page_offset_hint_table(ReadonlyBytes const& hint_stream_bytes);
Optional<Vector<PageOffsetHintTableEntry>> parse_all_page_offset_hint_table_entries(const PageOffsetHintTable&, const ReadonlyBytes& hint_stream_bytes); Optional<Vector<PageOffsetHintTableEntry>> parse_all_page_offset_hint_table_entries(PageOffsetHintTable const&, ReadonlyBytes const& hint_stream_bytes);
RefPtr<XRefTable> parse_xref_table(); RefPtr<XRefTable> parse_xref_table();
RefPtr<DictObject> parse_file_trailer(); RefPtr<DictObject> parse_file_trailer();

4
Userland/Libraries/LibPDF/Reader.h
View file

@ -14,12 +14,12 @@ namespace PDF {
class Reader { class Reader {
public: public:
explicit Reader(const ReadonlyBytes& bytes) explicit Reader(ReadonlyBytes const& bytes)
: m_bytes(bytes) : m_bytes(bytes)
{ {
} }
ALWAYS_INLINE const ReadonlyBytes& bytes() const { return m_bytes; } ALWAYS_INLINE ReadonlyBytes const& bytes() const { return m_bytes; }
ALWAYS_INLINE size_t offset() const { return m_offset; } ALWAYS_INLINE size_t offset() const { return m_offset; }
bool done() const bool done() const

14
Userland/Libraries/LibPDF/Renderer.cpp
View file

@ -9,7 +9,7 @@
#include <LibPDF/Renderer.h> #include <LibPDF/Renderer.h>
#define RENDERER_HANDLER(name) \ #define RENDERER_HANDLER(name) \
void Renderer::handle_##name([[maybe_unused]] const Vector<Value>& args) void Renderer::handle_##name([[maybe_unused]] Vector<Value> const& args)
#define RENDERER_TODO(name) \ #define RENDERER_TODO(name) \
RENDERER_HANDLER(name) \ RENDERER_HANDLER(name) \
@ -20,12 +20,12 @@
namespace PDF { namespace PDF {
void Renderer::render(Document& document, const Page& page, RefPtr<Gfx::Bitmap> bitmap) void Renderer::render(Document& document, Page const& page, RefPtr<Gfx::Bitmap> bitmap)
{ {
Renderer(document, page, bitmap).render(); Renderer(document, page, bitmap).render();
} }
Renderer::Renderer(RefPtr<Document> document, const Page& page, RefPtr<Gfx::Bitmap> bitmap) Renderer::Renderer(RefPtr<Document> document, Page const& page, RefPtr<Gfx::Bitmap> bitmap)
: m_document(document) : m_document(document)
, m_bitmap(bitmap) , m_bitmap(bitmap)
, m_page(page) , m_page(page)
@ -83,7 +83,7 @@ void Renderer::render()
handle_command(command); handle_command(command);
} }
void Renderer::handle_command(const Command& command) void Renderer::handle_command(Command const& command)
{ {
switch (command.command_type()) { switch (command.command_type()) {
#define V(name, snake_name, symbol) \ #define V(name, snake_name, symbol) \
@ -528,7 +528,7 @@ void Renderer::set_graphics_state_from_dict(NonnullRefPtr<DictObject> dict)
handle_set_flatness_tolerance({ dict->get_value(CommonNames::FL) }); handle_set_flatness_tolerance({ dict->get_value(CommonNames::FL) });
} }
void Renderer::show_text(const String& string, float shift) void Renderer::show_text(String const& string, float shift)
{ {
auto utf = Utf8View(string); auto utf = Utf8View(string);
@ -566,7 +566,7 @@ void Renderer::show_text(const String& string, float shift)
m_text_matrix = Gfx::AffineTransform(1, 0, 0, 1, delta_x, 0).multiply(m_text_matrix); m_text_matrix = Gfx::AffineTransform(1, 0, 0, 1, delta_x, 0).multiply(m_text_matrix);
} }
RefPtr<ColorSpace> Renderer::get_color_space(const Value& value) RefPtr<ColorSpace> Renderer::get_color_space(Value const& value)
{ {
auto name = object_cast<NameObject>(value.as_object())->name(); auto name = object_cast<NameObject>(value.as_object())->name();
@ -600,7 +600,7 @@ RefPtr<ColorSpace> Renderer::get_color_space(const Value& value)
TODO(); TODO();
} }
const Gfx::AffineTransform& Renderer::calculate_text_rendering_matrix() Gfx::AffineTransform const& Renderer::calculate_text_rendering_matrix()
{ {
if (m_text_rendering_matrix_is_dirty) { if (m_text_rendering_matrix_is_dirty) {
m_text_rendering_matrix = Gfx::AffineTransform( m_text_rendering_matrix = Gfx::AffineTransform(

36
Userland/Libraries/LibPDF/Renderer.h
View file

@ -79,29 +79,29 @@ struct GraphicsState {
class Renderer { class Renderer {
public: public:
static void render(Document&, const Page&, RefPtr<Gfx::Bitmap>); static void render(Document&, Page const&, RefPtr<Gfx::Bitmap>);
private: private:
Renderer(RefPtr<Document>, const Page&, RefPtr<Gfx::Bitmap>); Renderer(RefPtr<Document>, Page const&, RefPtr<Gfx::Bitmap>);
void render(); void render();
void handle_command(const Command&); void handle_command(Command const&);
#define V(name, snake_name, symbol) \ #define V(name, snake_name, symbol) \
void handle_##snake_name(const Vector<Value>& args); void handle_##snake_name(Vector<Value> const& args);
ENUMERATE_COMMANDS(V) ENUMERATE_COMMANDS(V)
#undef V #undef V
void handle_text_next_line_show_string(const Vector<Value>& args); void handle_text_next_line_show_string(Vector<Value> const& args);
void handle_text_next_line_show_string_set_spacing(const Vector<Value>& args); void handle_text_next_line_show_string_set_spacing(Vector<Value> const& args);
void set_graphics_state_from_dict(NonnullRefPtr<DictObject>); void set_graphics_state_from_dict(NonnullRefPtr<DictObject>);
// shift is the manual advance given in the TJ command array // shift is the manual advance given in the TJ command array
void show_text(const String&, float shift = 0.0f); void show_text(String const&, float shift = 0.0f);
RefPtr<ColorSpace> get_color_space(const Value&); RefPtr<ColorSpace> get_color_space(Value const&);
ALWAYS_INLINE const GraphicsState& state() const { return m_graphics_state_stack.last(); } ALWAYS_INLINE GraphicsState const& state() const { return m_graphics_state_stack.last(); }
ALWAYS_INLINE GraphicsState& state() { return m_graphics_state_stack.last(); } ALWAYS_INLINE GraphicsState& state() { return m_graphics_state_stack.last(); }
ALWAYS_INLINE const TextState& text_state() const { return state().text_state; } ALWAYS_INLINE TextState const& text_state() const { return state().text_state; }
ALWAYS_INLINE TextState& text_state() { return state().text_state; } ALWAYS_INLINE TextState& text_state() { return state().text_state; }
template<typename T> template<typename T>
@ -113,11 +113,11 @@ private:
template<typename T> template<typename T>
ALWAYS_INLINE Gfx::Rect<T> map(Gfx::Rect<T>) const; ALWAYS_INLINE Gfx::Rect<T> map(Gfx::Rect<T>) const;
const Gfx::AffineTransform& calculate_text_rendering_matrix(); Gfx::AffineTransform const& calculate_text_rendering_matrix();
RefPtr<Document> m_document; RefPtr<Document> m_document;
RefPtr<Gfx::Bitmap> m_bitmap; RefPtr<Gfx::Bitmap> m_bitmap;
const Page& m_page; Page const& m_page;
Gfx::Painter m_painter; Gfx::Painter m_painter;
Gfx::Path m_current_path; Gfx::Path m_current_path;
@ -135,7 +135,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::LineCapStyle> : Formatter<StringView> { struct Formatter<PDF::LineCapStyle> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::LineCapStyle& style) void format(FormatBuilder& builder, PDF::LineCapStyle const& style)
{ {
switch (style) { switch (style) {
case PDF::LineCapStyle::ButtCap: case PDF::LineCapStyle::ButtCap:
@ -153,7 +153,7 @@ struct Formatter<PDF::LineCapStyle> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::LineJoinStyle> : Formatter<StringView> { struct Formatter<PDF::LineJoinStyle> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::LineJoinStyle& style) void format(FormatBuilder& builder, PDF::LineJoinStyle const& style)
{ {
switch (style) { switch (style) {
case PDF::LineJoinStyle::Miter: case PDF::LineJoinStyle::Miter:
@ -171,7 +171,7 @@ struct Formatter<PDF::LineJoinStyle> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::LineDashPattern> : Formatter<StringView> { struct Formatter<PDF::LineDashPattern> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::LineDashPattern& pattern) void format(FormatBuilder& format_builder, PDF::LineDashPattern const& pattern)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("["); builder.append("[");
@ -191,7 +191,7 @@ struct Formatter<PDF::LineDashPattern> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::TextRenderingMode> : Formatter<StringView> { struct Formatter<PDF::TextRenderingMode> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::TextRenderingMode& style) void format(FormatBuilder& builder, PDF::TextRenderingMode const& style)
{ {
switch (style) { switch (style) {
case PDF::TextRenderingMode::Fill: case PDF::TextRenderingMode::Fill:
@ -224,7 +224,7 @@ struct Formatter<PDF::TextRenderingMode> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::TextState> : Formatter<StringView> { struct Formatter<PDF::TextState> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::TextState& state) void format(FormatBuilder& format_builder, PDF::TextState const& state)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("TextState {\n"); builder.append("TextState {\n");
@ -245,7 +245,7 @@ struct Formatter<PDF::TextState> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::GraphicsState> : Formatter<StringView> { struct Formatter<PDF::GraphicsState> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::GraphicsState& state) void format(FormatBuilder& format_builder, PDF::GraphicsState const& state)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("GraphicsState {\n"); builder.append("GraphicsState {\n");

2
Userland/Libraries/LibPDF/Value.cpp
View file

@ -15,7 +15,7 @@ Value::~Value()
m_as_object->unref(); m_as_object->unref();
} }
Value& Value::operator=(const Value& other) Value& Value::operator=(Value const& other)
{ {
m_type = other.m_type; m_type = other.m_type;
switch (m_type) { switch (m_type) {

6
Userland/Libraries/LibPDF/Value.h
View file

@ -79,14 +79,14 @@ public:
m_as_object = obj; m_as_object = obj;
} }
Value(const Value& other) Value(Value const& other)
{ {
*this = other; *this = other;
} }
~Value(); ~Value();
Value& operator=(const Value& other); Value& operator=(Value const& other);
[[nodiscard]] ALWAYS_INLINE bool is_empty() const { return m_type == Type::Empty; } [[nodiscard]] ALWAYS_INLINE bool is_empty() const { return m_type == Type::Empty; }
[[nodiscard]] ALWAYS_INLINE bool is_null() const { return m_type == Type::Null; } [[nodiscard]] ALWAYS_INLINE bool is_null() const { return m_type == Type::Null; }
@ -191,7 +191,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::Value> : Formatter<StringView> { struct Formatter<PDF::Value> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::Value& value) void format(FormatBuilder& builder, PDF::Value const& value)
{ {
Formatter<StringView>::format(builder, value.to_string()); Formatter<StringView>::format(builder, value.to_string());
} }

6
Userland/Libraries/LibPDF/XRefTable.h
View file

@ -52,7 +52,7 @@ public:
return true; return true;
} }
void add_section(const XRefSection& section) void add_section(XRefSection const& section)
{ {
m_entries.ensure_capacity(section.starting_index + section.count); m_entries.ensure_capacity(section.starting_index + section.count);
@ -98,7 +98,7 @@ namespace AK {
template<> template<>
struct Formatter<PDF::XRefEntry> : Formatter<StringView> { struct Formatter<PDF::XRefEntry> : Formatter<StringView> {
void format(FormatBuilder& builder, const PDF::XRefEntry& entry) void format(FormatBuilder& builder, PDF::XRefEntry const& entry)
{ {
Formatter<StringView>::format(builder, Formatter<StringView>::format(builder,
String::formatted("XRefEntry {{ offset={} generation={} used={} }}", String::formatted("XRefEntry {{ offset={} generation={} used={} }}",
@ -110,7 +110,7 @@ struct Formatter<PDF::XRefEntry> : Formatter<StringView> {
template<> template<>
struct Formatter<PDF::XRefTable> : Formatter<StringView> { struct Formatter<PDF::XRefTable> : Formatter<StringView> {
void format(FormatBuilder& format_builder, const PDF::XRefTable& table) void format(FormatBuilder& format_builder, PDF::XRefTable const& table)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("XRefTable {"); builder.append("XRefTable {");