diff --git a/libqpdf/QPDF.cc b/libqpdf/QPDF.cc index 5c72571..c9669b5 100644 --- a/libqpdf/QPDF.cc +++ b/libqpdf/QPDF.cc @@ -723,11 +723,11 @@ QPDF::getRoot() std::map QPDF::getXRefTable() { - return m->objects.getXRefTableInternal(); + return m->objects.xref_table(); } std::map const& -Objects::getXRefTableInternal() +Objects::xref_table() { if (!m->parsed) { throw std::logic_error("QPDF::getXRefTable called before parsing."); diff --git a/libqpdf/QPDFWriter.cc b/libqpdf/QPDFWriter.cc index 6a10919..b0dbf3c 100644 --- a/libqpdf/QPDFWriter.cc +++ b/libqpdf/QPDFWriter.cc @@ -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 skip_stream_parameters) - { - lin.optimize(obj, skip_stream_parameters); - } - - void - getLinearizedParts( - QPDFWriter::ObjTable const& obj, - std::vector& part4, - std::vector& part6, - std::vector& part7, - std::vector& part8, - std::vector& 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 - getCompressibleObjGens() - { - return objects.getCompressibleObjVector(); - } - - std::vector - getCompressibleObjSet() - { - return objects.getCompressibleObjSet(); - } - - std::map 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 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 part4; std::vector part6; std::vector part7; std::vector part8; std::vector part9; - getLinearizedParts(obj, part4, part6, part7, part8, part9); + lin.parts(obj, part4, part6, part7, part8, part9); // Object number sequence: // diff --git a/libqpdf/QPDF_linearization.cc b/libqpdf/QPDF_linearization.cc index dfeb2dc..d5522ad 100644 --- a/libqpdf/QPDF_linearization.cc +++ b/libqpdf/QPDF_linearization.cc @@ -1681,7 +1681,7 @@ Lin::pushOutlinesToPart( } void -Lin::getLinearizedParts( +Lin::parts( QPDFWriter::ObjTable const& obj, std::vector& part4, std::vector& part6, diff --git a/libqpdf/QPDF_objects.cc b/libqpdf/QPDF_objects.cc index cd8a849..b8c43dc 100644 --- a/libqpdf/QPDF_objects.cc +++ b/libqpdf/QPDF_objects.cc @@ -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 -Objects::getCompressibleObjVector() +Objects::compressible_vector() { - return getCompressibleObjGens(); + return compressible(); } std::vector -Objects::getCompressibleObjSet() +Objects::compressible_set() { - return getCompressibleObjGens(); + return compressible(); } template std::vector -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 result; if constexpr (std::is_same_v) { result.reserve(m->obj_cache.size()); - } else if constexpr (std::is_same_v) { - result.resize(max_obj + 1U, false); } else { - throw std::logic_error("Unsupported type in QPDF::getCompressibleObjGens"); + qpdf_static_expect(std::is_same_v); + result.resize(max_obj + 1U, false); } while (!queue.empty()) { auto obj = queue.back(); diff --git a/libqpdf/qpdf/QPDF_private.hh b/libqpdf/qpdf/QPDF_private.hh index ca804eb..8055c84 100644 --- a/libqpdf/qpdf/QPDF_private.hh +++ b/libqpdf/qpdf/QPDF_private.hh @@ -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& part4, std::vector& part6, @@ -993,18 +993,19 @@ class QPDF::Doc::Objects: Common QPDFObjectHandle makeIndirectFromQPDFObject(std::shared_ptr const& obj); std::shared_ptr getObjectForParser(int id, int gen, bool parse_pdf); std::shared_ptr getObjectForJSON(int id, int gen); - size_t tableSize(); + size_t table_size(); // For QPDFWriter: - std::map const& getXRefTableInternal(); + std::map const& xref_table(); + std::vector compressible_vector(); + std::vector compressible_set(); + + private: // Get a list of objects that would be permitted in an object stream. template - std::vector getCompressibleObjGens(); - std::vector getCompressibleObjVector(); - std::vector getCompressibleObjSet(); + std::vector 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);