octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-14 08:44:04 +00:00
Code Issues Releases Wiki Activity
722148de3d
qpdf/libqpdf/NNTree.cc

955 lines
31 KiB
C++
Raw Normal View History

Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
#include <qpdf/NNTree.hh>
Add a blank line after the first header included in each source
2022-02-04 21:31:31 +00:00
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
#include <qpdf/QTC.hh>
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
#include <qpdf/QUtil.hh>
#include <exception>
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
static std::string
get_description(QPDFObjectHandle& node)
{
std::string result("Name/Number tree node");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (node.isIndirect()) {
Replace calls to QUtil::int_to_string with std::to_string
2022-09-21 16:49:21 +00:00
result += " (object " + std::to_string(node.getObjectID()) + ")";
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
}
return result;
}
static void
Remove deprecated name/number tree constructors Remove the name/number tree object helper constructors that don't take a QPDF&.
2022-04-16 17:12:49 +00:00
warn(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
{
Add new QPDF::warn that takes most of QPDFExc's arguments
2022-04-23 22:03:44 +00:00
qpdf.warn(qpdf_e_damaged_pdf, get_description(node), 0, msg);
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
}
static void
Remove deprecated name/number tree constructors Remove the name/number tree object helper constructors that don't take a QPDF&.
2022-04-16 17:12:49 +00:00
error(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
{
Rerun clang-format
2023-05-21 17:35:09 +00:00
throw QPDFExc(qpdf_e_damaged_pdf, qpdf.getFilename(), get_description(node), 0, msg);
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
NNTreeIterator::NNTreeIterator(NNTreeImpl& impl) :
impl(impl),
item_number(-1)
{
}
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
void
NNTreeIterator::updateIValue(bool allow_invalid)
{
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// ivalue should never be used inside the class since we return a pointer/reference to it. Every
// bit of code that ever changes what object the iterator points to should take care to call
// updateIValue. Failure to do this means that any old references to *iter will point to
// incorrect objects, though the next dereference of the iterator will fix it. This isn't
// necessarily catastrophic, but it would be confusing. The test suite attempts to exercise
// various cases to ensure we don't introduce that bug in the future, but sadly it's tricky to
// verify by reasoning about the code that this constraint is always satisfied. Whenever we
// update what the iterator points to, we should call setItemNumber, which calls this. If we
Fix doc typos
2023-05-29 18:26:18 +00:00
// change what the iterator points to in some other way, such as replacing a value or removing
// an item and making the iterator point at a different item in potentially the same position,
// we must call updateIValue as well. These cases are handled, and for good measure, we also
// call updateIValue in operator* and operator->.
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
bool okay = false;
Code tidy: remove redundant calls to QPDFObjectHandle::isInitialized
2022-06-25 14:00:31 +00:00
if ((item_number >= 0) && this->node.isDictionary()) {
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
auto items = this->node.getKey(impl.details.itemsKey());
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number + 1 < items.getArrayNItems()) {
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
okay = true;
this->ivalue.first = items.getArrayItem(this->item_number);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
this->ivalue.second = items.getArrayItem(1 + this->item_number);
} else {
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
error(impl.qpdf, node, "update ivalue: items array is too short");
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!okay) {
if (!allow_invalid) {
throw std::logic_error("attempt made to dereference an invalid"
" name/number tree iterator");
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
}
this->ivalue.first = QPDFObjectHandle();
this->ivalue.second = QPDFObjectHandle();
}
}
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeIterator::PathElement::PathElement(QPDFObjectHandle const& node, int kid_number) :
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
node(node),
kid_number(kid_number)
{
}
QPDFObjectHandle
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
NNTreeIterator::getNextKid(PathElement& pe, bool backward)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
QPDFObjectHandle result;
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
bool found = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (!found) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
pe.kid_number += backward ? -1 : 1;
auto kids = pe.node.getKey("/Kids");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((pe.kid_number >= 0) && (pe.kid_number < kids.getArrayNItems())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
result = kids.getArrayItem(pe.kid_number);
if (result.isDictionary() &&
Rerun clang-format
2023-05-21 17:35:09 +00:00
(result.hasKey("/Kids") || result.hasKey(impl.details.itemsKey()))) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
found = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree skip invalid kid");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
warn(
impl.qpdf,
pe.node,
Rerun clang-format
2023-05-21 17:35:09 +00:00
("skipping over invalid kid at index " + std::to_string(pe.kid_number)));
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
result = QPDFObjectHandle::newNull();
found = true;
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
return result;
}
bool
NNTreeIterator::valid() const
{
return this->item_number >= 0;
}
void
NNTreeIterator::increment(bool backward)
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number < 0) {
name/number trees: newEmpty, increment/decrement end()
2021-01-24 08:55:18 +00:00
QTC::TC("qpdf", "NNTree increment end()");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
deepen(impl.oh, !backward, true);
name/number trees: newEmpty, increment/decrement end()
2021-01-24 08:55:18 +00:00
return;
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
bool found_valid_key = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (valid() && (!found_valid_key)) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
this->item_number += backward ? -2 : 2;
auto items = this->node.getKey(impl.details.itemsKey());
Rerun clang-format
2023-05-21 17:35:09 +00:00
if ((this->item_number < 0) || (this->item_number >= items.getArrayNItems())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
bool found = false;
setItemNumber(QPDFObjectHandle(), -1);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (!(found || this->path.empty())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto& element = this->path.back();
auto pe_node = getNextKid(element, backward);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (pe_node.isNull()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
this->path.pop_back();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
found = deepen(pe_node, !backward, false);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number >= 0) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
items = this->node.getKey(impl.details.itemsKey());
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number + 1 >= items.getArrayNItems()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree skip item at end of short items");
Rerun clang-format
2023-05-21 17:35:09 +00:00
warn(impl.qpdf, this->node, "items array doesn't have enough elements");
} else if (!impl.details.keyValid(items.getArrayItem(this->item_number))) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree skip invalid key");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
warn(
impl.qpdf,
this->node,
Rerun clang-format
2023-05-21 17:35:09 +00:00
("item " + std::to_string(this->item_number) + " has the wrong type"));
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
found_valid_key = true;
}
}
}
}
void
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list<PathElement>::iterator parent)
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
{
bool done = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (!done) {
if (parent == this->path.end()) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree remove limits from root");
node.removeKey("/Limits");
done = true;
break;
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto kids = node.getKey("/Kids");
int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
auto items = node.getKey(impl.details.itemsKey());
int nitems = items.isArray() ? items.getArrayNItems() : 0;
bool changed = true;
QPDFObjectHandle first;
QPDFObjectHandle last;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nitems >= 2) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
first = items.getArrayItem(0);
last = items.getArrayItem((nitems - 1) & ~1);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (nkids > 0) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto first_kid = kids.getArrayItem(0);
auto last_kid = kids.getArrayItem(nkids - 1);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (first_kid.isDictionary() && last_kid.isDictionary()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto first_limits = first_kid.getKey("/Limits");
auto last_limits = last_kid.getKey("/Limits");
Rerun clang-format
2023-05-21 17:35:09 +00:00
if (first_limits.isArray() && (first_limits.getArrayNItems() >= 2) &&
last_limits.isArray() && (last_limits.getArrayNItems() >= 2)) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
first = first_limits.getArrayItem(0);
last = last_limits.getArrayItem(1);
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (first.isInitialized() && last.isInitialized()) {
Back out fluent QPDFObjectHandle methods. Keep the andGet methods. I decided these were confusing and inconsistent with how JSON works. They muddle the API rather than improving it.
2022-05-17 22:28:50 +00:00
auto limits = QPDFObjectHandle::newArray();
limits.appendItem(first);
limits.appendItem(last);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto olimits = node.getKey("/Limits");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (olimits.isArray() && (olimits.getArrayNItems() == 2)) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto ofirst = olimits.getArrayItem(0);
auto olast = olimits.getArrayItem(1);
Rerun clang-format
2023-05-21 17:35:09 +00:00
if (impl.details.keyValid(ofirst) && impl.details.keyValid(olast) &&
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
(impl.details.compareKeys(first, ofirst) == 0) &&
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
(impl.details.compareKeys(last, olast) == 0)) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree limits didn't change");
changed = false;
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (changed) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
node.replaceKey("/Limits", limits);
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree unable to determine limits");
warn(impl.qpdf, node, "unable to determine limits");
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((!changed) || (parent == this->path.begin())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
done = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
node = parent->node;
--parent;
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
void
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeIterator::split(QPDFObjectHandle to_split, std::list<PathElement>::iterator parent)
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
{
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Split some node along the path to the item pointed to by this iterator, and adjust the
// iterator so it points to the same item.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
Fix doc typos
2023-05-29 18:26:18 +00:00
// In examples, for simplicity, /Nums is shown to just contain numbers instead of pairs. Imagine
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// this tree:
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
//
// root: << /Kids [ A B C D ] >>
// A: << /Nums [ 1 2 3 4 ] >>
// B: << /Nums [ 5 6 7 8 ] >>
// C: << /Nums [ 9 10 11 12 ] >>
// D: << /Kids [ E F ]
// E: << /Nums [ 13 14 15 16 ] >>
// F: << /Nums [ 17 18 19 20 ] >>
// iter1 (points to 19)
// path:
// - { node: root: kid_number: 3 }
// - { node: D, kid_number: 1 }
// node: F
// item_number: 2
// iter2 (points to 1)
// path:
// - { node: root, kid_number: 0}
// node: A
// item_number: 0
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!valid()) {
Rerun clang-format
2023-05-21 17:35:09 +00:00
throw std::logic_error("NNTreeIterator::split called an invalid iterator");
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Find the array we actually need to split, which is either this node's kids or items.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto kids = to_split.getKey("/Kids");
int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
auto items = to_split.getKey(impl.details.itemsKey());
int nitems = items.isArray() ? items.getArrayNItems() : 0;
QPDFObjectHandle first_half;
int n = 0;
std::string key;
int threshold = 0;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nkids > 0) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split kids");
first_half = kids;
n = nkids;
threshold = impl.split_threshold;
key = "/Kids";
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (nitems > 0) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split items");
first_half = items;
n = nitems;
threshold = 2 * impl.split_threshold;
key = impl.details.itemsKey();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
throw std::logic_error("NNTreeIterator::split called on invalid node");
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (n <= threshold) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
return;
}
bool is_root = (parent == this->path.end());
bool is_leaf = (nitems > 0);
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// CURRENT STATE: tree is in original state; iterator is valid and unchanged.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (is_root) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// What we want to do is to create a new node for the second half of the items and put it in
// the parent's /Kids array right after the element that points to the current to_split
// node, but if we're splitting root, there is no parent, so handle that first.
// In the non-root case, parent points to the path element whose /Kids contains the first
// half node, and the first half node is to_split. If we are splitting the root, we need to
// push everything down a level, but we want to keep the actual root object the same so that
// indirect references to it remain intact (and also in case it might be a direct object,
// which it shouldn't be but that case probably exists in the wild). To achieve this, we
// create a new node for the first half and then replace /Kids in the root to contain it.
// Then we adjust the path so that the first element is root and the second element, if any,
// is the new first half. In this way, we make the root case identical to the non-root case
// so remaining logic can handle them in the same way.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
Rerun clang-format
2023-05-21 17:35:09 +00:00
auto first_node = impl.qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
first_node.replaceKey(key, first_half);
QPDFObjectHandle new_kids = QPDFObjectHandle::newArray();
new_kids.appendItem(first_node);
Back out fluent QPDFObjectHandle methods. Keep the andGet methods. I decided these were confusing and inconsistent with how JSON works. They muddle the API rather than improving it.
2022-05-17 22:28:50 +00:00
to_split.removeKey("/Limits"); // already shouldn't be there for root
to_split.removeKey(impl.details.itemsKey());
to_split.replaceKey("/Kids", new_kids);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (is_leaf) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split root + leaf");
this->node = first_node;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split root + !leaf");
auto next = this->path.begin();
next->node = first_node;
}
Code tidy - Clang-Tidy rule modernize-use-emplace
2023-05-27 22:49:18 +00:00
this->path.emplace_front(to_split, 0);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
parent = this->path.begin();
to_split = first_node;
}
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// CURRENT STATE: parent is guaranteed to be defined, and we have the invariants that
// parent[/Kids][kid_number] == to_split and (++parent).node == to_split.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Create a second half array, and transfer the second half of the items into the second half
// array.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QPDFObjectHandle second_half = QPDFObjectHandle::newArray();
int start_idx = ((n / 2) & ~1);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (first_half.getArrayNItems() > start_idx) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
second_half.appendItem(first_half.getArrayItem(start_idx));
first_half.eraseItem(start_idx);
}
resetLimits(to_split, parent);
// Create a new node to contain the second half
Rerun clang-format
2023-05-21 17:35:09 +00:00
QPDFObjectHandle second_node = impl.qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
second_node.replaceKey(key, second_half);
resetLimits(second_node, parent);
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// CURRENT STATE: half the items from the kids or items array in the node being split have been
// moved into a new node. The new node is not yet attached to the tree. The iterator may have a
Fix loop detection in NNTree
2021-04-04 21:22:07 +00:00
// path element or leaf node that is out of bounds.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We need to adjust the parent to add the second node to /Kids and, if needed, update
// kid_number to traverse through it. We need to update to_split's path element, or the node if
// this is a leaf, so that the kid/item number points to the right place.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto parent_kids = parent->node.getKey("/Kids");
parent_kids.insertItem(parent->kid_number + 1, second_node);
auto cur_elem = parent;
++cur_elem; // points to end() for leaf nodes
int old_idx = (is_leaf ? this->item_number : cur_elem->kid_number);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (old_idx >= start_idx) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
++parent->kid_number;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (is_leaf) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split second half item");
setItemNumber(second_node, this->item_number - start_idx);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split second half kid");
cur_elem->node = second_node;
cur_elem->kid_number -= start_idx;
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!is_root) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree split parent");
auto next = parent->node;
resetLimits(next, parent);
--parent;
split(next, parent);
}
}
std::list<NNTreeIterator::PathElement>::iterator
NNTreeIterator::lastPathElement()
{
auto result = this->path.end();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!this->path.empty()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
--result;
}
return result;
}
void
NNTreeIterator::insertAfter(QPDFObjectHandle key, QPDFObjectHandle value)
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!valid()) {
name/number trees: insertAfter
2021-01-24 09:16:48 +00:00
QTC::TC("qpdf", "NNTree insertAfter inserts first");
impl.insertFirst(key, value);
deepen(impl.oh, true, false);
return;
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto items = this->node.getKey(impl.details.itemsKey());
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!items.isArray()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
error(impl.qpdf, node, "node contains no items array");
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (items.getArrayNItems() < this->item_number + 2) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
error(impl.qpdf, node, "insert: items array is too short");
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
items.insertItem(this->item_number + 2, key);
items.insertItem(this->item_number + 3, value);
resetLimits(this->node, lastPathElement());
split(this->node, lastPathElement());
name/number trees: insertAfter
2021-01-24 09:16:48 +00:00
increment(false);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
name/number trees: remove
2021-01-24 16:48:46 +00:00
void
NNTreeIterator::remove()
{
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Remove this item, leaving the tree valid and this iterator pointing to the next item.
name/number trees: remove
2021-01-24 16:48:46 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!valid()) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
throw std::logic_error("attempt made to remove an invalid iterator");
}
auto items = this->node.getKey(impl.details.itemsKey());
int nitems = items.getArrayNItems();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number + 2 > nitems) {
Rerun clang-format
2023-05-21 17:35:09 +00:00
error(impl.qpdf, this->node, "found short items array while removing an item");
name/number trees: remove
2021-01-24 16:48:46 +00:00
}
items.eraseItem(this->item_number);
items.eraseItem(this->item_number);
nitems -= 2;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nitems > 0) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
// There are still items left
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((this->item_number == 0) || (this->item_number == nitems)) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We removed either the first or last item of an items array that remains non-empty, so
// we have to adjust limits.
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree remove reset limits");
resetLimits(this->node, lastPathElement());
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number == nitems) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We removed the last item of a non-empty items array, so advance to the successor of
// the previous item.
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased last item");
this->item_number -= 2;
increment(false);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (this->item_number < nitems) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We don't have to do anything since the removed item's successor now occupies its
// former location.
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased non-last item");
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
updateIValue();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We already checked to ensure this condition would not happen.
Rerun clang-format
2023-05-21 17:35:09 +00:00
throw std::logic_error("NNTreeIterator::remove: item_number > nitems after erase");
name/number trees: remove
2021-01-24 16:48:46 +00:00
}
return;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->path.empty()) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Special case: if this is the root node, we can leave it empty.
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased all items on leaf/root");
setItemNumber(impl.oh, -1);
return;
}
QTC::TC("qpdf", "NNTree items is empty after remove");
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We removed the last item from this items array, so we need to remove this node from the
// parent on up the tree. Then we need to position ourselves at the removed item's successor.
name/number trees: remove
2021-01-24 16:48:46 +00:00
bool done = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (!done) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
auto element = lastPathElement();
auto parent = element;
--parent;
auto kids = element->node.getKey("/Kids");
kids.eraseItem(element->kid_number);
auto nkids = kids.getArrayNItems();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nkids > 0) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
// The logic here is similar to the items case.
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((element->kid_number == 0) || (element->kid_number == nkids)) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased first or last kid");
resetLimits(element->node, parent);
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (element->kid_number == nkids) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Move to the successor of the last child of the previous kid.
name/number trees: remove
2021-01-24 16:48:46 +00:00
setItemNumber(QPDFObjectHandle(), -1);
--element->kid_number;
deepen(kids.getArrayItem(element->kid_number), false, true);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (valid()) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
increment(false);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!valid()) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased last item in tree");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree erased last kid");
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
name/number trees: remove
2021-01-24 16:48:46 +00:00
// Next kid is in deleted kid's position
QTC::TC("qpdf", "NNTree erased non-last kid");
deepen(kids.getArrayItem(element->kid_number), true, true);
}
done = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parent == this->path.end()) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// We erased the very last item. Convert the root to an empty items array.
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree non-flat tree is empty after remove");
element->node.removeKey("/Kids");
Rerun clang-format
2023-05-21 17:35:09 +00:00
element->node.replaceKey(impl.details.itemsKey(), QPDFObjectHandle::newArray());
name/number trees: remove
2021-01-24 16:48:46 +00:00
this->path.clear();
setItemNumber(impl.oh, -1);
done = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
name/number trees: remove
2021-01-24 16:48:46 +00:00
// Walk up the tree and continue
QTC::TC("qpdf", "NNTree remove walking up tree");
this->path.pop_back();
}
}
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
NNTreeIterator&
NNTreeIterator::operator++()
{
increment(false);
return *this;
}
NNTreeIterator&
NNTreeIterator::operator--()
{
increment(true);
return *this;
}
NNTreeIterator::reference
NNTreeIterator::operator*()
{
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
updateIValue(false);
return this->ivalue;
}
NNTreeIterator::pointer
NNTreeIterator::operator->()
{
updateIValue(false);
return &(this->ivalue);
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
bool
NNTreeIterator::operator==(NNTreeIterator const& other) const
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((this->item_number == -1) && (other.item_number == -1)) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return true;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->path.size() != other.path.size()) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return false;
}
auto tpi = this->path.begin();
auto opi = other.path.begin();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (tpi != this->path.end()) {
if (tpi->kid_number != opi->kid_number) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return false;
}
++tpi;
++opi;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->item_number != other.item_number) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return false;
}
return true;
}
void
NNTreeIterator::setItemNumber(QPDFObjectHandle const& node, int n)
{
this->node = node;
this->item_number = n;
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
updateIValue();
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
void
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
NNTreeIterator::addPathElement(QPDFObjectHandle const& node, int kid_number)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
Code tidy - Clang-Tidy rule modernize-use-emplace
2023-05-27 22:49:18 +00:00
this->path.emplace_back(node, kid_number);
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
bool
NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
{
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Starting at this node, descend through the first or last kid until we reach a node with
// items. If we succeed, return true; otherwise return false and leave path alone.
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto opath = this->path;
bool failed = false;
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
QPDFObjGen::set seen;
Code tidy - Clang-Tidy rule performance-for-range-copy
2023-06-01 15:16:21 +00:00
for (auto const& i: this->path) {
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
seen.add(i.node);
Fix loop detection in NNTree
2021-04-04 21:22:07 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (!failed) {
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
if (!seen.add(node)) {
QTC::TC("qpdf", "NNTree deepen: loop");
Rerun clang-format
2023-05-21 17:35:09 +00:00
warn(impl.qpdf, node, "loop detected while traversing name/number tree");
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
failed = true;
break;
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!node.isDictionary()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree node is not a dictionary");
Rerun clang-format
2023-05-21 17:35:09 +00:00
warn(impl.qpdf, node, "non-dictionary node while traversing name/number tree");
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
failed = true;
break;
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
auto kids = node.getKey("/Kids");
int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto items = node.getKey(impl.details.itemsKey());
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
int nitems = items.isArray() ? items.getArrayNItems() : 0;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nitems > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
setItemNumber(node, first ? 0 : nitems - 2);
break;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (nkids > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
int kid_number = first ? 0 : nkids - 1;
addPathElement(node, kid_number);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
auto next = kids.getArrayItem(kid_number);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!next.isIndirect()) {
Remove deprecated name/number tree constructors Remove the name/number tree object helper constructors that don't take a QPDF&.
2022-04-16 17:12:49 +00:00
if (impl.auto_repair) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree fix indirect kid");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
warn(
impl.qpdf,
node,
Replace calls to QUtil::int_to_string with std::to_string
2022-09-21 16:49:21 +00:00
("converting kid number " + std::to_string(kid_number) +
Update some code manually to get better formatting results Add comments to force line breaks, parenthesize function arguments that are contatenated strings, etc. -- these kinds of changes improve clang-format's results and also cause emacs cc-mode to match clang-format. After this type of change, most of the time, when clang-format and emacs disagree, clang-format is better.
2022-04-03 20:10:27 +00:00
" to an indirect object"));
Remove deprecated name/number tree constructors Remove the name/number tree object helper constructors that don't take a QPDF&.
2022-04-16 17:12:49 +00:00
next = impl.qpdf.makeIndirectObject(next);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
kids.setArrayItem(kid_number, next);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree warn indirect kid");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
warn(
impl.qpdf,
node,
Replace calls to QUtil::int_to_string with std::to_string
2022-09-21 16:49:21 +00:00
("kid number " + std::to_string(kid_number) +
Update some code manually to get better formatting results Add comments to force line breaks, parenthesize function arguments that are contatenated strings, etc. -- these kinds of changes improve clang-format's results and also cause emacs cc-mode to match clang-format. After this type of change, most of the time, when clang-format and emacs disagree, clang-format is better.
2022-04-03 20:10:27 +00:00
" is not an indirect object"));
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
}
node = next;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (allow_empty && items.isArray()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree deepen found empty");
setItemNumber(node, -1);
break;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
QTC::TC("qpdf", "NNTree deepen: invalid node");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
warn(
impl.qpdf,
node,
Rerun clang-format
2023-05-21 17:35:09 +00:00
("name/number tree node has neither non-empty " + impl.details.itemsKey() +
" nor /Kids"));
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
failed = true;
break;
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (failed) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
this->path = opath;
return false;
}
return true;
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
NNTreeImpl::NNTreeImpl(
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeDetails const& details, QPDF& qpdf, QPDFObjectHandle& oh, bool auto_repair) :
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
details(details),
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
qpdf(qpdf),
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
split_threshold(32),
oh(oh),
auto_repair(auto_repair)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
void
NNTreeImpl::setSplitThreshold(int split_threshold)
{
this->split_threshold = split_threshold;
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
NNTreeImpl::iterator
NNTreeImpl::begin()
{
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
iterator result(*this);
result.deepen(this->oh, true, true);
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return result;
}
NNTreeImpl::iterator
NNTreeImpl::end()
{
Code tidy - Clang-Tidy rule modernize-return-braced-init-list
2023-05-27 20:04:32 +00:00
return {*this};
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
NNTreeImpl::iterator
NNTreeImpl::last()
{
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
iterator result(*this);
result.deepen(this->oh, false, true);
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return result;
}
int
NNTreeImpl::withinLimits(QPDFObjectHandle key, QPDFObjectHandle node)
{
int result = 0;
auto limits = node.getKey("/Limits");
if (limits.isArray() && (limits.getArrayNItems() >= 2) &&
Rerun clang-format
2023-05-21 17:35:09 +00:00
details.keyValid(limits.getArrayItem(0)) && details.keyValid(limits.getArrayItem(1))) {
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (details.compareKeys(key, limits.getArrayItem(0)) < 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
result = -1;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (details.compareKeys(key, limits.getArrayItem(1)) > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
result = 1;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree missing limits");
error(qpdf, node, "node is missing /Limits");
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
return result;
}
int
NNTreeImpl::binarySearch(
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
QPDFObjectHandle key,
QPDFObjectHandle items,
int num_items,
bool return_prev_if_not_found,
Rerun clang-format
2023-05-21 17:35:09 +00:00
int (NNTreeImpl::*compare)(QPDFObjectHandle& key, QPDFObjectHandle& arr, int item))
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
int max_idx = 1;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (max_idx < num_items) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
max_idx <<= 1;
}
int step = max_idx / 2;
int checks = max_idx;
int idx = step;
int found_idx = -1;
bool found = false;
bool found_leq = false;
int status = 0;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while ((!found) && (checks > 0)) {
if (idx < num_items) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
status = (this->*compare)(key, items, idx);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (status >= 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
found_leq = true;
found_idx = idx;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
// consider item to be below anything after the top
status = -1;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (status == 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
found = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
checks >>= 1;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (checks > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
step >>= 1;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (step == 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
step = 1;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (status < 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
idx -= step;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
idx += step;
}
}
}
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (found || (found_leq && return_prev_if_not_found)) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return found_idx;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return -1;
}
}
int
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeImpl::compareKeyItem(QPDFObjectHandle& key, QPDFObjectHandle& items, int idx)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!((items.isArray() && (items.getArrayNItems() > (2 * idx)) &&
details.keyValid(items.getArrayItem(2 * idx))))) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree item is wrong type");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
error(
qpdf,
this->oh,
Rerun clang-format
2023-05-21 17:35:09 +00:00
("item at index " + std::to_string(2 * idx) + " is not the right type"));
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
return details.compareKeys(key, items.getArrayItem(2 * idx));
}
int
Rerun clang-format
2023-05-21 17:35:09 +00:00
NNTreeImpl::compareKeyKid(QPDFObjectHandle& key, QPDFObjectHandle& kids, int idx)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!(kids.isArray() && (idx < kids.getArrayNItems()) &&
kids.getArrayItem(idx).isDictionary())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree kid is invalid");
Replace calls to QUtil::int_to_string with std::to_string
2022-09-21 16:49:21 +00:00
error(qpdf, this->oh, "invalid kid at index " + std::to_string(idx));
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
return withinLimits(key, kids.getArrayItem(idx));
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
void
NNTreeImpl::repair()
{
auto new_node = QPDFObjectHandle::newDictionary();
new_node.replaceKey(details.itemsKey(), QPDFObjectHandle::newArray());
NNTreeImpl repl(details, qpdf, new_node, false);
Formatting: remove space in range-style for loops Change .clang-format and commit automated changes from a fresh run of format-code
2022-04-30 13:43:07 +00:00
for (auto const& i: *this) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
repl.insert(i.first, i.second);
}
Back out fluent QPDFObjectHandle methods. Keep the andGet methods. I decided these were confusing and inconsistent with how JSON works. They muddle the API rather than improving it.
2022-05-17 22:28:50 +00:00
this->oh.replaceKey("/Kids", new_node.getKey("/Kids"));
Rerun clang-format
2023-05-21 17:35:09 +00:00
this->oh.replaceKey(details.itemsKey(), new_node.getKey(details.itemsKey()));
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
NNTreeImpl::iterator
NNTreeImpl::find(QPDFObjectHandle key, bool return_prev_if_not_found)
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
try {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
return findInternal(key, return_prev_if_not_found);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} catch (QPDFExc& e) {
if (this->auto_repair) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree repair");
Rerun clang-format
2023-05-21 17:35:09 +00:00
warn(qpdf, this->oh, std::string("attempting to repair after error: ") + e.what());
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
repair();
return findInternal(key, return_prev_if_not_found);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Code tidy re-throwing of exceptions Avoid copying exceptions.
2023-03-19 16:57:27 +00:00
throw;
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
}
}
NNTreeImpl::iterator
NNTreeImpl::findInternal(QPDFObjectHandle key, bool return_prev_if_not_found)
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
{
auto first_item = begin();
auto last_item = end();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (first_item == end()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
// Empty
return end();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (
first_item.valid() && details.keyValid(first_item->first) &&
details.compareKeys(key, first_item->first) < 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
// Before the first key
return end();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (
last_item.valid() && details.keyValid(last_item->first) &&
details.compareKeys(key, last_item->first) > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
// After the last key
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (return_prev_if_not_found) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return last_item;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
return end();
}
}
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
QPDFObjGen::set seen;
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
auto node = this->oh;
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
iterator result(*this);
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
while (true) {
Use QPDFObjGen::set in NNTree
2023-01-05 11:35:44 +00:00
if (!seen.add(node)) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree loop in find");
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
error(qpdf, node, "loop detected in find");
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
auto kids = node.getKey("/Kids");
int nkids = kids.isArray() ? kids.getArrayNItems() : 0;
auto items = node.getKey(details.itemsKey());
int nitems = items.isArray() ? items.getArrayNItems() : 0;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (nitems > 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
int idx = binarySearch(
Rerun clang-format
2023-05-21 17:35:09 +00:00
key, items, nitems / 2, return_prev_if_not_found, &NNTreeImpl::compareKeyItem);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (idx >= 0) {
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
result.setItemNumber(node, 2 * idx);
}
break;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (nkids > 0) {
Rerun clang-format
2023-05-21 17:35:09 +00:00
int idx = binarySearch(key, kids, nkids, true, &NNTreeImpl::compareKeyKid);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (idx == -1) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree -1 in binary search");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
error(
qpdf,
node,
"unexpected -1 from binary search of kids;"
" limits may by wrong");
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
result.addPathElement(node, idx);
node = kids.getArrayItem(idx);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree bad node during find");
Add new constructors for name/number tree helpers Add constructors that take a QPDF object so we can issue warnings and create new indirect objects.
2021-01-16 23:35:30 +00:00
error(qpdf, node, "bad node during find");
Reimplement name and number tree object helpers Create a computationally and memory efficient implementation of name and number trees that does binary searches as intended by the data structure rather than loading into a map, which can use a great deal of memory and can be very slow.
2021-01-16 13:31:56 +00:00
}
}
return result;
}
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
NNTreeImpl::iterator
NNTreeImpl::insertFirst(QPDFObjectHandle key, QPDFObjectHandle value)
{
auto iter = begin();
QPDFObjectHandle items;
Code tidy: remove redundant calls to QPDFObjectHandle::isInitialized
2022-06-25 14:00:31 +00:00
if (iter.node.isDictionary()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
items = iter.node.getKey(details.itemsKey());
}
Code tidy: remove redundant calls to QPDFObjectHandle::isInitialized
2022-06-25 14:00:31 +00:00
if (!(items.isArray())) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree no valid items node in insertFirst");
error(qpdf, this->oh, "unable to find a valid items node");
}
items.insertItem(0, key);
items.insertItem(1, value);
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
iter.setItemNumber(iter.node, 0);
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
iter.resetLimits(iter.node, iter.lastPathElement());
iter.split(iter.node, iter.lastPathElement());
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
return iter;
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
}
NNTreeImpl::iterator
NNTreeImpl::insert(QPDFObjectHandle key, QPDFObjectHandle value)
{
auto iter = find(key, true);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!iter.valid()) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree insert inserts first");
return insertFirst(key, value);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (details.compareKeys(key, iter->first) == 0) {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree insert replaces");
auto items = iter.node.getKey(details.itemsKey());
items.setArrayItem(iter.item_number + 1, value);
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
iter.updateIValue();
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Implement repair and insert for name/number trees
2021-01-23 23:33:55 +00:00
QTC::TC("qpdf", "NNTree insert inserts after");
iter.insertAfter(key, value);
}
return iter;
}
name/number trees: remove
2021-01-24 16:48:46 +00:00
bool
NNTreeImpl::remove(QPDFObjectHandle key, QPDFObjectHandle* value)
{
auto iter = find(key, false);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!iter.valid()) {
name/number trees: remove
2021-01-24 16:48:46 +00:00
QTC::TC("qpdf", "NNTree remove not found");
return false;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (value) {
NNTree: rework iterators to be more memory efficient Keep a std::pair internal to the iterators so that operator* can return a reference and operator-> can work, and each can work without copying pairs of objects around.
2021-01-25 13:05:43 +00:00
*value = iter->second;
name/number trees: remove
2021-01-24 16:48:46 +00:00
}
iter.remove();
return true;
}
Copy Permalink