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.

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<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);
 
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<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
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<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)
 {
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 <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();
 }
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<QPDFValueProxy> new_obj;
+    std::shared_ptr<QPDFObject> 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 <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;
 }
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<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);
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<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);
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<QPDFValueProxy>
+std::shared_ptr<QPDFObject>
 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<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);
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<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);
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<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);
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<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);
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<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();
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<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);
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<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);
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<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();
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<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");
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<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);
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<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(
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<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;
 };
 
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<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;
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<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();
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<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;
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<QPDFValueProxy> shallowCopy();
+    virtual std::shared_ptr<QPDFObject> shallowCopy();
     virtual std::string unparse();
     virtual JSON getJSON(int json_version);
     static std::shared_ptr<QPDFValue> 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<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();
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<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;
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<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;
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<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;
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<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);
 
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<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;
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<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();
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<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);
 
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<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&);
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<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);
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<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);
 
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: