From 18a583e8d9c509039046330a64925fdc733bb277 Mon Sep 17 00:00:00 2001 From: Jay Berkenbilt Date: Thu, 8 Sep 2022 11:29:23 -0400 Subject: [PATCH] Rename QPDFValueProxy back to QPDFObject QPDFValueProxy wasn't a good name for it. We decided the evil of having the header file be named QPDFObject_private.hh was less than the evil of having the class be named something other than what it should have been named. --- TODO | 2 +- include/qpdf/QPDF.hh | 12 ++++---- include/qpdf/QPDFObjectHandle.hh | 10 +++---- libqpdf/QPDF.cc | 5 ++-- libqpdf/QPDFObject.cc | 4 +-- libqpdf/QPDFObjectHandle.cc | 2 +- libqpdf/QPDFValue.cc | 4 +-- libqpdf/QPDF_Array.cc | 6 ++-- libqpdf/QPDF_Bool.cc | 4 +-- libqpdf/QPDF_Destroyed.cc | 2 +- libqpdf/QPDF_Dictionary.cc | 4 +-- libqpdf/QPDF_InlineImage.cc | 4 +-- libqpdf/QPDF_Integer.cc | 4 +-- libqpdf/QPDF_Name.cc | 4 +-- libqpdf/QPDF_Null.cc | 4 +-- libqpdf/QPDF_Operator.cc | 4 +-- libqpdf/QPDF_Real.cc | 6 ++-- libqpdf/QPDF_Reserved.cc | 4 +-- libqpdf/QPDF_Stream.cc | 4 +-- libqpdf/QPDF_String.cc | 6 ++-- libqpdf/QPDF_Unresolved.cc | 4 +-- libqpdf/qpdf/QPDFObject_private.hh | 14 +++++----- libqpdf/qpdf/QPDFValue.hh | 8 +++--- libqpdf/qpdf/QPDF_Array.hh | 6 ++-- libqpdf/qpdf/QPDF_Bool.hh | 4 +-- libqpdf/qpdf/QPDF_Destroyed.hh | 2 +- libqpdf/qpdf/QPDF_Dictionary.hh | 4 +-- libqpdf/qpdf/QPDF_InlineImage.hh | 4 +-- libqpdf/qpdf/QPDF_Integer.hh | 4 +-- libqpdf/qpdf/QPDF_Name.hh | 4 +-- libqpdf/qpdf/QPDF_Null.hh | 4 +-- libqpdf/qpdf/QPDF_Operator.hh | 4 +-- libqpdf/qpdf/QPDF_Real.hh | 6 ++-- libqpdf/qpdf/QPDF_Reserved.hh | 4 +-- libqpdf/qpdf/QPDF_Stream.hh | 4 +-- libqpdf/qpdf/QPDF_String.hh | 6 ++-- libqpdf/qpdf/QPDF_Unresolved.hh | 5 ++-- manual/design.rst | 44 ++++++++++++++++-------------- 38 files changed, 113 insertions(+), 113 deletions(-) diff --git a/TODO b/TODO index 8c647fe5..3099f8cc 100644 --- a/TODO +++ b/TODO @@ -789,7 +789,7 @@ Rejected Ideas These are some ideas I had before m-holger's changes to split QPDFValue from QPDFObject. These notes were written prior to the - split of QPDFObject into QPDFValueProxy and QPDFValue and don't work + split of QPDFObject into QPDFObject and QPDFValue and don't work directly with the new implementation. I think they are still basic valid after adjusting to the new structure, but I think they would come at too high a performance cost to be worth doing. diff --git a/include/qpdf/QPDF.hh b/include/qpdf/QPDF.hh index c7ac5281..ea2ca05c 100644 --- a/include/qpdf/QPDF.hh +++ b/include/qpdf/QPDF.hh @@ -842,11 +842,11 @@ class QPDF } }; - // Resolver class is restricted to QPDFValueProxy so that only it + // The Resolver class is restricted to QPDFObject so that only it // can resolve indirect references. class Resolver { - friend class QPDFValueProxy; + friend class QPDFObject; private: static void @@ -952,7 +952,7 @@ class QPDF { } ObjCache( - std::shared_ptr object, + std::shared_ptr object, qpdf_offset_t end_before_space, qpdf_offset_t end_after_space) : object(object), @@ -961,7 +961,7 @@ class QPDF { } - std::shared_ptr object; + std::shared_ptr object; qpdf_offset_t end_before_space; qpdf_offset_t end_after_space; }; @@ -1186,12 +1186,12 @@ class QPDF QPDFObjectHandle reserveObjectIfNotExists(QPDFObjGen const& og); QPDFObjectHandle reserveStream(QPDFObjGen const& og); QPDFObjectHandle - newIndirect(QPDFObjGen const&, std::shared_ptr const&); + newIndirect(QPDFObjGen const&, std::shared_ptr const&); bool isCached(QPDFObjGen const& og); bool isUnresolved(QPDFObjGen const& og); void updateCache( QPDFObjGen const& og, - std::shared_ptr const& object, + std::shared_ptr const& object, qpdf_offset_t end_before_space, qpdf_offset_t end_after_space); diff --git a/include/qpdf/QPDFObjectHandle.hh b/include/qpdf/QPDFObjectHandle.hh index 07fe3ad5..21f82e58 100644 --- a/include/qpdf/QPDFObjectHandle.hh +++ b/include/qpdf/QPDFObjectHandle.hh @@ -54,7 +54,7 @@ class QPDF_Real; class QPDF_Reserved; class QPDF_Stream; class QPDF_String; -class QPDFValueProxy; +class QPDFObject; class QPDFTokenizer; class QPDFExc; class Pl_QPDFTokenizer; @@ -1493,7 +1493,7 @@ class QPDFObjectHandle private: static QPDFObjectHandle - newIndirect(std::shared_ptr const& obj) + newIndirect(std::shared_ptr const& obj) { return QPDFObjectHandle(obj); } @@ -1518,7 +1518,7 @@ class QPDFObjectHandle friend class QPDF; private: - static std::shared_ptr + static std::shared_ptr getObject(QPDFObjectHandle& o) { if (!o.dereference()) { @@ -1617,7 +1617,7 @@ class QPDFObjectHandle bool isImage(bool exclude_imagemask = true); private: - QPDFObjectHandle(std::shared_ptr const& obj) : + QPDFObjectHandle(std::shared_ptr const& obj) : obj(obj) { } @@ -1671,7 +1671,7 @@ class QPDFObjectHandle // Moving members of QPDFObjectHandle into a smart pointer incurs // a substantial performance penalty since QPDFObjectHandle // objects are copied around so frequently. - std::shared_ptr obj; + std::shared_ptr obj; }; #ifndef QPDF_NO_QPDF_STRING diff --git a/libqpdf/QPDF.cc b/libqpdf/QPDF.cc index d56fb29d..454c05ee 100644 --- a/libqpdf/QPDF.cc +++ b/libqpdf/QPDF.cc @@ -2120,8 +2120,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number) } QPDFObjectHandle -QPDF::newIndirect( - QPDFObjGen const& og, std::shared_ptr const& obj) +QPDF::newIndirect(QPDFObjGen const& og, std::shared_ptr const& obj) { obj->setObjGen(this, og); if (!obj->hasDescription()) { @@ -2133,7 +2132,7 @@ QPDF::newIndirect( void QPDF::updateCache( QPDFObjGen const& og, - std::shared_ptr const& object, + std::shared_ptr const& object, qpdf_offset_t end_before_space, qpdf_offset_t end_after_space) { diff --git a/libqpdf/QPDFObject.cc b/libqpdf/QPDFObject.cc index b5d073ab..f6869925 100644 --- a/libqpdf/QPDFObject.cc +++ b/libqpdf/QPDFObject.cc @@ -4,14 +4,14 @@ #include void -QPDFValueProxy::doResolve() +QPDFObject::doResolve() { auto og = value->og; QPDF::Resolver::resolve(value->qpdf, og); } void -QPDFValueProxy::destroy() +QPDFObject::destroy() { value = QPDF_Destroyed::getInstance(); } diff --git a/libqpdf/QPDFObjectHandle.cc b/libqpdf/QPDFObjectHandle.cc index ab54b808..6225dba9 100644 --- a/libqpdf/QPDFObjectHandle.cc +++ b/libqpdf/QPDFObjectHandle.cc @@ -2287,7 +2287,7 @@ QPDFObjectHandle::copyObject( " reserved object handle direct"); } - std::shared_ptr new_obj; + std::shared_ptr new_obj; if (isBool() || isInteger() || isName() || isNull() || isReal() || isString()) { diff --git a/libqpdf/QPDFValue.cc b/libqpdf/QPDFValue.cc index 99fd77d7..ca3205b7 100644 --- a/libqpdf/QPDFValue.cc +++ b/libqpdf/QPDFValue.cc @@ -2,10 +2,10 @@ #include -std::shared_ptr +std::shared_ptr QPDFValue::do_create(QPDFValue* object) { - std::shared_ptr obj(new QPDFValueProxy()); + std::shared_ptr obj(new QPDFObject()); obj->value = std::shared_ptr(object); return obj; } diff --git a/libqpdf/QPDF_Array.cc b/libqpdf/QPDF_Array.cc index 6d60b789..2cbdfcec 100644 --- a/libqpdf/QPDF_Array.cc +++ b/libqpdf/QPDF_Array.cc @@ -16,19 +16,19 @@ QPDF_Array::QPDF_Array(SparseOHArray const& items) : { } -std::shared_ptr +std::shared_ptr QPDF_Array::create(std::vector const& items) { return do_create(new QPDF_Array(items)); } -std::shared_ptr +std::shared_ptr QPDF_Array::create(SparseOHArray const& items) { return do_create(new QPDF_Array(items)); } -std::shared_ptr +std::shared_ptr QPDF_Array::shallowCopy() { return create(elements); diff --git a/libqpdf/QPDF_Bool.cc b/libqpdf/QPDF_Bool.cc index 8b4c6a7a..efbfd6c9 100644 --- a/libqpdf/QPDF_Bool.cc +++ b/libqpdf/QPDF_Bool.cc @@ -6,13 +6,13 @@ QPDF_Bool::QPDF_Bool(bool val) : { } -std::shared_ptr +std::shared_ptr QPDF_Bool::create(bool value) { return do_create(new QPDF_Bool(value)); } -std::shared_ptr +std::shared_ptr QPDF_Bool::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Destroyed.cc b/libqpdf/QPDF_Destroyed.cc index 55308c9a..e12a9975 100644 --- a/libqpdf/QPDF_Destroyed.cc +++ b/libqpdf/QPDF_Destroyed.cc @@ -14,7 +14,7 @@ QPDF_Destroyed::getInstance() return instance; } -std::shared_ptr +std::shared_ptr QPDF_Destroyed::shallowCopy() { throw std::logic_error( diff --git a/libqpdf/QPDF_Dictionary.cc b/libqpdf/QPDF_Dictionary.cc index bf694949..afbaba4b 100644 --- a/libqpdf/QPDF_Dictionary.cc +++ b/libqpdf/QPDF_Dictionary.cc @@ -9,13 +9,13 @@ QPDF_Dictionary::QPDF_Dictionary( { } -std::shared_ptr +std::shared_ptr QPDF_Dictionary::create(std::map const& items) { return do_create(new QPDF_Dictionary(items)); } -std::shared_ptr +std::shared_ptr QPDF_Dictionary::shallowCopy() { return create(items); diff --git a/libqpdf/QPDF_InlineImage.cc b/libqpdf/QPDF_InlineImage.cc index a675514a..76318196 100644 --- a/libqpdf/QPDF_InlineImage.cc +++ b/libqpdf/QPDF_InlineImage.cc @@ -6,13 +6,13 @@ QPDF_InlineImage::QPDF_InlineImage(std::string const& val) : { } -std::shared_ptr +std::shared_ptr QPDF_InlineImage::create(std::string const& val) { return do_create(new QPDF_InlineImage(val)); } -std::shared_ptr +std::shared_ptr QPDF_InlineImage::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Integer.cc b/libqpdf/QPDF_Integer.cc index cb9066bd..24812573 100644 --- a/libqpdf/QPDF_Integer.cc +++ b/libqpdf/QPDF_Integer.cc @@ -8,13 +8,13 @@ QPDF_Integer::QPDF_Integer(long long val) : { } -std::shared_ptr +std::shared_ptr QPDF_Integer::create(long long value) { return do_create(new QPDF_Integer(value)); } -std::shared_ptr +std::shared_ptr QPDF_Integer::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Name.cc b/libqpdf/QPDF_Name.cc index e793affb..c86d34b4 100644 --- a/libqpdf/QPDF_Name.cc +++ b/libqpdf/QPDF_Name.cc @@ -10,13 +10,13 @@ QPDF_Name::QPDF_Name(std::string const& name) : { } -std::shared_ptr +std::shared_ptr QPDF_Name::create(std::string const& name) { return do_create(new QPDF_Name(name)); } -std::shared_ptr +std::shared_ptr QPDF_Name::shallowCopy() { return create(name); diff --git a/libqpdf/QPDF_Null.cc b/libqpdf/QPDF_Null.cc index 0b824828..f60dda1f 100644 --- a/libqpdf/QPDF_Null.cc +++ b/libqpdf/QPDF_Null.cc @@ -5,13 +5,13 @@ QPDF_Null::QPDF_Null() : { } -std::shared_ptr +std::shared_ptr QPDF_Null::create() { return do_create(new QPDF_Null()); } -std::shared_ptr +std::shared_ptr QPDF_Null::shallowCopy() { return create(); diff --git a/libqpdf/QPDF_Operator.cc b/libqpdf/QPDF_Operator.cc index f29ab23d..547ff40a 100644 --- a/libqpdf/QPDF_Operator.cc +++ b/libqpdf/QPDF_Operator.cc @@ -6,13 +6,13 @@ QPDF_Operator::QPDF_Operator(std::string const& val) : { } -std::shared_ptr +std::shared_ptr QPDF_Operator::create(std::string const& val) { return do_create(new QPDF_Operator(val)); } -std::shared_ptr +std::shared_ptr QPDF_Operator::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Real.cc b/libqpdf/QPDF_Real.cc index 32c03b63..85c9ceeb 100644 --- a/libqpdf/QPDF_Real.cc +++ b/libqpdf/QPDF_Real.cc @@ -15,20 +15,20 @@ QPDF_Real::QPDF_Real( { } -std::shared_ptr +std::shared_ptr QPDF_Real::create(std::string const& val) { return do_create(new QPDF_Real(val)); } -std::shared_ptr +std::shared_ptr QPDF_Real::create(double value, int decimal_places, bool trim_trailing_zeroes) { return do_create( new QPDF_Real(value, decimal_places, trim_trailing_zeroes)); } -std::shared_ptr +std::shared_ptr QPDF_Real::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Reserved.cc b/libqpdf/QPDF_Reserved.cc index 9e795e57..b3669320 100644 --- a/libqpdf/QPDF_Reserved.cc +++ b/libqpdf/QPDF_Reserved.cc @@ -7,13 +7,13 @@ QPDF_Reserved::QPDF_Reserved() : { } -std::shared_ptr +std::shared_ptr QPDF_Reserved::create() { return do_create(new QPDF_Reserved()); } -std::shared_ptr +std::shared_ptr QPDF_Reserved::shallowCopy() { return create(); diff --git a/libqpdf/QPDF_Stream.cc b/libqpdf/QPDF_Stream.cc index 83610e94..e2878904 100644 --- a/libqpdf/QPDF_Stream.cc +++ b/libqpdf/QPDF_Stream.cc @@ -130,7 +130,7 @@ QPDF_Stream::QPDF_Stream( qpdf, qpdf->getFilename() + ", stream object " + og.unparse(' ')); } -std::shared_ptr +std::shared_ptr QPDF_Stream::create( QPDF* qpdf, QPDFObjGen const& og, @@ -141,7 +141,7 @@ QPDF_Stream::create( return do_create(new QPDF_Stream(qpdf, og, stream_dict, offset, length)); } -std::shared_ptr +std::shared_ptr QPDF_Stream::shallowCopy() { throw std::logic_error("stream objects cannot be cloned"); diff --git a/libqpdf/QPDF_String.cc b/libqpdf/QPDF_String.cc index a9819325..c6cb6c41 100644 --- a/libqpdf/QPDF_String.cc +++ b/libqpdf/QPDF_String.cc @@ -26,13 +26,13 @@ QPDF_String::QPDF_String(std::string const& val) : { } -std::shared_ptr +std::shared_ptr QPDF_String::create(std::string const& val) { return do_create(new QPDF_String(val)); } -std::shared_ptr +std::shared_ptr QPDF_String::create_utf16(std::string const& utf8_val) { std::string result; @@ -42,7 +42,7 @@ QPDF_String::create_utf16(std::string const& utf8_val) return do_create(new QPDF_String(result)); } -std::shared_ptr +std::shared_ptr QPDF_String::shallowCopy() { return create(val); diff --git a/libqpdf/QPDF_Unresolved.cc b/libqpdf/QPDF_Unresolved.cc index 79553c1e..c069842b 100644 --- a/libqpdf/QPDF_Unresolved.cc +++ b/libqpdf/QPDF_Unresolved.cc @@ -7,13 +7,13 @@ QPDF_Unresolved::QPDF_Unresolved(QPDF* qpdf, QPDFObjGen const& og) : { } -std::shared_ptr +std::shared_ptr QPDF_Unresolved::create(QPDF* qpdf, QPDFObjGen const& og) { return do_create(new QPDF_Unresolved(qpdf, og)); } -std::shared_ptr +std::shared_ptr QPDF_Unresolved::shallowCopy() { throw std::logic_error( diff --git a/libqpdf/qpdf/QPDFObject_private.hh b/libqpdf/qpdf/QPDFObject_private.hh index 84aaabe4..42bd02b5 100644 --- a/libqpdf/qpdf/QPDFObject_private.hh +++ b/libqpdf/qpdf/QPDFObject_private.hh @@ -16,14 +16,14 @@ class QPDF; class QPDFObjectHandle; -class QPDFValueProxy +class QPDFObject { friend class QPDFValue; public: - QPDFValueProxy() = default; + QPDFObject() = default; - std::shared_ptr + std::shared_ptr shallowCopy() { return value->shallowCopy(); @@ -91,12 +91,12 @@ class QPDFValueProxy return value->getParsedOffset(); } void - assign(std::shared_ptr o) + assign(std::shared_ptr o) { value = o->value; } void - swapWith(std::shared_ptr o) + swapWith(std::shared_ptr o) { auto v = value; value = o->value; @@ -148,8 +148,8 @@ class QPDFValueProxy } private: - QPDFValueProxy(QPDFValueProxy const&) = delete; - QPDFValueProxy& operator=(QPDFValueProxy const&) = delete; + QPDFObject(QPDFObject const&) = delete; + QPDFObject& operator=(QPDFObject const&) = delete; std::shared_ptr value; }; diff --git a/libqpdf/qpdf/QPDFValue.hh b/libqpdf/qpdf/QPDFValue.hh index dbde018c..0f85f79f 100644 --- a/libqpdf/qpdf/QPDFValue.hh +++ b/libqpdf/qpdf/QPDFValue.hh @@ -11,16 +11,16 @@ class QPDF; class QPDFObjectHandle; -class QPDFValueProxy; +class QPDFObject; class QPDFValue { - friend class QPDFValueProxy; + friend class QPDFObject; public: virtual ~QPDFValue() = default; - virtual std::shared_ptr shallowCopy() = 0; + virtual std::shared_ptr shallowCopy() = 0; virtual std::string unparse() = 0; virtual JSON getJSON(int json_version) = 0; virtual void @@ -91,7 +91,7 @@ class QPDFValue { } - static std::shared_ptr do_create(QPDFValue*); + static std::shared_ptr do_create(QPDFValue*); private: QPDFValue(QPDFValue const&) = delete; diff --git a/libqpdf/qpdf/QPDF_Array.hh b/libqpdf/qpdf/QPDF_Array.hh index 8fb227da..61482848 100644 --- a/libqpdf/qpdf/QPDF_Array.hh +++ b/libqpdf/qpdf/QPDF_Array.hh @@ -11,10 +11,10 @@ class QPDF_Array: public QPDFValue { public: virtual ~QPDF_Array() = default; - static std::shared_ptr + static std::shared_ptr create(std::vector const& items); - static std::shared_ptr create(SparseOHArray const& items); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(SparseOHArray const& items); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); virtual void disconnect(); diff --git a/libqpdf/qpdf/QPDF_Bool.hh b/libqpdf/qpdf/QPDF_Bool.hh index 33704176..3e45cd8e 100644 --- a/libqpdf/qpdf/QPDF_Bool.hh +++ b/libqpdf/qpdf/QPDF_Bool.hh @@ -7,8 +7,8 @@ class QPDF_Bool: public QPDFValue { public: virtual ~QPDF_Bool() = default; - static std::shared_ptr create(bool val); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(bool val); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); bool getVal() const; diff --git a/libqpdf/qpdf/QPDF_Destroyed.hh b/libqpdf/qpdf/QPDF_Destroyed.hh index 78c2d601..def4346a 100644 --- a/libqpdf/qpdf/QPDF_Destroyed.hh +++ b/libqpdf/qpdf/QPDF_Destroyed.hh @@ -7,7 +7,7 @@ class QPDF_Destroyed: public QPDFValue { public: virtual ~QPDF_Destroyed() = default; - virtual std::shared_ptr shallowCopy(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); static std::shared_ptr getInstance(); diff --git a/libqpdf/qpdf/QPDF_Dictionary.hh b/libqpdf/qpdf/QPDF_Dictionary.hh index 96985fe7..e6ec76fd 100644 --- a/libqpdf/qpdf/QPDF_Dictionary.hh +++ b/libqpdf/qpdf/QPDF_Dictionary.hh @@ -12,9 +12,9 @@ class QPDF_Dictionary: public QPDFValue { public: virtual ~QPDF_Dictionary() = default; - static std::shared_ptr + static std::shared_ptr create(std::map const& items); - virtual std::shared_ptr shallowCopy(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); virtual void disconnect(); diff --git a/libqpdf/qpdf/QPDF_InlineImage.hh b/libqpdf/qpdf/QPDF_InlineImage.hh index 9c21c183..b7bea9c7 100644 --- a/libqpdf/qpdf/QPDF_InlineImage.hh +++ b/libqpdf/qpdf/QPDF_InlineImage.hh @@ -7,8 +7,8 @@ class QPDF_InlineImage: public QPDFValue { public: virtual ~QPDF_InlineImage() = default; - static std::shared_ptr create(std::string const& val); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(std::string const& val); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); std::string getVal() const; diff --git a/libqpdf/qpdf/QPDF_Integer.hh b/libqpdf/qpdf/QPDF_Integer.hh index 448bc059..7e09673c 100644 --- a/libqpdf/qpdf/QPDF_Integer.hh +++ b/libqpdf/qpdf/QPDF_Integer.hh @@ -7,8 +7,8 @@ class QPDF_Integer: public QPDFValue { public: virtual ~QPDF_Integer() = default; - static std::shared_ptr create(long long value); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(long long value); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); long long getVal() const; diff --git a/libqpdf/qpdf/QPDF_Name.hh b/libqpdf/qpdf/QPDF_Name.hh index bf46ee14..74fc7e44 100644 --- a/libqpdf/qpdf/QPDF_Name.hh +++ b/libqpdf/qpdf/QPDF_Name.hh @@ -7,8 +7,8 @@ class QPDF_Name: public QPDFValue { public: virtual ~QPDF_Name() = default; - static std::shared_ptr create(std::string const& name); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(std::string const& name); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); std::string getName() const; diff --git a/libqpdf/qpdf/QPDF_Null.hh b/libqpdf/qpdf/QPDF_Null.hh index 90ccda38..68973de9 100644 --- a/libqpdf/qpdf/QPDF_Null.hh +++ b/libqpdf/qpdf/QPDF_Null.hh @@ -7,8 +7,8 @@ class QPDF_Null: public QPDFValue { public: virtual ~QPDF_Null() = default; - static std::shared_ptr create(); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); diff --git a/libqpdf/qpdf/QPDF_Operator.hh b/libqpdf/qpdf/QPDF_Operator.hh index 30c40070..767c0ba0 100644 --- a/libqpdf/qpdf/QPDF_Operator.hh +++ b/libqpdf/qpdf/QPDF_Operator.hh @@ -7,8 +7,8 @@ class QPDF_Operator: public QPDFValue { public: virtual ~QPDF_Operator() = default; - static std::shared_ptr create(std::string const& val); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(std::string const& val); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); std::string getVal() const; diff --git a/libqpdf/qpdf/QPDF_Real.hh b/libqpdf/qpdf/QPDF_Real.hh index 2e5bfa02..dc0f3ff8 100644 --- a/libqpdf/qpdf/QPDF_Real.hh +++ b/libqpdf/qpdf/QPDF_Real.hh @@ -7,10 +7,10 @@ class QPDF_Real: public QPDFValue { public: virtual ~QPDF_Real() = default; - static std::shared_ptr create(std::string const& val); - static std::shared_ptr + static std::shared_ptr create(std::string const& val); + static std::shared_ptr create(double value, int decimal_places, bool trim_trailing_zeroes); - virtual std::shared_ptr shallowCopy(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); std::string getVal(); diff --git a/libqpdf/qpdf/QPDF_Reserved.hh b/libqpdf/qpdf/QPDF_Reserved.hh index 23b72ec3..f90242a9 100644 --- a/libqpdf/qpdf/QPDF_Reserved.hh +++ b/libqpdf/qpdf/QPDF_Reserved.hh @@ -7,8 +7,8 @@ class QPDF_Reserved: public QPDFValue { public: virtual ~QPDF_Reserved() = default; - static std::shared_ptr create(); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); diff --git a/libqpdf/qpdf/QPDF_Stream.hh b/libqpdf/qpdf/QPDF_Stream.hh index bf7dbca7..935476af 100644 --- a/libqpdf/qpdf/QPDF_Stream.hh +++ b/libqpdf/qpdf/QPDF_Stream.hh @@ -17,13 +17,13 @@ class QPDF_Stream: public QPDFValue { public: virtual ~QPDF_Stream() = default; - static std::shared_ptr create( + static std::shared_ptr create( QPDF*, QPDFObjGen const& og, QPDFObjectHandle stream_dict, qpdf_offset_t offset, size_t length); - virtual std::shared_ptr shallowCopy(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); virtual void setDescription(QPDF*, std::string const&); diff --git a/libqpdf/qpdf/QPDF_String.hh b/libqpdf/qpdf/QPDF_String.hh index a2cf9246..a92427e3 100644 --- a/libqpdf/qpdf/QPDF_String.hh +++ b/libqpdf/qpdf/QPDF_String.hh @@ -11,10 +11,10 @@ class QPDF_String: public QPDFValue public: virtual ~QPDF_String() = default; - static std::shared_ptr create(std::string const& val); - static std::shared_ptr + static std::shared_ptr create(std::string const& val); + static std::shared_ptr create_utf16(std::string const& utf8_val); - virtual std::shared_ptr shallowCopy(); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); std::string unparse(bool force_binary); virtual JSON getJSON(int json_version); diff --git a/libqpdf/qpdf/QPDF_Unresolved.hh b/libqpdf/qpdf/QPDF_Unresolved.hh index 80d27102..efcf4e3d 100644 --- a/libqpdf/qpdf/QPDF_Unresolved.hh +++ b/libqpdf/qpdf/QPDF_Unresolved.hh @@ -7,9 +7,8 @@ class QPDF_Unresolved: public QPDFValue { public: virtual ~QPDF_Unresolved() = default; - static std::shared_ptr - create(QPDF* qpdf, QPDFObjGen const& og); - virtual std::shared_ptr shallowCopy(); + static std::shared_ptr create(QPDF* qpdf, QPDFObjGen const& og); + virtual std::shared_ptr shallowCopy(); virtual std::string unparse(); virtual JSON getJSON(int json_version); diff --git a/manual/design.rst b/manual/design.rst index 3c402438..4b889b73 100644 --- a/manual/design.rst +++ b/manual/design.rst @@ -349,18 +349,18 @@ Objects in qpdf 11 and Newer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The object cache in ``QPDF`` contains a shared pointer to -``QPDFValueProxy``. Any ``QPDFObjectHandle`` resolved from an indirect +``QPDFObject``. Any ``QPDFObjectHandle`` resolved from an indirect reference to that object has a copy of that shared pointer. Each -``QPDFValueProxy`` object contains a shared pointer to an object of -type ``QPDFValue``. The ``QPDFValue`` type is an abstract base class. -There is an implementation for each of the basic object types (array, +``QPDFObject`` object contains a shared pointer to an object of type +``QPDFValue``. The ``QPDFValue`` type is an abstract base class. There +is an implementation for each of the basic object types (array, dictionary, null, boolean, string, number, etc.) as well as a few -special ones including ``uninitialized``, ``unresolved``, and -``reserved``. When an object is first referenced, its underlying -``QPDFValue`` has type ``unresolved``. When the object is first -resolved, the ``QPDFValueProxy`` in the cache has its internal +special ones including ``uninitialized``, ``unresolved``, +``reserved``, and ``destroyed``. When an object is first referenced, +its underlying ``QPDFValue`` has type ``unresolved``. When the object +is first resolved, the ``QPDFObject`` in the cache has its internal ``QPDFValue`` replaced with the object as read from the file. Since it -is the ``QPDFValueProxy`` object that is shared by all referencing +is the ``QPDFObject`` object that is shared by all referencing ``QPDFObjectHandle`` objects as well as by the owning ``QPDF`` object, this ensures that any future changes to the object, including replacing the object with a completely different one, will be @@ -368,22 +368,24 @@ reflected across all ``QPDFObjectHandle`` objects that reference it. A ``QPDFValue`` that originated from a PDF input source maintains a pointer to the ``QPDF`` object that read it (its *owner*). When that -``QPDF`` object is destroyed, it replaces the value of each -``QPDFValueProxy`` in its cache with a direct ``null`` object and -clears the pointer to the owning ``QPDF``. This means that, if there -are still any referencing ``QPDFObjectHandle`` objects floating -around, requesting their owning ``QPDF`` will return a null pointer -rather than a pointer to a ``QPDF`` object that is either invalid or -points to something else. This operation also has the effect of -breaking any circular references (which are common and, in some cases, -required by the PDF specification), thus preventing memory leaks when -``QPDF`` objects are destroyed. +``QPDF`` object is destroyed, it disconnects all reachable from it by +clearing their owner. For indirect objects (all objects in the object +cache), it also replaces the object's value with an object of type +``destroyed``. This means that, if there are still any referencing +``QPDFObjectHandle`` objects floating around, requesting their owning +``QPDF`` will return a null pointer rather than a pointer to a +``QPDF`` object that is either invalid or points to something else, +and any attempt to access an indirect object that is associated with a +destroyed ``QPDF`` object will throw an exception. This operation also +has the effect of breaking any circular references (which are common +and, in some cases, required by the PDF specification), thus +preventing memory leaks when ``QPDF`` objects are destroyed. Objects prior to qpdf 11 ~~~~~~~~~~~~~~~~~~~~~~~~ Prior to qpdf 11, the functionality of the ``QPDFValue`` and -``QPDFValueProxy`` classes were combined into a single ``QPDFObject`` +``QPDFObject`` classes were contained in a single ``QPDFObject`` class, which served the dual purpose of being the cache entry for ``QPDF`` and being the abstract base class for all the different PDF object types. The behavior was nearly the same, but there were a few @@ -415,7 +417,7 @@ problems: was still valid. All of these problems were effectively solved by splitting -``QPDFObject`` into ``QPDFValueProxy`` and ``QPDFValue``. +``QPDFObject`` into ``QPDFObject`` and ``QPDFValue``. .. _casting: