LLVM 17.0.0git
MsgPackDocument.cpp
Go to the documentation of this file.
1//===-- MsgPackDocument.cpp - MsgPack Document --------------------------*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// This file implements a class that exposes a simple in-memory representation
10/// of a document of MsgPack objects, that can be read from MsgPack, written to
11/// MsgPack, and inspected and modified in memory. This is intended to be a
12/// lighter-weight (in terms of memory allocations) replacement for
13/// MsgPackTypes.
14///
15//===----------------------------------------------------------------------===//
16
19
20using namespace llvm;
21using namespace msgpack;
22
23// Convert this DocNode into an empty array.
24void DocNode::convertToArray() { *this = getDocument()->getArrayNode(); }
25
26// Convert this DocNode into an empty map.
27void DocNode::convertToMap() { *this = getDocument()->getMapNode(); }
28
29/// Find the key in the MapDocNode.
30DocNode::MapTy::iterator MapDocNode::find(StringRef S) {
31 return find(getDocument()->getNode(S));
32}
33
34/// Member access for MapDocNode. The string data must remain valid for the
35/// lifetime of the Document.
37 return (*this)[getDocument()->getNode(S)];
38}
39
40/// Member access for MapDocNode.
42 assert(!Key.isEmpty());
43 DocNode &N = (*Map)[Key];
44 if (N.isEmpty()) {
45 // Ensure a new element has its KindAndDoc initialized.
47 }
48 return N;
49}
50
51/// Member access for MapDocNode for integer key.
53 return (*this)[getDocument()->getNode(Key)];
54}
56 return (*this)[getDocument()->getNode(Key)];
57}
59 return (*this)[getDocument()->getNode(Key)];
60}
62 return (*this)[getDocument()->getNode(Key)];
63}
64
65/// Array element access. This extends the array if necessary.
67 if (size() <= Index) {
68 // Ensure new elements have their KindAndDoc initialized.
69 Array->resize(Index + 1, getDocument()->getEmptyNode());
70 }
71 return (*Array)[Index];
72}
73
74// Convenience assignment operators. This only works if the destination
75// DocNode has an associated Document, i.e. it was not constructed using the
76// default constructor. The string one does not copy, so the string must
77// remain valid for the lifetime of the Document. Use fromString to avoid
78// that restriction.
80 *this = getDocument()->getNode(Val);
81 return *this;
82}
84 *this = getDocument()->getNode(Val);
85 return *this;
86}
88 *this = getDocument()->getNode(Val);
89 return *this;
90}
92 *this = getDocument()->getNode(Val);
93 return *this;
94}
96 *this = getDocument()->getNode(Val);
97 return *this;
98}
100 *this = getDocument()->getNode(Val);
101 return *this;
102}
104 *this = getDocument()->getNode(Val);
105 return *this;
106}
107
108// A level in the document reading stack.
110 StackLevel(DocNode Node, size_t StartIndex, size_t Length,
111 DocNode *MapEntry = nullptr)
112 : Node(Node), Index(StartIndex), End(StartIndex + Length),
113 MapEntry(MapEntry) {}
115 size_t Index;
116 size_t End;
117 // Points to map entry when we have just processed a map key.
120};
121
122// Read a document from a binary msgpack blob, merging into anything already in
123// the Document.
124// The blob data must remain valid for the lifetime of this Document (because a
125// string object in the document contains a StringRef into the original blob).
126// If Multi, then this sets root to an array and adds top-level objects to it.
127// If !Multi, then it only reads a single top-level object, even if there are
128// more, and sets root to that.
129// Returns false if failed due to illegal format or merge error.
130
132 StringRef Blob, bool Multi,
133 function_ref<int(DocNode *DestNode, DocNode SrcNode, DocNode MapKey)>
134 Merger) {
135 msgpack::Reader MPReader(Blob);
137 if (Multi) {
138 // Create the array for multiple top-level objects.
139 Root = getArrayNode();
140 Stack.push_back(StackLevel(Root, 0, (size_t)-1));
141 }
142 do {
143 // On to next element (or key if doing a map key next).
144 // Read the value.
145 Object Obj;
146 if (!MPReader.read(Obj)) {
147 if (Multi && Stack.size() == 1) {
148 // OK to finish here as we've just done a top-level element with Multi
149 break;
150 }
151 return false; // Finished too early
152 }
153 // Convert it into a DocNode.
154 DocNode Node;
155 switch (Obj.Kind) {
156 case Type::Nil:
157 Node = getNode();
158 break;
159 case Type::Int:
160 Node = getNode(Obj.Int);
161 break;
162 case Type::UInt:
163 Node = getNode(Obj.UInt);
164 break;
165 case Type::Boolean:
166 Node = getNode(Obj.Bool);
167 break;
168 case Type::Float:
169 Node = getNode(Obj.Float);
170 break;
171 case Type::String:
172 Node = getNode(Obj.Raw);
173 break;
174 case Type::Binary:
175 Node = getNode(MemoryBufferRef(Obj.Raw, ""));
176 break;
177 case Type::Map:
178 Node = getMapNode();
179 break;
180 case Type::Array:
181 Node = getArrayNode();
182 break;
183 default:
184 return false; // Raw and Extension not supported
185 }
186
187 // Store it.
188 DocNode *DestNode = nullptr;
189 if (Stack.empty())
190 DestNode = &Root;
191 else if (Stack.back().Node.getKind() == Type::Array) {
192 // Reading an array entry.
193 auto &Array = Stack.back().Node.getArray();
194 DestNode = &Array[Stack.back().Index++];
195 } else {
196 auto &Map = Stack.back().Node.getMap();
197 if (!Stack.back().MapEntry) {
198 // Reading a map key.
199 Stack.back().MapKey = Node;
200 Stack.back().MapEntry = &Map[Node];
201 continue;
202 }
203 // Reading the value for the map key read in the last iteration.
204 DestNode = Stack.back().MapEntry;
205 Stack.back().MapEntry = nullptr;
206 ++Stack.back().Index;
207 }
208 int MergeResult = 0;
209 if (!DestNode->isEmpty()) {
210 // In a merge, there is already a value at this position. Call the
211 // callback to attempt to resolve the conflict. The resolution must result
212 // in an array or map if Node is an array or map respectively.
213 DocNode MapKey = !Stack.empty() && !Stack.back().MapKey.isEmpty()
214 ? Stack.back().MapKey
215 : getNode();
216 MergeResult = Merger(DestNode, Node, MapKey);
217 if (MergeResult < 0)
218 return false; // Merge conflict resolution failed
219 assert(!((Node.isMap() && !DestNode->isMap()) ||
220 (Node.isArray() && !DestNode->isArray())));
221 } else
222 *DestNode = Node;
223
224 // See if we're starting a new array or map.
225 switch (DestNode->getKind()) {
228 Stack.push_back(StackLevel(*DestNode, MergeResult, Obj.Length, nullptr));
229 break;
230 default:
231 break;
232 }
233
234 // Pop finished stack levels.
235 while (!Stack.empty()) {
236 if (Stack.back().MapEntry)
237 break;
238 if (Stack.back().Index != Stack.back().End)
239 break;
240 Stack.pop_back();
241 }
242 } while (!Stack.empty());
243 return true;
244}
245
248 DocNode::MapTy::iterator MapIt;
249 DocNode::ArrayTy::iterator ArrayIt;
250 bool OnKey;
251};
252
253/// Write a MsgPack document to a binary MsgPack blob.
254void Document::writeToBlob(std::string &Blob) {
255 Blob.clear();
257 msgpack::Writer MPWriter(OS);
259 DocNode Node = getRoot();
260 for (;;) {
261 switch (Node.getKind()) {
262 case Type::Array:
263 MPWriter.writeArraySize(Node.getArray().size());
264 Stack.push_back(
265 {Node, DocNode::MapTy::iterator(), Node.getArray().begin(), false});
266 break;
267 case Type::Map:
268 MPWriter.writeMapSize(Node.getMap().size());
269 Stack.push_back(
270 {Node, Node.getMap().begin(), DocNode::ArrayTy::iterator(), true});
271 break;
272 case Type::Nil:
273 MPWriter.writeNil();
274 break;
275 case Type::Boolean:
276 MPWriter.write(Node.getBool());
277 break;
278 case Type::Int:
279 MPWriter.write(Node.getInt());
280 break;
281 case Type::UInt:
282 MPWriter.write(Node.getUInt());
283 break;
284 case Type::String:
285 MPWriter.write(Node.getString());
286 break;
287 case Type::Binary:
288 MPWriter.write(Node.getBinary());
289 break;
290 case Type::Empty:
291 llvm_unreachable("unhandled empty msgpack node");
292 default:
293 llvm_unreachable("unhandled msgpack object kind");
294 }
295 // Pop finished stack levels.
296 while (!Stack.empty()) {
297 if (Stack.back().Node.getKind() == Type::Map) {
298 if (Stack.back().MapIt != Stack.back().Node.getMap().end())
299 break;
300 } else {
301 if (Stack.back().ArrayIt != Stack.back().Node.getArray().end())
302 break;
303 }
304 Stack.pop_back();
305 }
306 if (Stack.empty())
307 break;
308 // Get the next value.
309 if (Stack.back().Node.getKind() == Type::Map) {
310 if (Stack.back().OnKey) {
311 // Do the key of a key,value pair in a map.
312 Node = Stack.back().MapIt->first;
313 Stack.back().OnKey = false;
314 } else {
315 Node = Stack.back().MapIt->second;
316 ++Stack.back().MapIt;
317 Stack.back().OnKey = true;
318 }
319 } else {
320 Node = *Stack.back().ArrayIt;
321 ++Stack.back().ArrayIt;
322 }
323 }
324}
bool End
Definition: ELF_riscv.cpp:464
This file declares a class that exposes a simple in-memory representation of a document of MsgPack ob...
This file contains a MessagePack writer.
R600 Vector Reg Merger
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
An efficient, type-erasing, non-owning reference to a callable.
DocNode & operator[](size_t Index)
Element access. This extends the array if necessary, with empty nodes.
A node in a MsgPack Document.
DocNode & operator=(const char *Val)
Convenience assignment operators.
Document * getDocument() const
MapDocNode getMapNode()
Create an empty Map node associated with this Document.
DocNode getEmptyNode()
Create an empty node associated with this Document.
DocNode & getRoot()
Get ref to the document's root element.
DocNode getNode()
Create a nil node associated with this Document.
ArrayDocNode getArrayNode()
Create an empty Array node associated with this Document.
void writeToBlob(std::string &Blob)
Write a MsgPack document to a binary MsgPack blob.
bool readFromBlob(StringRef Blob, bool Multi, function_ref< int(DocNode *DestNode, DocNode SrcNode, DocNode MapKey)> Merger=[](DocNode *DestNode, DocNode SrcNode, DocNode MapKey) { return -1;})
Read a document from a binary msgpack blob, merging into anything already in the Document.
MapTy::iterator find(DocNode Key)
DocNode & operator[](StringRef S)
Member access.
Reads MessagePack objects from memory, one at a time.
Definition: MsgPackReader.h:99
Expected< bool > read(Object &Obj)
Read one object from the input buffer, advancing past it.
Writes MessagePack objects to an output stream, one at a time.
Definition: MsgPackWriter.h:41
void writeNil()
Write a Nil to the output stream.
void writeMapSize(uint32_t Size)
Write the header for a Map of the given size.
void writeArraySize(uint32_t Size)
Write the header for an Array of the given size.
void write(bool b)
Write a Boolean to the output stream.
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Length
Definition: DWP.cpp:440
sampleprof_error MergeResult(sampleprof_error &Accumulator, sampleprof_error Result)
Definition: SampleProf.h:68
#define N
StackLevel(DocNode Node, size_t StartIndex, size_t Length, DocNode *MapEntry=nullptr)
DocNode * MapEntry
DocNode::MapTy::iterator MapIt
DocNode::ArrayTy::iterator ArrayIt
MessagePack object, represented as a tagged union of C++ types.
Definition: MsgPackReader.h:76
int64_t Int
Value for Type::Int.
Definition: MsgPackReader.h:80
double Float
Value for Type::Float.
Definition: MsgPackReader.h:86
StringRef Raw
Value for Type::String and Type::Binary.
Definition: MsgPackReader.h:88
uint64_t UInt
Value for Type::Uint.
Definition: MsgPackReader.h:82
bool Bool
Value for Type::Boolean.
Definition: MsgPackReader.h:84
size_t Length
Value for Type::Array and Type::Map.
Definition: MsgPackReader.h:90