/src/qpdf/libqpdf/QPDF_Array.cc

Source (jump to first uncovered line)
#include <qpdf/QPDF_Array.hh>

#include <qpdf/JSON_writer.hh>
#include <qpdf/QPDFObjectHandle.hh>
#include <qpdf/QPDFObject_private.hh>
#include <qpdf/QTC.hh>

static const QPDFObjectHandle null_oh = QPDFObjectHandle::newNull();

inline void
QPDF_Array::checkOwnership(QPDFObjectHandle const& item) const
{
    if (auto obj = item.getObjectPtr()) {
        if (qpdf) {
            if (auto item_qpdf = obj->getQPDF()) {
                if (qpdf != item_qpdf) {
                    throw std::logic_error(
                        "Attempting to add an object from a different QPDF. Use "
                        "QPDF::copyForeignObject to add objects from another file.");
                }
            }
        }
    } else {
        throw std::logic_error("Attempting to add an uninitialized object to a QPDF_Array.");
    }
}

QPDF_Array::QPDF_Array() :
    QPDFValue(::ot_array)
{
}

QPDF_Array::QPDF_Array(QPDF_Array const& other) :
    QPDFValue(::ot_array),
    sp(other.sp ? std::make_unique<Sparse>(*other.sp) : nullptr)
{
}

QPDF_Array::QPDF_Array(std::vector<QPDFObjectHandle> const& v) :
    QPDFValue(::ot_array)
{
    setFromVector(v);
}

QPDF_Array::QPDF_Array(std::vector<std::shared_ptr<QPDFObject>>&& v, bool sparse) :
    QPDFValue(::ot_array)
{
    if (sparse) {
        sp = std::make_unique<Sparse>();
        for (auto&& item: v) {
            if (item->getTypeCode() != ::ot_null || item->getObjGen().isIndirect()) {
                sp->elements[sp->size] = std::move(item);
            }
            ++sp->size;
        }
    } else {
        elements = std::move(v);
    }
}

std::shared_ptr<QPDFObject>
QPDF_Array::create(std::vector<QPDFObjectHandle> const& items)
{
    return do_create(new QPDF_Array(items));
}

std::shared_ptr<QPDFObject>
QPDF_Array::create(std::vector<std::shared_ptr<QPDFObject>>&& items, bool sparse)
{
    return do_create(new QPDF_Array(std::move(items), sparse));
}

std::shared_ptr<QPDFObject>
QPDF_Array::copy(bool shallow)
{
    if (shallow) {
        return do_create(new QPDF_Array(*this));
    } else {
        QTC::TC("qpdf", "QPDF_Array copy", sp ? 0 : 1);
        if (sp) {
            auto* result = new QPDF_Array();
            result->sp = std::make_unique<Sparse>();
            result->sp->size = sp->size;
            for (auto const& element: sp->elements) {
                auto const& obj = element.second;
                result->sp->elements[element.first] =
                    obj->getObjGen().isIndirect() ? obj : obj->copy();
            }
            return do_create(result);
        } else {
            std::vector<std::shared_ptr<QPDFObject>> result;
            result.reserve(elements.size());
            for (auto const& element: elements) {
                result.push_back(
                    element ? (element->getObjGen().isIndirect() ? element : element->copy())
                            : element);
            }
            return create(std::move(result), false);
        }
    }
}

void
QPDF_Array::disconnect()
{
    if (sp) {
        for (auto& item: sp->elements) {
            auto& obj = item.second;
            if (!obj->getObjGen().isIndirect()) {
                obj->disconnect();
            }
        }
    } else {
        for (auto& obj: elements) {
            if (!obj->getObjGen().isIndirect()) {
                obj->disconnect();
            }
        }
    }
}

