Refactor `Writer` usage: encapsulate `Linearization` and `Objects` inside `impl:…

…:Doc`, rename related methods, and streamline usage across QPDFWriter and linearization modules.

Refactor `Writer` usage: encapsulate `Linearization` and `Objects` inside `impl:…
…:Doc`, rename related methods, and streamline usage across QPDFWriter and linearization modules.
m-holger
1 parent efde6274
Showing 5 changed files with 30 additions and 88 deletions
libqpdf/QPDF.cc
libqpdf/QPDFWriter.cc
libqpdf/QPDF_linearization.cc
libqpdf/QPDF_objects.cc
libqpdf/qpdf/QPDF_private.hh
@@ -723,11 +723,11 @@ QPDF::getRoot()
 std::map<QPDFObjGen, QPDFXRefEntry>
 QPDF::getXRefTable()
 {
-    return m->objects.getXRefTableInternal();
+    return m->objects.xref_table();
 }
  
 std::map<QPDFObjGen, QPDFXRefEntry> const&
-Objects::getXRefTableInternal()
+Objects::xref_table()
 {
     if (!m->parsed) {
         throw std::logic_error("QPDF::getXRefTable called before parsing.");
@@ -262,75 +262,17 @@ Pl_stack::Popper::pop()
 }
  
 // Writer class is restricted to QPDFWriter so that only it can call certain methods.
-class QPDF::Doc::Writer: QPDF::Doc::Common
+class impl::Doc::Writer: impl::Doc::Common
 {
     friend class QPDFWriter;
     Writer(QPDF& qpdf) :
         Common(qpdf, qpdf.doc().m),
-        lin(m->lin),
-        objects(m->objects)
+        lin(m->lin)
     {
     }
  
   protected:
-    void
-    optimize(
-        QPDFWriter::ObjTable const& obj,
-        std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
-    {
-        lin.optimize(obj, skip_stream_parameters);
-    }
-
-    void
-    getLinearizedParts(
-        QPDFWriter::ObjTable const& obj,
-        std::vector<QPDFObjectHandle>& part4,
-        std::vector<QPDFObjectHandle>& part6,
-        std::vector<QPDFObjectHandle>& part7,
-        std::vector<QPDFObjectHandle>& part8,
-        std::vector<QPDFObjectHandle>& part9)
-    {
-        lin.getLinearizedParts(obj, part4, part6, part7, part8, part9);
-    }
-
-    void
-    generateHintStream(
-        QPDFWriter::NewObjTable const& new_obj,
-        QPDFWriter::ObjTable const& obj,
-        std::string& hint_stream,
-        int& S,
-        int& O,
-        bool compressed)
-    {
-        lin.generateHintStream(new_obj, obj, hint_stream, S, O, compressed);
-    }
-
-    std::vector<QPDFObjGen>
-    getCompressibleObjGens()
-    {
-        return objects.getCompressibleObjVector();
-    }
-
-    std::vector<bool>
-    getCompressibleObjSet()
-    {
-        return objects.getCompressibleObjSet();
-    }
-
-    std::map<QPDFObjGen, QPDFXRefEntry> const&
-    getXRefTable()
-    {
-        return objects.getXRefTableInternal();
-    }
-
-    size_t
-    tableSize()
-    {
-        return qpdf.m->objects.tableSize();
-    }
-
-    QPDF::Doc::Linearization& lin;
-    QPDF::Doc::Objects& objects;
+    impl::Doc::Linearization& lin;
 };
  
 class QPDFWriter::Members: QPDF::Doc::Writer
@@ -2151,7 +2093,7 @@ QPDFWriter::Members::initializeSpecialStreams()
 void
 QPDFWriter::Members::preserveObjectStreams()
 {
-    auto const& xref = getXRefTable();
+    auto const& xref = objects.xref_table();
     // Our object_to_object_stream map has to map ObjGen -> ObjGen since we may be generating object
     // streams out of old objects that have generation numbers greater than zero. However in an
     // existing PDF, all object stream objects and all objects in them must have generation 0
@@ -2176,9 +2118,9 @@ QPDFWriter::Members::preserveObjectStreams()
             if (iter->second.getType() == 2) {
                 // Pdf contains object streams.
                 obj.streams_empty = false;
-                auto eligible = getCompressibleObjSet();
+                auto eligible = objects.compressible_set();
                 // The object pointed to by iter may be a previous generation, in which case it is
-                // removed by getCompressibleObjSet. We need to restart the loop (while the object
+                // removed by compressible_set. We need to restart the loop (while the object
                 // table may contain multiple generations of an object).
                 for (iter = xref.cbegin(); iter != end; ++iter) {
                     if (iter->second.getType() == 2) {
@@ -2207,7 +2149,7 @@ QPDFWriter::Members::generateObjectStreams()
  
     // This code doesn't do anything with /Extends.
  
-    std::vector<QPDFObjGen> eligible = getCompressibleObjGens();
+    auto eligible = objects.compressible_vector();
     size_t n_object_streams = (eligible.size() + 99U) / 100U;
  
     initializeTables(2U * n_object_streams);
@@ -2288,7 +2230,7 @@ QPDFWriter::Members::prepareFileForWrite()
 void
 QPDFWriter::Members::initializeTables(size_t extra)
 {
-    auto size = QIntC::to_size(tableSize() + 100) + extra;
+    auto size = objects.table_size() + 100u + extra;
     obj.resize(size);
     new_obj.resize(size);
 }
@@ -2568,7 +2510,7 @@ QPDFWriter::Members::writeHintStream(int hint_id)
     int S = 0;
     int O = 0;
     bool compressed = compress_streams;
-    generateHintStream(new_obj, obj, hint_buffer, S, O, compressed);
+    lin.generateHintStream(new_obj, obj, hint_buffer, S, O, compressed);
  
     openObject(hint_id);
     setDataKey(hint_id);
@@ -2771,14 +2713,14 @@ QPDFWriter::Members::writeLinearized()
         }
     };
  
-    optimize(obj, skip_stream_parameters);
+    lin.optimize(obj, skip_stream_parameters);
  
     std::vector<QPDFObjectHandle> part4;
     std::vector<QPDFObjectHandle> part6;
     std::vector<QPDFObjectHandle> part7;
     std::vector<QPDFObjectHandle> part8;
     std::vector<QPDFObjectHandle> part9;
-    getLinearizedParts(obj, part4, part6, part7, part8, part9);
+    lin.parts(obj, part4, part6, part7, part8, part9);
  
     // Object number sequence:
     //
@@ -1681,7 +1681,7 @@ Lin::pushOutlinesToPart(
 }
  
 void
-Lin::getLinearizedParts(
+Lin::parts(
     QPDFWriter::ObjTable const& obj,
     std::vector<QPDFObjectHandle>& part4,
     std::vector<QPDFObjectHandle>& part6,
@@ -1916,7 +1916,7 @@ QPDF::swapObjects(QPDFObjGen og1, QPDFObjGen og2)
 }
  
 size_t
-Objects::tableSize()
+Objects::table_size()
 {
     // If obj_cache is dense, accommodate all object in tables,else accommodate only original
     // objects.
@@ -1936,20 +1936,20 @@ Objects::tableSize()
 }
  
 std::vector<QPDFObjGen>
-Objects::getCompressibleObjVector()
+Objects::compressible_vector()
 {
-    return getCompressibleObjGens<QPDFObjGen>();
+    return compressible<QPDFObjGen>();
 }
  
 std::vector<bool>
-Objects::getCompressibleObjSet()
+Objects::compressible_set()
 {
-    return getCompressibleObjGens<bool>();
+    return compressible<bool>();
 }
  
 template <typename T>
 std::vector<T>
-Objects::getCompressibleObjGens()
+Objects::compressible()
 {
     // Return a list of objects that are allowed to be in object streams.  Walk through the objects
     // by traversing the document from the root, including a traversal of the pages tree.  This
@@ -1969,10 +1969,9 @@ Objects::getCompressibleObjGens()
     std::vector<T> result;
     if constexpr (std::is_same_v<T, QPDFObjGen>) {
         result.reserve(m->obj_cache.size());
-    } else if constexpr (std::is_same_v<T, bool>) {
-        result.resize(max_obj + 1U, false);
     } else {
-        throw std::logic_error("Unsupported type in QPDF::getCompressibleObjGens");
+        qpdf_static_expect(std::is_same_v<T, bool>);
+        result.resize(max_obj + 1U, false);
     }
     while (!queue.empty()) {
         auto obj = queue.back();
@@ -573,7 +573,7 @@ class QPDF::Doc::Linearization: Common
  
     // Get lists of all objects in order according to the part of a linearized file that they
     // belong to.
-    void getLinearizedParts(
+    void parts(
         QPDFWriter::ObjTable const& obj,
         std::vector<QPDFObjectHandle>& part4,
         std::vector<QPDFObjectHandle>& part6,
@@ -993,18 +993,19 @@ class QPDF::Doc::Objects: Common
     QPDFObjectHandle makeIndirectFromQPDFObject(std::shared_ptr<QPDFObject> const& obj);
     std::shared_ptr<QPDFObject> getObjectForParser(int id, int gen, bool parse_pdf);
     std::shared_ptr<QPDFObject> getObjectForJSON(int id, int gen);
-    size_t tableSize();
+    size_t table_size();
  
     // For QPDFWriter:
  
-    std::map<QPDFObjGen, QPDFXRefEntry> const& getXRefTableInternal();
+    std::map<QPDFObjGen, QPDFXRefEntry> const& xref_table();
+    std::vector<QPDFObjGen> compressible_vector();
+    std::vector<bool> compressible_set();
+
+  private:
     // Get a list of objects that would be permitted in an object stream.
     template <typename T>
-    std::vector<T> getCompressibleObjGens();
-    std::vector<QPDFObjGen> getCompressibleObjVector();
-    std::vector<bool> getCompressibleObjSet();
+    std::vector<T> compressible();
  
-  private:
     void setTrailer(QPDFObjectHandle obj);
     void reconstruct_xref(QPDFExc& e, bool found_startxref = true);
     void read_xref(qpdf_offset_t offset, bool in_stream_recovery = false);