2008-04-29 12:55:25 +00:00
|
|
|
#include <qpdf/QPDF_Array.hh>
|
2022-02-04 21:31:31 +00:00
|
|
|
|
2019-06-21 03:35:23 +00:00
|
|
|
#include <qpdf/QIntC.hh>
|
2022-12-19 11:41:09 +00:00
|
|
|
#include <qpdf/QPDFObject_private.hh>
|
2022-04-02 21:14:10 +00:00
|
|
|
#include <qpdf/QUtil.hh>
|
2009-09-26 18:36:04 +00:00
|
|
|
#include <stdexcept>
|
2008-04-29 12:55:25 +00:00
|
|
|
|
2023-03-25 16:59:49 +00:00
|
|
|
static const QPDFObjectHandle null_oh = QPDFObjectHandle::newNull();
|
|
|
|
|
2022-11-17 17:35:13 +00:00
|
|
|
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.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-02 21:57:33 +00:00
|
|
|
QPDF_Array::QPDF_Array(std::vector<QPDFObjectHandle> const& v) :
|
|
|
|
QPDFValue(::ot_array, "array")
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2019-08-17 23:01:32 +00:00
|
|
|
setFromVector(v);
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
|
2023-03-26 19:02:49 +00:00
|
|
|
QPDF_Array::QPDF_Array(
|
|
|
|
std::vector<std::shared_ptr<QPDFObject>>&& v, bool sparse) :
|
|
|
|
QPDFValue(::ot_array, "array"),
|
|
|
|
sparse(sparse)
|
2022-12-19 11:41:09 +00:00
|
|
|
{
|
|
|
|
setFromVector(std::move(v));
|
|
|
|
}
|
|
|
|
|
2019-08-18 02:13:37 +00:00
|
|
|
QPDF_Array::QPDF_Array(SparseOHArray const& items) :
|
2022-08-02 21:57:33 +00:00
|
|
|
QPDFValue(::ot_array, "array"),
|
2023-03-26 19:02:49 +00:00
|
|
|
sparse(true),
|
2023-03-25 15:30:52 +00:00
|
|
|
sp_elements(items)
|
2023-03-26 19:02:49 +00:00
|
|
|
|
2023-03-25 15:30:52 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2023-03-25 18:23:39 +00:00
|
|
|
QPDF_Array::QPDF_Array(std::vector<std::shared_ptr<QPDFObject>> const& items) :
|
2023-03-25 15:30:52 +00:00
|
|
|
QPDFValue(::ot_array, "array"),
|
|
|
|
sparse(false),
|
2019-08-18 02:13:37 +00:00
|
|
|
elements(items)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-09-08 15:29:23 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
2022-06-16 16:45:04 +00:00
|
|
|
QPDF_Array::create(std::vector<QPDFObjectHandle> const& items)
|
|
|
|
{
|
|
|
|
return do_create(new QPDF_Array(items));
|
|
|
|
}
|
|
|
|
|
2022-12-19 11:41:09 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
2023-03-26 19:02:49 +00:00
|
|
|
QPDF_Array::create(
|
|
|
|
std::vector<std::shared_ptr<QPDFObject>>&& items, bool sparse)
|
2022-12-19 11:41:09 +00:00
|
|
|
{
|
2023-03-26 19:02:49 +00:00
|
|
|
return do_create(new QPDF_Array(std::move(items), sparse));
|
2022-12-19 11:41:09 +00:00
|
|
|
}
|
|
|
|
|
2022-09-08 15:29:23 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
2022-06-16 16:45:04 +00:00
|
|
|
QPDF_Array::create(SparseOHArray const& items)
|
|
|
|
{
|
|
|
|
return do_create(new QPDF_Array(items));
|
|
|
|
}
|
|
|
|
|
2023-03-25 15:30:52 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
2023-03-25 18:23:39 +00:00
|
|
|
QPDF_Array::create(std::vector<std::shared_ptr<QPDFObject>> const& items)
|
2023-03-25 15:30:52 +00:00
|
|
|
{
|
|
|
|
return do_create(new QPDF_Array(items));
|
|
|
|
}
|
|
|
|
|
2022-09-08 15:29:23 +00:00
|
|
|
std::shared_ptr<QPDFObject>
|
2022-11-14 17:54:12 +00:00
|
|
|
QPDF_Array::copy(bool shallow)
|
2022-06-16 16:45:04 +00:00
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
return create(shallow ? sp_elements : sp_elements.copy());
|
|
|
|
} else {
|
2023-03-25 18:05:54 +00:00
|
|
|
if (shallow) {
|
|
|
|
return create(elements);
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
std::vector<std::shared_ptr<QPDFObject>> result;
|
|
|
|
result.reserve(elements.size());
|
|
|
|
for (auto const& element: elements) {
|
|
|
|
result.push_back(
|
2023-03-25 18:05:54 +00:00
|
|
|
element
|
|
|
|
? (element->getObjGen().isIndirect() ? element
|
|
|
|
: element->copy())
|
|
|
|
: element);
|
|
|
|
}
|
|
|
|
return create(result);
|
|
|
|
}
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2022-06-16 16:45:04 +00:00
|
|
|
}
|
|
|
|
|
2022-09-07 20:49:31 +00:00
|
|
|
void
|
2022-09-08 15:06:15 +00:00
|
|
|
QPDF_Array::disconnect()
|
2022-09-07 20:49:31 +00:00
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
sp_elements.disconnect();
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
for (auto const& iter: elements) {
|
2023-03-25 17:23:19 +00:00
|
|
|
if (iter) {
|
|
|
|
QPDFObjectHandle::DisconnectAccess::disconnect(iter);
|
|
|
|
}
|
|
|
|
}
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2022-09-07 20:49:31 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
std::string
|
|
|
|
QPDF_Array::unparse()
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
std::string result = "[ ";
|
2022-11-16 18:50:13 +00:00
|
|
|
int size = sp_elements.size();
|
|
|
|
for (int i = 0; i < size; ++i) {
|
2023-03-24 15:01:40 +00:00
|
|
|
result += at(i).unparse();
|
2023-03-25 15:30:52 +00:00
|
|
|
result += " ";
|
|
|
|
}
|
|
|
|
result += "]";
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
std::string result = "[ ";
|
2023-03-25 18:23:39 +00:00
|
|
|
auto size = elements.size();
|
2023-03-25 16:59:49 +00:00
|
|
|
for (int i = 0; i < int(size); ++i) {
|
2023-03-24 15:01:40 +00:00
|
|
|
result += at(i).unparse();
|
2023-03-25 15:30:52 +00:00
|
|
|
result += " ";
|
|
|
|
}
|
|
|
|
result += "]";
|
|
|
|
return result;
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-17 22:40:29 +00:00
|
|
|
JSON
|
2022-05-07 11:53:45 +00:00
|
|
|
QPDF_Array::getJSON(int json_version)
|
2018-12-17 22:40:29 +00:00
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
JSON j = JSON::makeArray();
|
2022-11-16 18:50:13 +00:00
|
|
|
int size = sp_elements.size();
|
|
|
|
for (int i = 0; i < size; ++i) {
|
2023-03-24 15:01:40 +00:00
|
|
|
j.addArrayElement(at(i).getJSON(json_version));
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
|
|
|
return j;
|
|
|
|
} else {
|
|
|
|
JSON j = JSON::makeArray();
|
2023-03-25 18:23:39 +00:00
|
|
|
size_t size = elements.size();
|
2023-03-25 16:59:49 +00:00
|
|
|
for (int i = 0; i < int(size); ++i) {
|
2023-03-24 15:01:40 +00:00
|
|
|
j.addArrayElement(at(i).getJSON(json_version));
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
|
|
|
return j;
|
2018-12-17 22:40:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
QPDFObjectHandle
|
2023-03-24 15:01:40 +00:00
|
|
|
QPDF_Array::at(int n) const noexcept
|
2008-04-29 12:55:25 +00:00
|
|
|
{
|
2023-03-24 15:01:40 +00:00
|
|
|
if (n < 0 || n >= size()) {
|
|
|
|
return {};
|
|
|
|
} else if (sparse) {
|
|
|
|
auto const& iter = sp_elements.elements.find(n);
|
|
|
|
return iter == sp_elements.elements.end() ? null_oh : (*iter).second;
|
2023-03-25 15:30:52 +00:00
|
|
|
} else {
|
2023-03-24 15:01:40 +00:00
|
|
|
return elements[size_t(n)];
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-17 23:01:32 +00:00
|
|
|
void
|
|
|
|
QPDF_Array::getAsVector(std::vector<QPDFObjectHandle>& v) const
|
2011-08-10 17:33:58 +00:00
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
2022-11-16 18:50:13 +00:00
|
|
|
int size = sp_elements.size();
|
|
|
|
for (int i = 0; i < size; ++i) {
|
2023-03-24 15:01:40 +00:00
|
|
|
v.push_back(at(i));
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
v = std::vector<QPDFObjectHandle>(elements.cbegin(), elements.cend());
|
2019-08-17 23:01:32 +00:00
|
|
|
}
|
2011-08-10 17:33:58 +00:00
|
|
|
}
|
|
|
|
|
2008-04-29 12:55:25 +00:00
|
|
|
void
|
|
|
|
QPDF_Array::setItem(int n, QPDFObjectHandle const& oh)
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
2022-11-16 18:50:13 +00:00
|
|
|
sp_elements.setAt(n, oh);
|
2023-03-25 15:30:52 +00:00
|
|
|
} else {
|
2023-03-25 17:23:19 +00:00
|
|
|
size_t idx = size_t(n);
|
2023-03-25 18:23:39 +00:00
|
|
|
if (n < 0 || idx >= elements.size()) {
|
2023-03-25 17:23:19 +00:00
|
|
|
throw std::logic_error("bounds error setting item in QPDF_Array");
|
|
|
|
}
|
2023-03-25 18:23:39 +00:00
|
|
|
elements[idx] = oh.getObj();
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2008-04-29 12:55:25 +00:00
|
|
|
}
|
2012-06-18 20:38:59 +00:00
|
|
|
|
|
|
|
void
|
2019-08-17 23:01:32 +00:00
|
|
|
QPDF_Array::setFromVector(std::vector<QPDFObjectHandle> const& v)
|
2012-06-18 20:38:59 +00:00
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
sp_elements = SparseOHArray();
|
|
|
|
for (auto const& iter: v) {
|
|
|
|
sp_elements.append(iter);
|
|
|
|
}
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.resize(0);
|
2023-03-25 15:30:52 +00:00
|
|
|
for (auto const& iter: v) {
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.push_back(iter.getObj());
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2019-08-17 23:01:32 +00:00
|
|
|
}
|
2012-06-18 20:38:59 +00:00
|
|
|
}
|
|
|
|
|
2022-12-19 11:41:09 +00:00
|
|
|
void
|
|
|
|
QPDF_Array::setFromVector(std::vector<std::shared_ptr<QPDFObject>>&& v)
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
sp_elements = SparseOHArray();
|
|
|
|
for (auto&& item: v) {
|
2023-03-26 19:02:49 +00:00
|
|
|
if (item->getTypeCode() != ::ot_null ||
|
|
|
|
item->getObjGen().isIndirect()) {
|
|
|
|
sp_elements.append(std::move(item));
|
2023-03-25 15:30:52 +00:00
|
|
|
} else {
|
|
|
|
++sp_elements.n_elements;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
elements = std::move(v);
|
2022-12-19 11:41:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-18 20:38:59 +00:00
|
|
|
void
|
|
|
|
QPDF_Array::insertItem(int at, QPDFObjectHandle const& item)
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
// As special case, also allow insert beyond the end
|
2022-11-16 18:50:13 +00:00
|
|
|
if ((at < 0) || (at > sp_elements.size())) {
|
2023-03-25 15:30:52 +00:00
|
|
|
throw std::logic_error(
|
|
|
|
"INTERNAL ERROR: bounds error accessing QPDF_Array element");
|
|
|
|
}
|
2022-11-16 18:50:13 +00:00
|
|
|
sp_elements.insert(at, item);
|
2023-03-25 15:30:52 +00:00
|
|
|
} else {
|
|
|
|
// As special case, also allow insert beyond the end
|
2023-03-25 18:05:54 +00:00
|
|
|
size_t idx = QIntC::to_size(at);
|
2023-03-25 18:23:39 +00:00
|
|
|
if ((at < 0) || (at > QIntC::to_int(elements.size()))) {
|
2023-03-25 15:30:52 +00:00
|
|
|
throw std::logic_error(
|
|
|
|
"INTERNAL ERROR: bounds error accessing QPDF_Array element");
|
|
|
|
}
|
2023-03-25 18:23:39 +00:00
|
|
|
if (idx == elements.size()) {
|
2023-03-25 18:05:54 +00:00
|
|
|
// Allow inserting to the last position
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.push_back(item.getObj());
|
2023-03-25 18:05:54 +00:00
|
|
|
} else {
|
|
|
|
int n = int(idx);
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.insert(elements.cbegin() + n, item.getObj());
|
2023-03-25 18:05:54 +00:00
|
|
|
}
|
2012-06-18 20:38:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF_Array::appendItem(QPDFObjectHandle const& item)
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
|
|
|
sp_elements.append(item);
|
|
|
|
} else {
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.push_back(item.getObj());
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2012-06-18 20:38:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
QPDF_Array::eraseItem(int at)
|
|
|
|
{
|
2023-03-25 15:30:52 +00:00
|
|
|
if (sparse) {
|
2022-11-16 18:50:13 +00:00
|
|
|
sp_elements.erase(at);
|
2023-03-25 15:30:52 +00:00
|
|
|
} else {
|
2023-03-25 18:05:54 +00:00
|
|
|
size_t idx = QIntC::to_size(at);
|
2023-03-25 18:23:39 +00:00
|
|
|
if (idx >= elements.size()) {
|
2023-03-25 18:05:54 +00:00
|
|
|
throw std::logic_error("bounds error erasing item from OHArray");
|
|
|
|
}
|
|
|
|
int n = int(idx);
|
2023-03-25 18:23:39 +00:00
|
|
|
elements.erase(elements.cbegin() + n);
|
2023-03-25 15:30:52 +00:00
|
|
|
}
|
2012-06-18 20:38:59 +00:00
|
|
|
}
|