octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2025-01-22 22:58:33 +00:00
Code Issues Releases Wiki Activity

Rename QPDFValueProxy back to QPDFObject

Browse Source 
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.
This commit is contained in:
Jay Berkenbilt 2022-09-08 11:29:23 -04:00
parent 25ccc7eae4
commit 18a583e8d9
38 changed files with 113 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TODO
View File

@ -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.

12
include/qpdf/QPDF.hh
View File

@ -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<QPDFValueProxy> object,
std::shared_ptr<QPDFObject> object,
qpdf_offset_t end_before_space,
qpdf_offset_t end_after_space) :
object(object),
@ -961,7 +961,7 @@ class QPDF
{
}
std::shared_ptr<QPDFValueProxy> object;
std::shared_ptr<QPDFObject> 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<QPDFValueProxy> const&);
newIndirect(QPDFObjGen const&, std::shared_ptr<QPDFObject> const&);
bool isCached(QPDFObjGen const& og);
bool isUnresolved(QPDFObjGen const& og);
void updateCache(
QPDFObjGen const& og,
std::shared_ptr<QPDFValueProxy> const& object,
std::shared_ptr<QPDFObject> const& object,
qpdf_offset_t end_before_space,
qpdf_offset_t end_after_space);

10
include/qpdf/QPDFObjectHandle.hh
View File