std::string
QPDF_Array::unparse()
{
    std::string result = "[ ";
    if (sp) {
        int next = 0;
        for (auto& item: sp->elements) {
            int key = item.first;
            for (int j = next; j < key; ++j) {
                result += "null ";
            }
            auto og = item.second->resolved_object()->getObjGen();
            result += og.isIndirect() ? og.unparse(' ') + " R " : item.second->unparse() + " ";
            next = ++key;
        }
        for (int j = next; j < sp->size; ++j) {
            result += "null ";
        }
    } else {
        for (auto const& item: elements) {
            auto og = item->resolved_object()->getObjGen();
            result += og.isIndirect() ? og.unparse(' ') + " R " : item->unparse() + " ";
        }
    }
    result += "]";
    return result;
}

void
QPDF_Array::writeJSON(int json_version, JSON::Writer& p)
{
    p.writeStart('[');
    if (sp) {
        int next = 0;
        for (auto& item: sp->elements) {
            int key = item.first;
            for (int j = next; j < key; ++j) {
                p.writeNext() << "null";
            }
            p.writeNext();
            auto og = item.second->getObjGen();
            if (og.isIndirect()) {
                p << "\"" << og.unparse(' ') << " R\"";
            } else {
                item.second->writeJSON(json_version, p);
            }
            next = ++key;
        }
        for (int j = next; j < sp->size; ++j) {
            p.writeNext() << "null";
        }
    } else {
        for (auto const& item: elements) {
            p.writeNext();
            auto og = item->getObjGen();
            if (og.isIndirect()) {
                p << "\"" << og.unparse(' ') << " R\"";
            } else {
                item->writeJSON(json_version, p);
            }
        }
    }
    p.writeEnd(']');
}

QPDFObjectHandle
QPDF_Array::at(int n) const noexcept
{
    if (n < 0 || n >= size()) {
        return {};
    } else if (sp) {
        auto const& iter = sp->elements.find(n);
        return iter == sp->elements.end() ? null_oh : (*iter).second;
    } else {
        return elements[size_t(n)];
    }
}

std::vector<QPDFObjectHandle>
QPDF_Array::getAsVector() const
{
    if (sp) {
        std::vector<QPDFObjectHandle> v;
        v.reserve(size_t(size()));
        for (auto const& item: sp->elements) {
            v.resize(size_t(item.first), null_oh);
            v.emplace_back(item.second);
        }
        v.resize(size_t(size()), null_oh);
        return v;
    } else {
        return {elements.cbegin(), elements.cend()};
    }
}

bool
QPDF_Array::setAt(int at, QPDFObjectHandle const& oh)
{
    if (at < 0 || at >= size()) {
        return false;
    }
    checkOwnership(oh);
    if (sp) {
        sp->elements[at] = oh.getObj();
    } else {
        elements[size_t(at)] = oh.getObj();
    }
    return true;
}

void
QPDF_Array::setFromVector(std::vector<QPDFObjectHandle> const& v)
{
    elements.resize(0);
    elements.reserve(v.size());
    for (auto const& item: v) {
        checkOwnership(item);
        elements.push_back(item.getObj());
    }
}

bool
QPDF_Array::insert(int at, QPDFObjectHandle const& item)
{
    int sz = size();
    if (at < 0 || at > sz) {
        // As special case, also allow insert beyond the end
        return false;
    } else if (at == sz) {
        push_back(item);
    } else {
        checkOwnership(item);
        if (sp) {
            auto iter = sp->elements.crbegin();
            while (iter != sp->elements.crend()) {
                auto key = (iter++)->first;
                if (key >= at) {
                    auto nh = sp->elements.extract(key);
                    ++nh.key();
                    sp->elements.insert(std::move(nh));
                } else {
                    break;
                }
            }
            sp->elements[at] = item.getObj();
            ++sp->size;
        } else {
            elements.insert(elements.cbegin() + at, item.getObj());
        }
    }
    return true;
}

void
QPDF_Array::push_back(QPDFObjectHandle const& item)
{
    checkOwnership(item);
    if (sp) {
        sp->elements[(sp->size)++] = item.getObj();
    } else {
        elements.push_back(item.getObj());
    }
}

bool
QPDF_Array::erase(int at)
{
    if (at < 0 || at >= size()) {
        return false;
    }
    if (sp) {
        auto end = sp->elements.end();
        if (auto iter = sp->elements.lower_bound(at); iter != end) {
            if (iter->first == at) {
                iter++;
                sp->elements.erase(at);
            }

            while (iter != end) {
                auto nh = sp->elements.extract(iter++);
                --nh.key();
                sp->elements.insert(std::move(nh));
            }
        }
        --(sp->size);
    } else {
        elements.erase(elements.cbegin() + at);
    }
    return true;
}

Coverage Report

Created: 2024-09-08 06:05

Line	Count	Source (jump to first uncovered line)
1		#include <qpdf/QPDF_Array.hh>
2
3		#include <qpdf/JSON_writer.hh>
4		#include <qpdf/QPDFObjectHandle.hh>
5		#include <qpdf/QPDFObject_private.hh>
6		#include <qpdf/QTC.hh>
7
8		static const QPDFObjectHandle null_oh = QPDFObjectHandle::newNull();
9
10		inline void
11		QPDF_Array::checkOwnership(QPDFObjectHandle const& item) const
12	2.97M	{
13	2.97M	if (auto obj = item.getObjectPtr()) {
14	2.97M	if (qpdf) {
15	2.97M	if (auto item_qpdf = obj->getQPDF()) {
16	2.96M	if (qpdf != item_qpdf) {
17	0	throw std::logic_error(
18	0	"Attempting to add an object from a different QPDF. Use "
19	0	"QPDF::copyForeignObject to add objects from another file.");
20	0	}
21	2.96M	}
22	2.97M	}
23	2.97M	} else {
24	0	throw std::logic_error("Attempting to add an uninitialized object to a QPDF_Array.");
25	0	}
26	2.97M	}
27
28		QPDF_Array::QPDF_Array() :
29		QPDFValue(::ot_array)
30	0	{
31	0	}
32
33		QPDF_Array::QPDF_Array(QPDF_Array const& other) :
34		QPDFValue(::ot_array),
35		sp(other.sp ? std::make_unique<Sparse>(*other.sp) : nullptr)
36	0	{
37	0	}
38
39		QPDF_Array::QPDF_Array(std::vector<QPDFObjectHandle> const& v) :
40		QPDFValue(::ot_array)
41	19.1k	{
42	19.1k	setFromVector(v);
43	19.1k	}
44
45		QPDF_Array::QPDF_Array(std::vector<std::shared_ptr<QPDFObject>>&& v, bool sparse) :
46		QPDFValue(::ot_array)
47	0	{
48	0	if (sparse) {
49	0	sp = std::make_unique<Sparse>();
50	0	for (auto&& item: v) {
51	0	if (item->getTypeCode() != ::ot_null \|\| item->getObjGen().isIndirect()) {
52	0	sp->elements[sp->size] = std::move(item);
53	0	}
54	0	++sp->size;
55	0	}
56	0	} else {
57	0	elements = std::move(v);
58	0	}
59	0	}
60
61		std::shared_ptr<QPDFObject>
62		QPDF_Array::create(std::vector<QPDFObjectHandle> const& items)
63	19.1k	{
64	19.1k	return do_create(new QPDF_Array(items));
65	19.1k	}
66
67		std::shared_ptr<QPDFObject>
68		QPDF_Array::create(std::vector<std::shared_ptr<QPDFObject>>&& items, bool sparse)
69	0	{
70	0	return do_create(new QPDF_Array(std::move(items), sparse));
71	0	}
72
73		std::shared_ptr<QPDFObject>
74		QPDF_Array::copy(bool shallow)
75	0	{
76	0	if (shallow) {
77	0	return do_create(new QPDF_Array(*this));
78	0	} else {
79	0	QTC::TC("qpdf", "QPDF_Array copy", sp ? 0 : 1);
80	0	if (sp) {
81	0	auto* result = new QPDF_Array();
82	0	result->sp = std::make_unique<Sparse>();
83	0	result->sp->size = sp->size;
84	0	for (auto const& element: sp->elements) {
85	0	auto const& obj = element.second;
86	0	result->sp->elements[element.first] =
87	0	obj->getObjGen().isIndirect() ? obj : obj->copy();
88	0	}
89	0	return do_create(result);
90	0	} else {
91	0	std::vector<std::shared_ptr<QPDFObject>> result;
92	0	result.reserve(elements.size());
93	0	for (auto const& element: elements) {
94	0	result.push_back(
95	0	element ? (element->getObjGen().isIndirect() ? element : element->copy())
96	0	: element);
97	0	}
98	0	return create(std::move(result), false);
99	0	}
100	0	}
101	0	}
102
103		void
104		QPDF_Array::disconnect()
105	18.8k	{
106	18.8k	if (sp) {
107	0	for (auto& item: sp->elements) {
108	0	auto& obj = item.second;
109	0	if (!obj->getObjGen().isIndirect()) {
110	0	obj->disconnect();
111	0	}
112	0	}
113	18.8k	} else {
114	2.97M	for (auto& obj: elements) {
115	2.97M	if (!obj->getObjGen().isIndirect()) {
116	2.74M	obj->disconnect();
117	2.74M	}
118	2.97M	}
119	18.8k	}
120	18.8k	}
121
122		std::string
123		QPDF_Array::unparse()
124	0	{
125	0	std::string result = "[ ";
126	0	if (sp) {
127	0	int next = 0;
128	0	for (auto& item: sp->elements) {
129	0	int key = item.first;
130	0	for (int j = next; j < key; ++j) {
131	0	result += "null ";
132	0	}
133	0	auto og = item.second->resolved_object()->getObjGen();
134	0	result += og.isIndirect() ? og.unparse(' ') + " R " : item.second->unparse() + " ";
135	0	next = ++key;
136	0	}
137	0	for (int j = next; j < sp->size; ++j) {
138	0	result += "null ";
139	0	}
140	0	} else {
141	0	for (auto const& item: elements) {
142	0	auto og = item->resolved_object()->getObjGen();
143	0	result += og.isIndirect() ? og.unparse(' ') + " R " : item->unparse() + " ";
144	0	}
145	0	}
146	0	result += "]";
147	0	return result;
148	0	}
149
150		void
151		QPDF_Array::writeJSON(int json_version, JSON::Writer& p)
152	0	{
153	0	p.writeStart('[');
154	0	if (sp) {
155	0	int next = 0;
156	0	for (auto& item: sp->elements) {
157	0	int key = item.first;
158	0	for (int j = next; j < key; ++j) {
159	0	p.writeNext() << "null";
160	0	}
161	0	p.writeNext();
162	0	auto og = item.second->getObjGen();
163	0	if (og.isIndirect()) {
164	0	p << "\"" << og.unparse(' ') << " R\"";
165	0	} else {
166	0	item.second->writeJSON(json_version, p);
167	0	}
168	0	next = ++key;
169	0	}
170	0	for (int j = next; j < sp->size; ++j) {
171	0	p.writeNext() << "null";
172	0	}
173	0	} else {
174	0	for (auto const& item: elements) {
175	0	p.writeNext();
176	0	auto og = item->getObjGen();
177	0	if (og.isIndirect()) {
178	0	p << "\"" << og.unparse(' ') << " R\"";
179	0	} else {
180	0	item->writeJSON(json_version, p);
181	0	}
182	0	}
183	0	}
184	0	p.writeEnd(']');
185	0	}
186
187		QPDFObjectHandle
188		QPDF_Array::at(int n) const noexcept
189	0	{
190	0	if (n < 0 \|\| n >= size()) {
191	0	return {};
192	0	} else if (sp) {
193	0	auto const& iter = sp->elements.find(n);
194	0	return iter == sp->elements.end() ? null_oh : (*iter).second;
195	0	} else {
196	0	return elements[size_t(n)];
197	0	}
198	0	}
199
200		std::vector<QPDFObjectHandle>
201		QPDF_Array::getAsVector() const
202	0	{
203	0	if (sp) {
204	0	std::vector<QPDFObjectHandle> v;
205	0	v.reserve(size_t(size()));
206	0	for (auto const& item: sp->elements) {
207	0	v.resize(size_t(item.first), null_oh);
208	0	v.emplace_back(item.second);
209	0	}
210	0	v.resize(size_t(size()), null_oh);
211	0	return v;
212	0	} else {
213	0	return {elements.cbegin(), elements.cend()};
214	0	}
215	0	}
216
217		bool
218		QPDF_Array::setAt(int at, QPDFObjectHandle const& oh)
219	0	{
220	0	if (at < 0 \|\| at >= size()) {
221	0	return false;
222	0	}
223	0	checkOwnership(oh);
224	0	if (sp) {
225	0	sp->elements[at] = oh.getObj();
226	0	} else {
227	0	elements[size_t(at)] = oh.getObj();
228	0	}
229	0	return true;
230	0	}
231
232		void
233		QPDF_Array::setFromVector(std::vector<QPDFObjectHandle> const& v)
234	19.1k	{
235	19.1k	elements.resize(0);
236	19.1k	elements.reserve(v.size());
237	19.1k	for (auto const& item: v) {
238	0	checkOwnership(item);
239	0	elements.push_back(item.getObj());
240	0	}
241	19.1k	}
242
243		bool
244		QPDF_Array::insert(int at, QPDFObjectHandle const& item)
245	0	{
246	0	int sz = size();
247	0	if (at < 0 \|\| at > sz) {
248		// As special case, also allow insert beyond the end
249	0	return false;
250	0	} else if (at == sz) {
251	0	push_back(item);
252	0	} else {
253	0	checkOwnership(item);
254	0	if (sp) {
255	0	auto iter = sp->elements.crbegin();
256	0	while (iter != sp->elements.crend()) {
257	0	auto key = (iter++)->first;
258	0	if (key >= at) {
259	0	auto nh = sp->elements.extract(key);
260	0	++nh.key();
261	0	sp->elements.insert(std::move(nh));
262	0	} else {
263	0	break;
264	0	}
265	0	}
266	0	sp->elements[at] = item.getObj();
267	0	++sp->size;
268	0	} else {
269	0	elements.insert(elements.cbegin() + at, item.getObj());
270	0	}
271	0	}
272	0	return true;
273	0	}
274
275		void
276		QPDF_Array::push_back(QPDFObjectHandle const& item)
277	2.97M	{
278	2.97M	checkOwnership(item);
279	2.97M	if (sp) {
280	0	sp->elements[(sp->size)++] = item.getObj();
281	2.97M	} else {
282	2.97M	elements.push_back(item.getObj());
283	2.97M	}
284	2.97M	}
285
286		bool
287		QPDF_Array::erase(int at)
288	0	{
289	0	if (at < 0 \|\| at >= size()) {
290	0	return false;
291	0	}
292	0	if (sp) {
293	0	auto end = sp->elements.end();
294	0	if (auto iter = sp->elements.lower_bound(at); iter != end) {
295	0	if (iter->first == at) {
296	0	iter++;
297	0	sp->elements.erase(at);
298	0	}
299
300	0	while (iter != end) {
301	0	auto nh = sp->elements.extract(iter++);
302	0	--nh.key();
303	0	sp->elements.insert(std::move(nh));
304	0	}
305	0	}
306	0	--(sp->size);
307	0	} else {
308	0	elements.erase(elements.cbegin() + at);
309	0	}
310	0	return true;
311	0	}