octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-18 10:25:12 +00:00
Code Issues Releases Wiki Activity
37f05e67d8
qpdf/libtests/nntree.cc

228 lines
6.7 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/QPDF.hh>
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
#include <qpdf/QPDFNameTreeObjectHelper.hh>
#include <qpdf/QPDFNumberTreeObjectHelper.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 <iostream>
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
static bool any_failures = 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
bool
report(QPDF& q, QPDFObjectHandle oh, long long item, long long exp_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
{
Use new QPDF{Name,Number}TreeObjectHelper API
2021-01-17 22:54:52 +00:00
QPDFNumberTreeObjectHelper nh(oh, q);
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 o1;
long long offset = 0;
bool f1 = nh.findObjectAtOrBelow(item, o1, offset);
QPDFObjectHandle o2;
bool f2 = nh.findObject(item, o2);
bool failed = 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
auto show = [&failed, &oh, &item]() {
if (!failed) {
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
failed = 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
std::cout << "key = " << item << ", oh = " << oh.unparseResolved()
<< std::endl;
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 mk_wanted = [](long long i) {
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
return (
(i == -1) ? "end"
: (QUtil::int_to_string(i) + "/(-" +
QUtil::int_to_string(i) + "-)"));
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
};
std::string i1_wanted = mk_wanted(exp_item);
std::string i2_wanted = mk_wanted(item == exp_item ? item : -1);
auto mk_actual = [](bool found, long long v, QPDFObjectHandle& o) {
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
return (found ? QUtil::int_to_string(v) + "/" + o.unparse() : "end");
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
};
std::string i1_actual = mk_actual(f1, item - offset, o1);
std::string i2_actual = mk_actual(f2, item, o2);
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 (i1_wanted != i1_actual) {
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
show();
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
std::cout << "i1: wanted " << i1_wanted << ", got " << i1_actual
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
<< std::endl;
}
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 (i2_wanted != i2_actual) {
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
show();
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
std::cout << "i2: wanted " << i2_wanted << ", got " << i2_actual
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
<< std::endl;
}
return failed;
}
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
void
test_bsearch()
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
{
QPDF q;
q.emptyPDF();
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
auto mk = [&q](std::vector<int> const& v) {
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 nums = QPDFObjectHandle::newArray();
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
for (auto i : v) {
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
nums.appendItem(QPDFObjectHandle::newInteger(i));
nums.appendItem(QPDFObjectHandle::newString(
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
"-" + QUtil::int_to_string(i) + "-"));
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 limits = QPDFObjectHandle::newArray();
limits.appendItem(QPDFObjectHandle::newInteger(v.at(0)));
limits.appendItem(QPDFObjectHandle::newInteger(v.at(v.size() - 1)));
auto node = q.makeIndirectObject(QPDFObjectHandle::newDictionary());
node.replaceKey("/Nums", nums);
node.replaceKey("/Limits", limits);
return node;
};
Use new QPDF{Name,Number}TreeObjectHelper API
2021-01-17 22:54:52 +00:00
auto r = [&q](QPDFObjectHandle& oh, int item, int exp) {
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 (report(q, oh, item, exp)) {
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
any_failures = true;
}
};
auto a = mk({2, 3, 5, 9, 11, 12, 14, 18});
r(a, 1, -1);
r(a, 2, 2);
r(a, 9, 9);
r(a, 11, 11);
r(a, 10, 9);
r(a, 7, 5);
r(a, 18, 18);
r(a, 19, 18);
auto b = mk({2, 4});
r(b, 1, -1);
r(b, 2, 2);
r(b, 3, 2);
r(b, 4, 4);
r(b, 5, 4);
auto c = mk({3});
r(c, 1, -1);
r(c, 3, 3);
r(c, 5, 3);
auto d = mk({2, 3, 5, 9, 10, 12, 14, 18, 19, 20});
r(d, 1, -1);
r(d, 2, 2);
r(d, 18, 18);
r(d, 14, 14);
r(d, 19, 19);
r(d, 20, 20);
r(d, 25, 20);
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 (!any_failures) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
std::cout << "bsearch tests passed" << std::endl;
}
}
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
new_node(QPDF& q, std::string const& key)
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
{
auto dict = QPDFObjectHandle::newDictionary();
dict.replaceKey(key, QPDFObjectHandle::newArray());
return q.makeIndirectObject(dict);
}
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
static void
check_find(
QPDFNameTreeObjectHelper& nh,
std::string const& key,
bool prev_if_not_found)
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
{
auto i = nh.find(key, prev_if_not_found);
std::cout << "find " << key << " (" << 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
if (i == nh.end()) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
std::cout << "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 {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
std::cout << (*i).first << " -> " << (*i).second.unparse();
}
std::cout << std::endl;
}
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
void
test_depth()
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
{
int constexpr NITEMS = 3;
QPDF q;
q.emptyPDF();
auto root = q.getRoot();
auto n0 = new_node(q, "/Kids");
root.replaceKey("/NT", n0);
auto k0 = root.getKey("/NT").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
for (int i1 = 0; i1 < NITEMS; ++i1) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
auto n1 = new_node(q, "/Kids");
k0.appendItem(n1);
auto k1 = n1.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
for (int i2 = 0; i2 < NITEMS; ++i2) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
auto n2 = new_node(q, "/Kids");
k1.appendItem(n2);
auto k2 = n2.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
for (int i3 = 0; i3 < NITEMS; ++i3) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
auto n3 = new_node(q, "/Names");
k2.appendItem(n3);
auto items = n3.getKey("/Names");
std::string first;
std::string 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
for (int i4 = 0; i4 < NITEMS; ++i4) {
int val =
(((((i1 * NITEMS) + i2) * NITEMS) + i3) * NITEMS) + i4;
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
std::string str = QUtil::int_to_string(10 * val, 6);
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
items.appendItem(QPDFObjectHandle::newString(str));
items.appendItem(QPDFObjectHandle::newString("val " + str));
if (i4 == 0) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
first = str;
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 (i4 == NITEMS - 1) {
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
last = str;
}
}
auto limits = QPDFObjectHandle::newArray();
n3.replaceKey("/Limits", limits);
limits.appendItem(QPDFObjectHandle::newString(first));
limits.appendItem(QPDFObjectHandle::newString(last));
}
auto limits = QPDFObjectHandle::newArray();
n2.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
limits.appendItem(
k2.getArrayItem(0).getKey("/Limits").getArrayItem(0));
limits.appendItem(
k2.getArrayItem(NITEMS - 1).getKey("/Limits").getArrayItem(1));
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
}
auto limits = QPDFObjectHandle::newArray();
n1.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
limits.appendItem(k1.getArrayItem(0).getKey("/Limits").getArrayItem(0));
limits.appendItem(
k1.getArrayItem(NITEMS - 1).getKey("/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
}
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
Use new QPDF{Name,Number}TreeObjectHelper API
2021-01-17 22:54:52 +00:00
QPDFNameTreeObjectHelper nh(n0, q);
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
std::cout << "--- forward ---" << std::endl;
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
for (auto i : nh) {
std::cout << i.first << " -> " << i.second.unparse() << std::endl;
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
}
std::cout << "--- backward ---" << std::endl;
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
for (auto i = nh.last(); i.valid(); --i) {
std::cout << (*i).first << " -> " << (*i).second.unparse() << std::endl;
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
}
// Find
check_find(nh, "000300", false);
check_find(nh, "000305", true);
check_find(nh, "000305", false);
check_find(nh, "00000", false);
check_find(nh, "00000", true);
check_find(nh, "000800", false);
check_find(nh, "000805", false);
check_find(nh, "000805", 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
int
main()
Add iterators to name/number tree helpers
2021-01-16 17:11:17 +00:00
{
test_bsearch();
test_depth();
return 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
}
Copy Permalink