@ -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<QPDFValueProxy> const& obj)
newIndirect(std::shared_ptr<QPDFObject> const& obj)
{
return QPDFObjectHandle(obj);
}
@ -1518,7 +1518,7 @@ class QPDFObjectHandle
friend class QPDF;
private:
static std::shared_ptr<QPDFValueProxy>
static std::shared_ptr<QPDFObject>
getObject(QPDFObjectHandle& o)
{
if (!o.dereference()) {
@ -1617,7 +1617,7 @@ class QPDFObjectHandle
bool isImage(bool exclude_imagemask = true);
private:
QPDFObjectHandle(std::shared_ptr<QPDFValueProxy> const& obj) :
QPDFObjectHandle(std::shared_ptr<QPDFObject> 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<QPDFValueProxy> obj;
std::shared_ptr<QPDFObject> obj;
};
#ifndef QPDF_NO_QPDF_STRING

5
libqpdf/QPDF.cc
View File

@ -2120,8 +2120,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
}
QPDFObjectHandle
QPDF::newIndirect(
QPDFObjGen const& og, std::shared_ptr<QPDFValueProxy> const& obj)
QPDF::newIndirect(QPDFObjGen const& og, std::shared_ptr<QPDFObject> const& obj)
{
obj->setObjGen(this, og);
if (!obj->hasDescription()) {
@ -2133,7 +2132,7 @@ QPDF::newIndirect(
void
QPDF::updateCache(
QPDFObjGen const& og,
std::shared_ptr<QPDFValueProxy> const& object,
std::shared_ptr<QPDFObject> const& object,
qpdf_offset_t end_before_space,
qpdf_offset_t end_after_space)
{

4
libqpdf/QPDFObject.cc
View File

@ -4,14 +4,14 @@
#include <qpdf/QPDF_Destroyed.hh>
void
QPDFValueProxy::doResolve()
QPDFObject::doResolve()
{
auto og = value->og;
QPDF::Resolver::resolve(value->qpdf, og);
}
void
QPDFValueProxy::destroy()
QPDFObject::destroy()
{
value = QPDF_Destroyed::getInstance();
}

2
libqpdf/QPDFObjectHandle.cc
View File

@ -2287,7 +2287,7 @@ QPDFObjectHandle::copyObject(
" reserved object handle direct");
}
std::shared_ptr<QPDFValueProxy> new_obj;
std::shared_ptr<QPDFObject> new_obj;
if (isBool() || isInteger() || isName() || isNull() || isReal() ||
isString()) {

4
libqpdf/QPDFValue.cc
View File

@ -2,10 +2,10 @@
#include <qpdf/QPDFObject_private.hh>
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDFValue::do_create(QPDFValue* object)
{
std::shared_ptr<QPDFValueProxy> obj(new QPDFValueProxy());
std::shared_ptr<QPDFObject> obj(new QPDFObject());
obj->value = std::shared_ptr<QPDFValue>(object);
return obj;
}

6
libqpdf/QPDF_Array.cc
View File

@ -16,19 +16,19 @@ QPDF_Array::QPDF_Array(SparseOHArray const& items) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Array::create(std::vector<QPDFObjectHandle> const& items)
{
return do_create(new QPDF_Array(items));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Array::create(SparseOHArray const& items)
{
return do_create(new QPDF_Array(items));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Array::shallowCopy()
{
return create(elements);

4
libqpdf/QPDF_Bool.cc
View File

@ -6,13 +6,13 @@ QPDF_Bool::QPDF_Bool(bool val) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Bool::create(bool value)
{
return do_create(new QPDF_Bool(value));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Bool::shallowCopy()
{
return create(val);

2
libqpdf/QPDF_Destroyed.cc
View File

@ -14,7 +14,7 @@ QPDF_Destroyed::getInstance()
return instance;
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Destroyed::shallowCopy()
{
throw std::logic_error(

4
libqpdf/QPDF_Dictionary.cc
View File

@ -9,13 +9,13 @@ QPDF_Dictionary::QPDF_Dictionary(
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Dictionary::create(std::map<std::string, QPDFObjectHandle> const& items)
{
return do_create(new QPDF_Dictionary(items));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Dictionary::shallowCopy()
{
return create(items);

4
libqpdf/QPDF_InlineImage.cc
View File

@ -6,13 +6,13 @@ QPDF_InlineImage::QPDF_InlineImage(std::string const& val) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_InlineImage::create(std::string const& val)
{
return do_create(new QPDF_InlineImage(val));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_InlineImage::shallowCopy()
{
return create(val);

4
libqpdf/QPDF_Integer.cc
View File

@ -8,13 +8,13 @@ QPDF_Integer::QPDF_Integer(long long val) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Integer::create(long long value)
{
return do_create(new QPDF_Integer(value));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Integer::shallowCopy()
{
return create(val);

4
libqpdf/QPDF_Name.cc
View File

@ -10,13 +10,13 @@ QPDF_Name::QPDF_Name(std::string const& name) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Name::create(std::string const& name)
{
return do_create(new QPDF_Name(name));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Name::shallowCopy()
{
return create(name);

4
libqpdf/QPDF_Null.cc
View File

@ -5,13 +5,13 @@ QPDF_Null::QPDF_Null() :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Null::create()
{
return do_create(new QPDF_Null());
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Null::shallowCopy()
{
return create();

4
libqpdf/QPDF_Operator.cc
View File

@ -6,13 +6,13 @@ QPDF_Operator::QPDF_Operator(std::string const& val) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Operator::create(std::string const& val)
{
return do_create(new QPDF_Operator(val));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Operator::shallowCopy()
{
return create(val);

6
libqpdf/QPDF_Real.cc
View File

@ -15,20 +15,20 @@ QPDF_Real::QPDF_Real(
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Real::create(std::string const& val)
{
return do_create(new QPDF_Real(val));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
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<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Real::shallowCopy()
{
return create(val);

4
libqpdf/QPDF_Reserved.cc
View File

@ -7,13 +7,13 @@ QPDF_Reserved::QPDF_Reserved() :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Reserved::create()
{
return do_create(new QPDF_Reserved());
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Reserved::shallowCopy()
{
return create();

4
libqpdf/QPDF_Stream.cc
View File

@ -130,7 +130,7 @@ QPDF_Stream::QPDF_Stream(
qpdf, qpdf->getFilename() + ", stream object " + og.unparse(' '));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
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<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Stream::shallowCopy()
{
throw std::logic_error("stream objects cannot be cloned");

6
libqpdf/QPDF_String.cc
View File

@ -26,13 +26,13 @@ QPDF_String::QPDF_String(std::string const& val) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_String::create(std::string const& val)
{
return do_create(new QPDF_String(val));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
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<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_String::shallowCopy()
{
return create(val);

4
libqpdf/QPDF_Unresolved.cc
View File

@ -7,13 +7,13 @@ QPDF_Unresolved::QPDF_Unresolved(QPDF* qpdf, QPDFObjGen const& og) :
{
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Unresolved::create(QPDF* qpdf, QPDFObjGen const& og)
{
return do_create(new QPDF_Unresolved(qpdf, og));
}
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
QPDF_Unresolved::shallowCopy()
{
throw std::logic_error(

14
libqpdf/qpdf/QPDFObject_private.hh
View File

@ -16,14 +16,14 @@
class QPDF;
class QPDFObjectHandle;
class QPDFValueProxy
class QPDFObject
{
friend class QPDFValue;
public:
QPDFValueProxy() = default;
QPDFObject() = default;
std::shared_ptr<QPDFValueProxy>
std::shared_ptr<QPDFObject>
shallowCopy()
{
return value->shallowCopy();
@ -91,12 +91,12 @@ class QPDFValueProxy
return value->getParsedOffset();
}
void
assign(std::shared_ptr<QPDFValueProxy> o)
assign(std::shared_ptr<QPDFObject> o)
{
value = o->value;
}
void
swapWith(std::shared_ptr<QPDFValueProxy> o)
swapWith(std::shared_ptr<QPDFObject> 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<QPDFValue> value;
};

8
libqpdf/qpdf/QPDFValue.hh
View File

@ -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<QPDFValueProxy> shallowCopy() = 0;
virtual std::shared_ptr<QPDFObject> 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<QPDFValueProxy> do_create(QPDFValue*);
static std::shared_ptr<QPDFObject> do_create(QPDFValue*);
private:
QPDFValue(QPDFValue const&) = delete;

6
libqpdf/qpdf/QPDF_Array.hh
View File

@ -11,10 +11,10 @@ class QPDF_Array: public QPDFValue
{
public:
virtual ~QPDF_Array() = default;
static std::shared_ptr<QPDFValueProxy>
static std::shared_ptr<QPDFObject>
create(std::vector<QPDFObjectHandle> const& items);
static std::shared_ptr<QPDFValueProxy> create(SparseOHArray const& items);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(SparseOHArray const& items);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
virtual void disconnect();

4
libqpdf/qpdf/QPDF_Bool.hh
View File

@ -7,8 +7,8 @@ class QPDF_Bool: public QPDFValue
{
public:
virtual ~QPDF_Bool() = default;
static std::shared_ptr<QPDFValueProxy> create(bool val);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(bool val);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
bool getVal() const;

2
libqpdf/qpdf/QPDF_Destroyed.hh
View File

@ -7,7 +7,7 @@ class QPDF_Destroyed: public QPDFValue
{
public:
virtual ~QPDF_Destroyed() = default;
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
static std::shared_ptr<QPDFValue> getInstance();

4
libqpdf/qpdf/QPDF_Dictionary.hh
View File

@ -12,9 +12,9 @@ class QPDF_Dictionary: public QPDFValue
{
public:
virtual ~QPDF_Dictionary() = default;
static std::shared_ptr<QPDFValueProxy>
static std::shared_ptr<QPDFObject>
create(std::map<std::string, QPDFObjectHandle> const& items);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
virtual void disconnect();

4
libqpdf/qpdf/QPDF_InlineImage.hh
View File

@ -7,8 +7,8 @@ class QPDF_InlineImage: public QPDFValue
{
public:
virtual ~QPDF_InlineImage() = default;
static std::shared_ptr<QPDFValueProxy> create(std::string const& val);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(std::string const& val);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
std::string getVal() const;

4
libqpdf/qpdf/QPDF_Integer.hh
View File

@ -7,8 +7,8 @@ class QPDF_Integer: public QPDFValue
{
public:
virtual ~QPDF_Integer() = default;
static std::shared_ptr<QPDFValueProxy> create(long long value);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(long long value);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
long long getVal() const;

4
libqpdf/qpdf/QPDF_Name.hh
View File

@ -7,8 +7,8 @@ class QPDF_Name: public QPDFValue
{
public:
virtual ~QPDF_Name() = default;
static std::shared_ptr<QPDFValueProxy> create(std::string const& name);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(std::string const& name);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
std::string getName() const;

4
libqpdf/qpdf/QPDF_Null.hh
View File

@ -7,8 +7,8 @@ class QPDF_Null: public QPDFValue
{
public:
virtual ~QPDF_Null() = default;
static std::shared_ptr<QPDFValueProxy> create();
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);

4
libqpdf/qpdf/QPDF_Operator.hh
View File

@ -7,8 +7,8 @@ class QPDF_Operator: public QPDFValue
{
public:
virtual ~QPDF_Operator() = default;
static std::shared_ptr<QPDFValueProxy> create(std::string const& val);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(std::string const& val);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
std::string getVal() const;

6
libqpdf/qpdf/QPDF_Real.hh
View File

@ -7,10 +7,10 @@ class QPDF_Real: public QPDFValue
{
public:
virtual ~QPDF_Real() = default;
static std::shared_ptr<QPDFValueProxy> create(std::string const& val);
static std::shared_ptr<QPDFValueProxy>
static std::shared_ptr<QPDFObject> create(std::string const& val);
static std::shared_ptr<QPDFObject>
create(double value, int decimal_places, bool trim_trailing_zeroes);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
std::string getVal();

4
libqpdf/qpdf/QPDF_Reserved.hh
View File

@ -7,8 +7,8 @@ class QPDF_Reserved: public QPDFValue
{
public:
virtual ~QPDF_Reserved() = default;
static std::shared_ptr<QPDFValueProxy> create();
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);

4
libqpdf/qpdf/QPDF_Stream.hh
View File

@ -17,13 +17,13 @@ class QPDF_Stream: public QPDFValue
{
public:
virtual ~QPDF_Stream() = default;
static std::shared_ptr<QPDFValueProxy> create(
static std::shared_ptr<QPDFObject> create(
QPDF*,
QPDFObjGen const& og,
QPDFObjectHandle stream_dict,
qpdf_offset_t offset,
size_t length);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);
virtual void setDescription(QPDF*, std::string const&);

6
libqpdf/qpdf/QPDF_String.hh
View File

@ -11,10 +11,10 @@ class QPDF_String: public QPDFValue
public:
virtual ~QPDF_String() = default;
static std::shared_ptr<QPDFValueProxy> create(std::string const& val);
static std::shared_ptr<QPDFValueProxy>
static std::shared_ptr<QPDFObject> create(std::string const& val);
static std::shared_ptr<QPDFObject>
create_utf16(std::string const& utf8_val);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
std::string unparse(bool force_binary);
virtual JSON getJSON(int json_version);

5
libqpdf/qpdf/QPDF_Unresolved.hh
View File

@ -7,9 +7,8 @@ class QPDF_Unresolved: public QPDFValue
{
public:
virtual ~QPDF_Unresolved() = default;
static std::shared_ptr<QPDFValueProxy>
create(QPDF* qpdf, QPDFObjGen const& og);
virtual std::shared_ptr<QPDFValueProxy> shallowCopy();
static std::shared_ptr<QPDFObject> create(QPDF* qpdf, QPDFObjGen const& og);
virtual std::shared_ptr<QPDFObject> shallowCopy();
virtual std::string unparse();
virtual JSON getJSON(int json_version);

44
manual/design.rst
View File

@ -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: