1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
#ifndef QPDFVALUEPROXY_HH
#define QPDFVALUEPROXY_HH
#include <qpdf/Constants.h>
#include <qpdf/DLL.h>
#include <qpdf/JSON.hh>
#include <qpdf/QPDFValue.hh>
#include <qpdf/Types.h>
#include <string>
class QPDF;
class QPDFObjectHandle;
class QPDFValueProxy
{
friend class QPDFValue;
public:
QPDFValueProxy() = default;
std::shared_ptr<QPDFValueProxy>
shallowCopy()
{
return value->shallowCopy();
}
std::string
unparse()
{
return value->unparse();
}
JSON
getJSON(int json_version)
{
return value->getJSON(json_version);
}
// Return a unique type code for the object
qpdf_object_type_e
getTypeCode() const
{
return value->type_code;
}
// Return a string literal that describes the type, useful for
// debugging and testing
char const*
getTypeName() const
{
return value->type_name;
}
QPDF*
getQPDF() const
{
return value->qpdf;
}
QPDFObjGen
getObjGen() const
{
return value->og;
}
void
setDescription(QPDF* qpdf, std::string const& description)
{
return value->setDescription(qpdf, description);
}
bool
getDescription(QPDF*& qpdf, std::string& description)
{
return value->getDescription(qpdf, description);
}
bool
hasDescription()
{
return value->hasDescription();
}
void
setParsedOffset(qpdf_offset_t offset)
{
value->setParsedOffset(offset);
}
qpdf_offset_t
getParsedOffset()
{
return value->getParsedOffset();
}
void
assign(std::shared_ptr<QPDFValueProxy> o)
{
value = o->value;
}
void
swapWith(std::shared_ptr<QPDFValueProxy> o)
{
auto v = value;
value = o->value;
o->value = v;
auto og = value->og;
value->og = o->value->og;
o->value->og = og;
}
// The following two methods are for use by class QPDF only
void
setObjGen(QPDF* qpdf, QPDFObjGen const& og)
{
value->qpdf = qpdf;
value->og = og;
}
void
reset()
{
value->reset();
// It would be better if, rather than clearing value->qpdf and
// value->og, we completely replaced value with
// QPDF_Destroyed. However, at the time of the release of qpdf
// 11, this causes test failures and would likely break a lot
// of code since it possible for a direct object that
// recursively contains no indirect objects to be copied into
// multiple QPDF objects. For that reason, we have to break
// the association with the owning QPDF but not otherwise
// mutate the object. For indirect objects, QPDF::~QPDF
// replaces indirect objects with QPDF_Destroyed, which clears
// circular references. If this code were able to do that,
// that code would not have to.
value->qpdf = nullptr;
value->og = QPDFObjGen();
}
void destroy();
bool
isUnresolved() const
{
return value->type_code == ::ot_unresolved;
}
void
resolve()
{
if (isUnresolved()) {
doResolve();
}
}
void doResolve();
template <typename T>
T*
as()
{
return dynamic_cast<T*>(value.get());
}
private:
QPDFValueProxy(QPDFValueProxy const&) = delete;
QPDFValueProxy& operator=(QPDFValueProxy const&) = delete;
std::shared_ptr<QPDFValue> value;
};
#endif // QPDFVALUEPROXY_HH
|