1pub(crate) mod _field_impls {
2 #![allow(clippy::wrong_self_convention)]
3 use super::*;
4 use crate::field::MessageFields;
5 use crate::field::MessageField;
6 impl MerkleNode {
7 pub const EMPTY_FIELD: &'static MessageField = &MessageField {
8 name: "empty",
9 json_name: "empty",
10 number: 1i32,
11 message_fields: None,
12 };
13 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
14 name: "digest",
15 json_name: "digest",
16 number: 2i32,
17 message_fields: None,
18 };
19 }
20 impl MessageFields for MerkleNode {
21 const FIELDS: &'static [&'static MessageField] = &[
22 Self::EMPTY_FIELD,
23 Self::DIGEST_FIELD,
24 ];
25 }
26 impl MerkleNode {
27 pub fn path_builder() -> MerkleNodeFieldPathBuilder {
28 MerkleNodeFieldPathBuilder::new()
29 }
30 }
31 pub struct MerkleNodeFieldPathBuilder {
32 path: Vec<&'static str>,
33 }
34 impl MerkleNodeFieldPathBuilder {
35 #[allow(clippy::new_without_default)]
36 pub fn new() -> Self {
37 Self { path: Default::default() }
38 }
39 #[doc(hidden)]
40 pub fn new_with_base(base: Vec<&'static str>) -> Self {
41 Self { path: base }
42 }
43 pub fn finish(self) -> String {
44 self.path.join(".")
45 }
46 pub fn empty(mut self) -> String {
47 self.path.push(MerkleNode::EMPTY_FIELD.name);
48 self.finish()
49 }
50 pub fn digest(mut self) -> String {
51 self.path.push(MerkleNode::DIGEST_FIELD.name);
52 self.finish()
53 }
54 }
55 impl MerkleProof {
56 pub const PATH_FIELD: &'static MessageField = &MessageField {
57 name: "path",
58 json_name: "path",
59 number: 1i32,
60 message_fields: Some(MerkleNode::FIELDS),
61 };
62 }
63 impl MessageFields for MerkleProof {
64 const FIELDS: &'static [&'static MessageField] = &[Self::PATH_FIELD];
65 }
66 impl MerkleProof {
67 pub fn path_builder() -> MerkleProofFieldPathBuilder {
68 MerkleProofFieldPathBuilder::new()
69 }
70 }
71 pub struct MerkleProofFieldPathBuilder {
72 path: Vec<&'static str>,
73 }
74 impl MerkleProofFieldPathBuilder {
75 #[allow(clippy::new_without_default)]
76 pub fn new() -> Self {
77 Self { path: Default::default() }
78 }
79 #[doc(hidden)]
80 pub fn new_with_base(base: Vec<&'static str>) -> Self {
81 Self { path: base }
82 }
83 pub fn finish(self) -> String {
84 self.path.join(".")
85 }
86 pub fn path(mut self) -> MerkleNodeFieldPathBuilder {
87 self.path.push(MerkleProof::PATH_FIELD.name);
88 MerkleNodeFieldPathBuilder::new_with_base(self.path)
89 }
90 }
91 impl MerkleNonInclusionProof {
92 pub const INDEX_FIELD: &'static MessageField = &MessageField {
93 name: "index",
94 json_name: "index",
95 number: 1i32,
96 message_fields: None,
97 };
98 pub const LEFT_LEAF_FIELD: &'static MessageField = &MessageField {
99 name: "left_leaf",
100 json_name: "leftLeaf",
101 number: 2i32,
102 message_fields: Some(MerkleNeighbourLeaf::FIELDS),
103 };
104 pub const RIGHT_LEAF_FIELD: &'static MessageField = &MessageField {
105 name: "right_leaf",
106 json_name: "rightLeaf",
107 number: 3i32,
108 message_fields: Some(MerkleNeighbourLeaf::FIELDS),
109 };
110 }
111 impl MessageFields for MerkleNonInclusionProof {
112 const FIELDS: &'static [&'static MessageField] = &[
113 Self::INDEX_FIELD,
114 Self::LEFT_LEAF_FIELD,
115 Self::RIGHT_LEAF_FIELD,
116 ];
117 }
118 impl MerkleNonInclusionProof {
119 pub fn path_builder() -> MerkleNonInclusionProofFieldPathBuilder {
120 MerkleNonInclusionProofFieldPathBuilder::new()
121 }
122 }
123 pub struct MerkleNonInclusionProofFieldPathBuilder {
124 path: Vec<&'static str>,
125 }
126 impl MerkleNonInclusionProofFieldPathBuilder {
127 #[allow(clippy::new_without_default)]
128 pub fn new() -> Self {
129 Self { path: Default::default() }
130 }
131 #[doc(hidden)]
132 pub fn new_with_base(base: Vec<&'static str>) -> Self {
133 Self { path: base }
134 }
135 pub fn finish(self) -> String {
136 self.path.join(".")
137 }
138 pub fn index(mut self) -> String {
139 self.path.push(MerkleNonInclusionProof::INDEX_FIELD.name);
140 self.finish()
141 }
142 pub fn left_leaf(mut self) -> MerkleNeighbourLeafFieldPathBuilder {
143 self.path.push(MerkleNonInclusionProof::LEFT_LEAF_FIELD.name);
144 MerkleNeighbourLeafFieldPathBuilder::new_with_base(self.path)
145 }
146 pub fn right_leaf(mut self) -> MerkleNeighbourLeafFieldPathBuilder {
147 self.path.push(MerkleNonInclusionProof::RIGHT_LEAF_FIELD.name);
148 MerkleNeighbourLeafFieldPathBuilder::new_with_base(self.path)
149 }
150 }
151 impl MerkleNeighbourLeaf {
152 pub const LEAF_FIELD: &'static MessageField = &MessageField {
153 name: "leaf",
154 json_name: "leaf",
155 number: 1i32,
156 message_fields: Some(ObjectReference::FIELDS),
157 };
158 pub const MERKLE_PROOF_FIELD: &'static MessageField = &MessageField {
159 name: "merkle_proof",
160 json_name: "merkleProof",
161 number: 2i32,
162 message_fields: Some(MerkleProof::FIELDS),
163 };
164 }
165 impl MessageFields for MerkleNeighbourLeaf {
166 const FIELDS: &'static [&'static MessageField] = &[
167 Self::LEAF_FIELD,
168 Self::MERKLE_PROOF_FIELD,
169 ];
170 }
171 impl MerkleNeighbourLeaf {
172 pub fn path_builder() -> MerkleNeighbourLeafFieldPathBuilder {
173 MerkleNeighbourLeafFieldPathBuilder::new()
174 }
175 }
176 pub struct MerkleNeighbourLeafFieldPathBuilder {
177 path: Vec<&'static str>,
178 }
179 impl MerkleNeighbourLeafFieldPathBuilder {
180 #[allow(clippy::new_without_default)]
181 pub fn new() -> Self {
182 Self { path: Default::default() }
183 }
184 #[doc(hidden)]
185 pub fn new_with_base(base: Vec<&'static str>) -> Self {
186 Self { path: base }
187 }
188 pub fn finish(self) -> String {
189 self.path.join(".")
190 }
191 pub fn leaf(mut self) -> ObjectReferenceFieldPathBuilder {
192 self.path.push(MerkleNeighbourLeaf::LEAF_FIELD.name);
193 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
194 }
195 pub fn merkle_proof(mut self) -> MerkleProofFieldPathBuilder {
196 self.path.push(MerkleNeighbourLeaf::MERKLE_PROOF_FIELD.name);
197 MerkleProofFieldPathBuilder::new_with_base(self.path)
198 }
199 }
200 impl OcsInclusionProof {
201 pub const OBJECT_REF_FIELD: &'static MessageField = &MessageField {
202 name: "object_ref",
203 json_name: "objectRef",
204 number: 1i32,
205 message_fields: Some(ObjectReference::FIELDS),
206 };
207 pub const MERKLE_PROOF_FIELD: &'static MessageField = &MessageField {
208 name: "merkle_proof",
209 json_name: "merkleProof",
210 number: 2i32,
211 message_fields: Some(MerkleProof::FIELDS),
212 };
213 pub const LEAF_INDEX_FIELD: &'static MessageField = &MessageField {
214 name: "leaf_index",
215 json_name: "leafIndex",
216 number: 3i32,
217 message_fields: None,
218 };
219 pub const TREE_ROOT_FIELD: &'static MessageField = &MessageField {
220 name: "tree_root",
221 json_name: "treeRoot",
222 number: 4i32,
223 message_fields: None,
224 };
225 pub const OBJECT_DATA_FIELD: &'static MessageField = &MessageField {
226 name: "object_data",
227 json_name: "objectData",
228 number: 5i32,
229 message_fields: None,
230 };
231 }
232 impl MessageFields for OcsInclusionProof {
233 const FIELDS: &'static [&'static MessageField] = &[
234 Self::OBJECT_REF_FIELD,
235 Self::MERKLE_PROOF_FIELD,
236 Self::LEAF_INDEX_FIELD,
237 Self::TREE_ROOT_FIELD,
238 Self::OBJECT_DATA_FIELD,
239 ];
240 }
241 impl OcsInclusionProof {
242 pub fn path_builder() -> OcsInclusionProofFieldPathBuilder {
243 OcsInclusionProofFieldPathBuilder::new()
244 }
245 }
246 pub struct OcsInclusionProofFieldPathBuilder {
247 path: Vec<&'static str>,
248 }
249 impl OcsInclusionProofFieldPathBuilder {
250 #[allow(clippy::new_without_default)]
251 pub fn new() -> Self {
252 Self { path: Default::default() }
253 }
254 #[doc(hidden)]
255 pub fn new_with_base(base: Vec<&'static str>) -> Self {
256 Self { path: base }
257 }
258 pub fn finish(self) -> String {
259 self.path.join(".")
260 }
261 pub fn object_ref(mut self) -> ObjectReferenceFieldPathBuilder {
262 self.path.push(OcsInclusionProof::OBJECT_REF_FIELD.name);
263 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
264 }
265 pub fn merkle_proof(mut self) -> MerkleProofFieldPathBuilder {
266 self.path.push(OcsInclusionProof::MERKLE_PROOF_FIELD.name);
267 MerkleProofFieldPathBuilder::new_with_base(self.path)
268 }
269 pub fn leaf_index(mut self) -> String {
270 self.path.push(OcsInclusionProof::LEAF_INDEX_FIELD.name);
271 self.finish()
272 }
273 pub fn tree_root(mut self) -> String {
274 self.path.push(OcsInclusionProof::TREE_ROOT_FIELD.name);
275 self.finish()
276 }
277 pub fn object_data(mut self) -> String {
278 self.path.push(OcsInclusionProof::OBJECT_DATA_FIELD.name);
279 self.finish()
280 }
281 }
282 impl OcsNonInclusionProof {
283 pub const NON_INCLUSION_PROOF_FIELD: &'static MessageField = &MessageField {
284 name: "non_inclusion_proof",
285 json_name: "nonInclusionProof",
286 number: 1i32,
287 message_fields: Some(MerkleNonInclusionProof::FIELDS),
288 };
289 pub const TREE_ROOT_FIELD: &'static MessageField = &MessageField {
290 name: "tree_root",
291 json_name: "treeRoot",
292 number: 2i32,
293 message_fields: None,
294 };
295 }
296 impl MessageFields for OcsNonInclusionProof {
297 const FIELDS: &'static [&'static MessageField] = &[
298 Self::NON_INCLUSION_PROOF_FIELD,
299 Self::TREE_ROOT_FIELD,
300 ];
301 }
302 impl OcsNonInclusionProof {
303 pub fn path_builder() -> OcsNonInclusionProofFieldPathBuilder {
304 OcsNonInclusionProofFieldPathBuilder::new()
305 }
306 }
307 pub struct OcsNonInclusionProofFieldPathBuilder {
308 path: Vec<&'static str>,
309 }
310 impl OcsNonInclusionProofFieldPathBuilder {
311 #[allow(clippy::new_without_default)]
312 pub fn new() -> Self {
313 Self { path: Default::default() }
314 }
315 #[doc(hidden)]
316 pub fn new_with_base(base: Vec<&'static str>) -> Self {
317 Self { path: base }
318 }
319 pub fn finish(self) -> String {
320 self.path.join(".")
321 }
322 pub fn non_inclusion_proof(mut self) -> MerkleNonInclusionProofFieldPathBuilder {
323 self.path.push(OcsNonInclusionProof::NON_INCLUSION_PROOF_FIELD.name);
324 MerkleNonInclusionProofFieldPathBuilder::new_with_base(self.path)
325 }
326 pub fn tree_root(mut self) -> String {
327 self.path.push(OcsNonInclusionProof::TREE_ROOT_FIELD.name);
328 self.finish()
329 }
330 }
331 impl GetCheckpointObjectProofRequest {
332 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
333 name: "object_id",
334 json_name: "objectId",
335 number: 1i32,
336 message_fields: None,
337 };
338 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
339 name: "checkpoint",
340 json_name: "checkpoint",
341 number: 2i32,
342 message_fields: None,
343 };
344 }
345 impl MessageFields for GetCheckpointObjectProofRequest {
346 const FIELDS: &'static [&'static MessageField] = &[
347 Self::OBJECT_ID_FIELD,
348 Self::CHECKPOINT_FIELD,
349 ];
350 }
351 impl GetCheckpointObjectProofRequest {
352 pub fn path_builder() -> GetCheckpointObjectProofRequestFieldPathBuilder {
353 GetCheckpointObjectProofRequestFieldPathBuilder::new()
354 }
355 }
356 pub struct GetCheckpointObjectProofRequestFieldPathBuilder {
357 path: Vec<&'static str>,
358 }
359 impl GetCheckpointObjectProofRequestFieldPathBuilder {
360 #[allow(clippy::new_without_default)]
361 pub fn new() -> Self {
362 Self { path: Default::default() }
363 }
364 #[doc(hidden)]
365 pub fn new_with_base(base: Vec<&'static str>) -> Self {
366 Self { path: base }
367 }
368 pub fn finish(self) -> String {
369 self.path.join(".")
370 }
371 pub fn object_id(mut self) -> String {
372 self.path.push(GetCheckpointObjectProofRequest::OBJECT_ID_FIELD.name);
373 self.finish()
374 }
375 pub fn checkpoint(mut self) -> String {
376 self.path.push(GetCheckpointObjectProofRequest::CHECKPOINT_FIELD.name);
377 self.finish()
378 }
379 }
380 impl GetCheckpointObjectProofResponse {
381 pub const CHECKPOINT_SUMMARY_FIELD: &'static MessageField = &MessageField {
382 name: "checkpoint_summary",
383 json_name: "checkpointSummary",
384 number: 1i32,
385 message_fields: None,
386 };
387 pub const INCLUSION_FIELD: &'static MessageField = &MessageField {
388 name: "inclusion",
389 json_name: "inclusion",
390 number: 2i32,
391 message_fields: Some(OcsInclusionProof::FIELDS),
392 };
393 pub const NON_INCLUSION_FIELD: &'static MessageField = &MessageField {
394 name: "non_inclusion",
395 json_name: "nonInclusion",
396 number: 3i32,
397 message_fields: Some(OcsNonInclusionProof::FIELDS),
398 };
399 }
400 impl MessageFields for GetCheckpointObjectProofResponse {
401 const FIELDS: &'static [&'static MessageField] = &[
402 Self::CHECKPOINT_SUMMARY_FIELD,
403 Self::INCLUSION_FIELD,
404 Self::NON_INCLUSION_FIELD,
405 ];
406 }
407 impl GetCheckpointObjectProofResponse {
408 pub fn path_builder() -> GetCheckpointObjectProofResponseFieldPathBuilder {
409 GetCheckpointObjectProofResponseFieldPathBuilder::new()
410 }
411 }
412 pub struct GetCheckpointObjectProofResponseFieldPathBuilder {
413 path: Vec<&'static str>,
414 }
415 impl GetCheckpointObjectProofResponseFieldPathBuilder {
416 #[allow(clippy::new_without_default)]
417 pub fn new() -> Self {
418 Self { path: Default::default() }
419 }
420 #[doc(hidden)]
421 pub fn new_with_base(base: Vec<&'static str>) -> Self {
422 Self { path: base }
423 }
424 pub fn finish(self) -> String {
425 self.path.join(".")
426 }
427 pub fn checkpoint_summary(mut self) -> String {
428 self.path
429 .push(GetCheckpointObjectProofResponse::CHECKPOINT_SUMMARY_FIELD.name);
430 self.finish()
431 }
432 pub fn inclusion(mut self) -> OcsInclusionProofFieldPathBuilder {
433 self.path.push(GetCheckpointObjectProofResponse::INCLUSION_FIELD.name);
434 OcsInclusionProofFieldPathBuilder::new_with_base(self.path)
435 }
436 pub fn non_inclusion(mut self) -> OcsNonInclusionProofFieldPathBuilder {
437 self.path.push(GetCheckpointObjectProofResponse::NON_INCLUSION_FIELD.name);
438 OcsNonInclusionProofFieldPathBuilder::new_with_base(self.path)
439 }
440 }
441}