1use super::blockchain::*;
4use super::extensions::*;
5use molecule::prelude::*;
6#[derive(Clone)]
7pub struct PingPayload(molecule::bytes::Bytes);
8impl ::core::fmt::LowerHex for PingPayload {
9 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
10 use molecule::hex_string;
11 if f.alternate() {
12 write!(f, "0x")?;
13 }
14 write!(f, "{}", hex_string(self.as_slice()))
15 }
16}
17impl ::core::fmt::Debug for PingPayload {
18 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
19 write!(f, "{}({:#x})", Self::NAME, self)
20 }
21}
22impl ::core::fmt::Display for PingPayload {
23 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
24 write!(f, "{}(", Self::NAME)?;
25 self.to_enum().display_inner(f)?;
26 write!(f, ")")
27 }
28}
29impl ::core::default::Default for PingPayload {
30 fn default() -> Self {
31 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
32 PingPayload::new_unchecked(v)
33 }
34}
35impl PingPayload {
36 const DEFAULT_VALUE: [u8; 16] = [0, 0, 0, 0, 12, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0];
37 pub const ITEMS_COUNT: usize = 2;
38 pub fn item_id(&self) -> molecule::Number {
39 molecule::unpack_number(self.as_slice())
40 }
41 pub fn to_enum(&self) -> PingPayloadUnion {
42 let inner = self.0.slice(molecule::NUMBER_SIZE..);
43 match self.item_id() {
44 0 => Ping::new_unchecked(inner).into(),
45 1 => Pong::new_unchecked(inner).into(),
46 _ => panic!("{}: invalid data", Self::NAME),
47 }
48 }
49 pub fn as_reader<'r>(&'r self) -> PingPayloadReader<'r> {
50 PingPayloadReader::new_unchecked(self.as_slice())
51 }
52}
53impl molecule::prelude::Entity for PingPayload {
54 type Builder = PingPayloadBuilder;
55 const NAME: &'static str = "PingPayload";
56 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
57 PingPayload(data)
58 }
59 fn as_bytes(&self) -> molecule::bytes::Bytes {
60 self.0.clone()
61 }
62 fn as_slice(&self) -> &[u8] {
63 &self.0[..]
64 }
65 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
66 PingPayloadReader::from_slice(slice).map(|reader| reader.to_entity())
67 }
68 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
69 PingPayloadReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
70 }
71 fn new_builder() -> Self::Builder {
72 ::core::default::Default::default()
73 }
74 fn as_builder(self) -> Self::Builder {
75 Self::new_builder().set(self.to_enum())
76 }
77}
78#[derive(Clone, Copy)]
79pub struct PingPayloadReader<'r>(&'r [u8]);
80impl<'r> ::core::fmt::LowerHex for PingPayloadReader<'r> {
81 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
82 use molecule::hex_string;
83 if f.alternate() {
84 write!(f, "0x")?;
85 }
86 write!(f, "{}", hex_string(self.as_slice()))
87 }
88}
89impl<'r> ::core::fmt::Debug for PingPayloadReader<'r> {
90 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
91 write!(f, "{}({:#x})", Self::NAME, self)
92 }
93}
94impl<'r> ::core::fmt::Display for PingPayloadReader<'r> {
95 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
96 write!(f, "{}(", Self::NAME)?;
97 self.to_enum().display_inner(f)?;
98 write!(f, ")")
99 }
100}
101impl<'r> PingPayloadReader<'r> {
102 pub const ITEMS_COUNT: usize = 2;
103 pub fn item_id(&self) -> molecule::Number {
104 molecule::unpack_number(self.as_slice())
105 }
106 pub fn to_enum(&self) -> PingPayloadUnionReader<'r> {
107 let inner = &self.as_slice()[molecule::NUMBER_SIZE..];
108 match self.item_id() {
109 0 => PingReader::new_unchecked(inner).into(),
110 1 => PongReader::new_unchecked(inner).into(),
111 _ => panic!("{}: invalid data", Self::NAME),
112 }
113 }
114}
115impl<'r> molecule::prelude::Reader<'r> for PingPayloadReader<'r> {
116 type Entity = PingPayload;
117 const NAME: &'static str = "PingPayloadReader";
118 fn to_entity(&self) -> Self::Entity {
119 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
120 }
121 fn new_unchecked(slice: &'r [u8]) -> Self {
122 PingPayloadReader(slice)
123 }
124 fn as_slice(&self) -> &'r [u8] {
125 self.0
126 }
127 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
128 use molecule::verification_error as ve;
129 let slice_len = slice.len();
130 if slice_len < molecule::NUMBER_SIZE {
131 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
132 }
133 let item_id = molecule::unpack_number(slice);
134 let inner_slice = &slice[molecule::NUMBER_SIZE..];
135 match item_id {
136 0 => PingReader::verify(inner_slice, compatible),
137 1 => PongReader::verify(inner_slice, compatible),
138 _ => ve!(Self, UnknownItem, Self::ITEMS_COUNT, item_id),
139 }?;
140 Ok(())
141 }
142}
143#[derive(Debug, Default)]
144pub struct PingPayloadBuilder(pub(crate) PingPayloadUnion);
145impl PingPayloadBuilder {
146 pub const ITEMS_COUNT: usize = 2;
147 pub fn set<I>(mut self, v: I) -> Self
148 where
149 I: ::core::convert::Into<PingPayloadUnion>,
150 {
151 self.0 = v.into();
152 self
153 }
154}
155impl molecule::prelude::Builder for PingPayloadBuilder {
156 type Entity = PingPayload;
157 const NAME: &'static str = "PingPayloadBuilder";
158 fn expected_length(&self) -> usize {
159 molecule::NUMBER_SIZE + self.0.as_slice().len()
160 }
161 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
162 writer.write_all(&molecule::pack_number(self.0.item_id()))?;
163 writer.write_all(self.0.as_slice())
164 }
165 fn build(&self) -> Self::Entity {
166 let mut inner = Vec::with_capacity(self.expected_length());
167 self.write(&mut inner)
168 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
169 PingPayload::new_unchecked(inner.into())
170 }
171}
172#[derive(Debug, Clone)]
173pub enum PingPayloadUnion {
174 Ping(Ping),
175 Pong(Pong),
176}
177#[derive(Debug, Clone, Copy)]
178pub enum PingPayloadUnionReader<'r> {
179 Ping(PingReader<'r>),
180 Pong(PongReader<'r>),
181}
182impl ::core::default::Default for PingPayloadUnion {
183 fn default() -> Self {
184 PingPayloadUnion::Ping(::core::default::Default::default())
185 }
186}
187impl ::core::fmt::Display for PingPayloadUnion {
188 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
189 match self {
190 PingPayloadUnion::Ping(ref item) => {
191 write!(f, "{}::{}({})", Self::NAME, Ping::NAME, item)
192 }
193 PingPayloadUnion::Pong(ref item) => {
194 write!(f, "{}::{}({})", Self::NAME, Pong::NAME, item)
195 }
196 }
197 }
198}
199impl<'r> ::core::fmt::Display for PingPayloadUnionReader<'r> {
200 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
201 match self {
202 PingPayloadUnionReader::Ping(ref item) => {
203 write!(f, "{}::{}({})", Self::NAME, Ping::NAME, item)
204 }
205 PingPayloadUnionReader::Pong(ref item) => {
206 write!(f, "{}::{}({})", Self::NAME, Pong::NAME, item)
207 }
208 }
209 }
210}
211impl PingPayloadUnion {
212 pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
213 match self {
214 PingPayloadUnion::Ping(ref item) => write!(f, "{}", item),
215 PingPayloadUnion::Pong(ref item) => write!(f, "{}", item),
216 }
217 }
218}
219impl<'r> PingPayloadUnionReader<'r> {
220 pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
221 match self {
222 PingPayloadUnionReader::Ping(ref item) => write!(f, "{}", item),
223 PingPayloadUnionReader::Pong(ref item) => write!(f, "{}", item),
224 }
225 }
226}
227impl ::core::convert::From<Ping> for PingPayloadUnion {
228 fn from(item: Ping) -> Self {
229 PingPayloadUnion::Ping(item)
230 }
231}
232impl ::core::convert::From<Pong> for PingPayloadUnion {
233 fn from(item: Pong) -> Self {
234 PingPayloadUnion::Pong(item)
235 }
236}
237impl<'r> ::core::convert::From<PingReader<'r>> for PingPayloadUnionReader<'r> {
238 fn from(item: PingReader<'r>) -> Self {
239 PingPayloadUnionReader::Ping(item)
240 }
241}
242impl<'r> ::core::convert::From<PongReader<'r>> for PingPayloadUnionReader<'r> {
243 fn from(item: PongReader<'r>) -> Self {
244 PingPayloadUnionReader::Pong(item)
245 }
246}
247impl PingPayloadUnion {
248 pub const NAME: &'static str = "PingPayloadUnion";
249 pub fn as_bytes(&self) -> molecule::bytes::Bytes {
250 match self {
251 PingPayloadUnion::Ping(item) => item.as_bytes(),
252 PingPayloadUnion::Pong(item) => item.as_bytes(),
253 }
254 }
255 pub fn as_slice(&self) -> &[u8] {
256 match self {
257 PingPayloadUnion::Ping(item) => item.as_slice(),
258 PingPayloadUnion::Pong(item) => item.as_slice(),
259 }
260 }
261 pub fn item_id(&self) -> molecule::Number {
262 match self {
263 PingPayloadUnion::Ping(_) => 0,
264 PingPayloadUnion::Pong(_) => 1,
265 }
266 }
267 pub fn item_name(&self) -> &str {
268 match self {
269 PingPayloadUnion::Ping(_) => "Ping",
270 PingPayloadUnion::Pong(_) => "Pong",
271 }
272 }
273 pub fn as_reader<'r>(&'r self) -> PingPayloadUnionReader<'r> {
274 match self {
275 PingPayloadUnion::Ping(item) => item.as_reader().into(),
276 PingPayloadUnion::Pong(item) => item.as_reader().into(),
277 }
278 }
279}
280impl<'r> PingPayloadUnionReader<'r> {
281 pub const NAME: &'r str = "PingPayloadUnionReader";
282 pub fn as_slice(&self) -> &'r [u8] {
283 match self {
284 PingPayloadUnionReader::Ping(item) => item.as_slice(),
285 PingPayloadUnionReader::Pong(item) => item.as_slice(),
286 }
287 }
288 pub fn item_id(&self) -> molecule::Number {
289 match self {
290 PingPayloadUnionReader::Ping(_) => 0,
291 PingPayloadUnionReader::Pong(_) => 1,
292 }
293 }
294 pub fn item_name(&self) -> &str {
295 match self {
296 PingPayloadUnionReader::Ping(_) => "Ping",
297 PingPayloadUnionReader::Pong(_) => "Pong",
298 }
299 }
300}
301#[derive(Clone)]
302pub struct PingMessage(molecule::bytes::Bytes);
303impl ::core::fmt::LowerHex for PingMessage {
304 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
305 use molecule::hex_string;
306 if f.alternate() {
307 write!(f, "0x")?;
308 }
309 write!(f, "{}", hex_string(self.as_slice()))
310 }
311}
312impl ::core::fmt::Debug for PingMessage {
313 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
314 write!(f, "{}({:#x})", Self::NAME, self)
315 }
316}
317impl ::core::fmt::Display for PingMessage {
318 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
319 write!(f, "{} {{ ", Self::NAME)?;
320 write!(f, "{}: {}", "payload", self.payload())?;
321 let extra_count = self.count_extra_fields();
322 if extra_count != 0 {
323 write!(f, ", .. ({} fields)", extra_count)?;
324 }
325 write!(f, " }}")
326 }
327}
328impl ::core::default::Default for PingMessage {
329 fn default() -> Self {
330 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
331 PingMessage::new_unchecked(v)
332 }
333}
334impl PingMessage {
335 const DEFAULT_VALUE: [u8; 24] = [
336 24, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
337 ];
338 pub const FIELD_COUNT: usize = 1;
339 pub fn total_size(&self) -> usize {
340 molecule::unpack_number(self.as_slice()) as usize
341 }
342 pub fn field_count(&self) -> usize {
343 if self.total_size() == molecule::NUMBER_SIZE {
344 0
345 } else {
346 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
347 }
348 }
349 pub fn count_extra_fields(&self) -> usize {
350 self.field_count() - Self::FIELD_COUNT
351 }
352 pub fn has_extra_fields(&self) -> bool {
353 Self::FIELD_COUNT != self.field_count()
354 }
355 pub fn payload(&self) -> PingPayload {
356 let slice = self.as_slice();
357 let start = molecule::unpack_number(&slice[4..]) as usize;
358 if self.has_extra_fields() {
359 let end = molecule::unpack_number(&slice[8..]) as usize;
360 PingPayload::new_unchecked(self.0.slice(start..end))
361 } else {
362 PingPayload::new_unchecked(self.0.slice(start..))
363 }
364 }
365 pub fn as_reader<'r>(&'r self) -> PingMessageReader<'r> {
366 PingMessageReader::new_unchecked(self.as_slice())
367 }
368}
369impl molecule::prelude::Entity for PingMessage {
370 type Builder = PingMessageBuilder;
371 const NAME: &'static str = "PingMessage";
372 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
373 PingMessage(data)
374 }
375 fn as_bytes(&self) -> molecule::bytes::Bytes {
376 self.0.clone()
377 }
378 fn as_slice(&self) -> &[u8] {
379 &self.0[..]
380 }
381 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
382 PingMessageReader::from_slice(slice).map(|reader| reader.to_entity())
383 }
384 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
385 PingMessageReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
386 }
387 fn new_builder() -> Self::Builder {
388 ::core::default::Default::default()
389 }
390 fn as_builder(self) -> Self::Builder {
391 Self::new_builder().payload(self.payload())
392 }
393}
394#[derive(Clone, Copy)]
395pub struct PingMessageReader<'r>(&'r [u8]);
396impl<'r> ::core::fmt::LowerHex for PingMessageReader<'r> {
397 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
398 use molecule::hex_string;
399 if f.alternate() {
400 write!(f, "0x")?;
401 }
402 write!(f, "{}", hex_string(self.as_slice()))
403 }
404}
405impl<'r> ::core::fmt::Debug for PingMessageReader<'r> {
406 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
407 write!(f, "{}({:#x})", Self::NAME, self)
408 }
409}
410impl<'r> ::core::fmt::Display for PingMessageReader<'r> {
411 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
412 write!(f, "{} {{ ", Self::NAME)?;
413 write!(f, "{}: {}", "payload", self.payload())?;
414 let extra_count = self.count_extra_fields();
415 if extra_count != 0 {
416 write!(f, ", .. ({} fields)", extra_count)?;
417 }
418 write!(f, " }}")
419 }
420}
421impl<'r> PingMessageReader<'r> {
422 pub const FIELD_COUNT: usize = 1;
423 pub fn total_size(&self) -> usize {
424 molecule::unpack_number(self.as_slice()) as usize
425 }
426 pub fn field_count(&self) -> usize {
427 if self.total_size() == molecule::NUMBER_SIZE {
428 0
429 } else {
430 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
431 }
432 }
433 pub fn count_extra_fields(&self) -> usize {
434 self.field_count() - Self::FIELD_COUNT
435 }
436 pub fn has_extra_fields(&self) -> bool {
437 Self::FIELD_COUNT != self.field_count()
438 }
439 pub fn payload(&self) -> PingPayloadReader<'r> {
440 let slice = self.as_slice();
441 let start = molecule::unpack_number(&slice[4..]) as usize;
442 if self.has_extra_fields() {
443 let end = molecule::unpack_number(&slice[8..]) as usize;
444 PingPayloadReader::new_unchecked(&self.as_slice()[start..end])
445 } else {
446 PingPayloadReader::new_unchecked(&self.as_slice()[start..])
447 }
448 }
449}
450impl<'r> molecule::prelude::Reader<'r> for PingMessageReader<'r> {
451 type Entity = PingMessage;
452 const NAME: &'static str = "PingMessageReader";
453 fn to_entity(&self) -> Self::Entity {
454 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
455 }
456 fn new_unchecked(slice: &'r [u8]) -> Self {
457 PingMessageReader(slice)
458 }
459 fn as_slice(&self) -> &'r [u8] {
460 self.0
461 }
462 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
463 use molecule::verification_error as ve;
464 let slice_len = slice.len();
465 if slice_len < molecule::NUMBER_SIZE {
466 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
467 }
468 let total_size = molecule::unpack_number(slice) as usize;
469 if slice_len != total_size {
470 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
471 }
472 if slice_len < molecule::NUMBER_SIZE * 2 {
473 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
474 }
475 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
476 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
477 return ve!(Self, OffsetsNotMatch);
478 }
479 if slice_len < offset_first {
480 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
481 }
482 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
483 if field_count < Self::FIELD_COUNT {
484 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
485 } else if !compatible && field_count > Self::FIELD_COUNT {
486 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
487 };
488 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
489 .chunks_exact(molecule::NUMBER_SIZE)
490 .map(|x| molecule::unpack_number(x) as usize)
491 .collect();
492 offsets.push(total_size);
493 if offsets.windows(2).any(|i| i[0] > i[1]) {
494 return ve!(Self, OffsetsNotMatch);
495 }
496 PingPayloadReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
497 Ok(())
498 }
499}
500#[derive(Debug, Default)]
501pub struct PingMessageBuilder {
502 pub(crate) payload: PingPayload,
503}
504impl PingMessageBuilder {
505 pub const FIELD_COUNT: usize = 1;
506 pub fn payload(mut self, v: PingPayload) -> Self {
507 self.payload = v;
508 self
509 }
510}
511impl molecule::prelude::Builder for PingMessageBuilder {
512 type Entity = PingMessage;
513 const NAME: &'static str = "PingMessageBuilder";
514 fn expected_length(&self) -> usize {
515 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.payload.as_slice().len()
516 }
517 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
518 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
519 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
520 offsets.push(total_size);
521 total_size += self.payload.as_slice().len();
522 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
523 for offset in offsets.into_iter() {
524 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
525 }
526 writer.write_all(self.payload.as_slice())?;
527 Ok(())
528 }
529 fn build(&self) -> Self::Entity {
530 let mut inner = Vec::with_capacity(self.expected_length());
531 self.write(&mut inner)
532 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
533 PingMessage::new_unchecked(inner.into())
534 }
535}
536#[derive(Clone)]
537pub struct Ping(molecule::bytes::Bytes);
538impl ::core::fmt::LowerHex for Ping {
539 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
540 use molecule::hex_string;
541 if f.alternate() {
542 write!(f, "0x")?;
543 }
544 write!(f, "{}", hex_string(self.as_slice()))
545 }
546}
547impl ::core::fmt::Debug for Ping {
548 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
549 write!(f, "{}({:#x})", Self::NAME, self)
550 }
551}
552impl ::core::fmt::Display for Ping {
553 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
554 write!(f, "{} {{ ", Self::NAME)?;
555 write!(f, "{}: {}", "nonce", self.nonce())?;
556 let extra_count = self.count_extra_fields();
557 if extra_count != 0 {
558 write!(f, ", .. ({} fields)", extra_count)?;
559 }
560 write!(f, " }}")
561 }
562}
563impl ::core::default::Default for Ping {
564 fn default() -> Self {
565 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
566 Ping::new_unchecked(v)
567 }
568}
569impl Ping {
570 const DEFAULT_VALUE: [u8; 12] = [12, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0];
571 pub const FIELD_COUNT: usize = 1;
572 pub fn total_size(&self) -> usize {
573 molecule::unpack_number(self.as_slice()) as usize
574 }
575 pub fn field_count(&self) -> usize {
576 if self.total_size() == molecule::NUMBER_SIZE {
577 0
578 } else {
579 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
580 }
581 }
582 pub fn count_extra_fields(&self) -> usize {
583 self.field_count() - Self::FIELD_COUNT
584 }
585 pub fn has_extra_fields(&self) -> bool {
586 Self::FIELD_COUNT != self.field_count()
587 }
588 pub fn nonce(&self) -> Uint32 {
589 let slice = self.as_slice();
590 let start = molecule::unpack_number(&slice[4..]) as usize;
591 if self.has_extra_fields() {
592 let end = molecule::unpack_number(&slice[8..]) as usize;
593 Uint32::new_unchecked(self.0.slice(start..end))
594 } else {
595 Uint32::new_unchecked(self.0.slice(start..))
596 }
597 }
598 pub fn as_reader<'r>(&'r self) -> PingReader<'r> {
599 PingReader::new_unchecked(self.as_slice())
600 }
601}
602impl molecule::prelude::Entity for Ping {
603 type Builder = PingBuilder;
604 const NAME: &'static str = "Ping";
605 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
606 Ping(data)
607 }
608 fn as_bytes(&self) -> molecule::bytes::Bytes {
609 self.0.clone()
610 }
611 fn as_slice(&self) -> &[u8] {
612 &self.0[..]
613 }
614 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
615 PingReader::from_slice(slice).map(|reader| reader.to_entity())
616 }
617 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
618 PingReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
619 }
620 fn new_builder() -> Self::Builder {
621 ::core::default::Default::default()
622 }
623 fn as_builder(self) -> Self::Builder {
624 Self::new_builder().nonce(self.nonce())
625 }
626}
627#[derive(Clone, Copy)]
628pub struct PingReader<'r>(&'r [u8]);
629impl<'r> ::core::fmt::LowerHex for PingReader<'r> {
630 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
631 use molecule::hex_string;
632 if f.alternate() {
633 write!(f, "0x")?;
634 }
635 write!(f, "{}", hex_string(self.as_slice()))
636 }
637}
638impl<'r> ::core::fmt::Debug for PingReader<'r> {
639 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
640 write!(f, "{}({:#x})", Self::NAME, self)
641 }
642}
643impl<'r> ::core::fmt::Display for PingReader<'r> {
644 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
645 write!(f, "{} {{ ", Self::NAME)?;
646 write!(f, "{}: {}", "nonce", self.nonce())?;
647 let extra_count = self.count_extra_fields();
648 if extra_count != 0 {
649 write!(f, ", .. ({} fields)", extra_count)?;
650 }
651 write!(f, " }}")
652 }
653}
654impl<'r> PingReader<'r> {
655 pub const FIELD_COUNT: usize = 1;
656 pub fn total_size(&self) -> usize {
657 molecule::unpack_number(self.as_slice()) as usize
658 }
659 pub fn field_count(&self) -> usize {
660 if self.total_size() == molecule::NUMBER_SIZE {
661 0
662 } else {
663 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
664 }
665 }
666 pub fn count_extra_fields(&self) -> usize {
667 self.field_count() - Self::FIELD_COUNT
668 }
669 pub fn has_extra_fields(&self) -> bool {
670 Self::FIELD_COUNT != self.field_count()
671 }
672 pub fn nonce(&self) -> Uint32Reader<'r> {
673 let slice = self.as_slice();
674 let start = molecule::unpack_number(&slice[4..]) as usize;
675 if self.has_extra_fields() {
676 let end = molecule::unpack_number(&slice[8..]) as usize;
677 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
678 } else {
679 Uint32Reader::new_unchecked(&self.as_slice()[start..])
680 }
681 }
682}
683impl<'r> molecule::prelude::Reader<'r> for PingReader<'r> {
684 type Entity = Ping;
685 const NAME: &'static str = "PingReader";
686 fn to_entity(&self) -> Self::Entity {
687 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
688 }
689 fn new_unchecked(slice: &'r [u8]) -> Self {
690 PingReader(slice)
691 }
692 fn as_slice(&self) -> &'r [u8] {
693 self.0
694 }
695 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
696 use molecule::verification_error as ve;
697 let slice_len = slice.len();
698 if slice_len < molecule::NUMBER_SIZE {
699 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
700 }
701 let total_size = molecule::unpack_number(slice) as usize;
702 if slice_len != total_size {
703 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
704 }
705 if slice_len < molecule::NUMBER_SIZE * 2 {
706 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
707 }
708 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
709 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
710 return ve!(Self, OffsetsNotMatch);
711 }
712 if slice_len < offset_first {
713 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
714 }
715 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
716 if field_count < Self::FIELD_COUNT {
717 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
718 } else if !compatible && field_count > Self::FIELD_COUNT {
719 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
720 };
721 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
722 .chunks_exact(molecule::NUMBER_SIZE)
723 .map(|x| molecule::unpack_number(x) as usize)
724 .collect();
725 offsets.push(total_size);
726 if offsets.windows(2).any(|i| i[0] > i[1]) {
727 return ve!(Self, OffsetsNotMatch);
728 }
729 Uint32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
730 Ok(())
731 }
732}
733#[derive(Debug, Default)]
734pub struct PingBuilder {
735 pub(crate) nonce: Uint32,
736}
737impl PingBuilder {
738 pub const FIELD_COUNT: usize = 1;
739 pub fn nonce(mut self, v: Uint32) -> Self {
740 self.nonce = v;
741 self
742 }
743}
744impl molecule::prelude::Builder for PingBuilder {
745 type Entity = Ping;
746 const NAME: &'static str = "PingBuilder";
747 fn expected_length(&self) -> usize {
748 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.nonce.as_slice().len()
749 }
750 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
751 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
752 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
753 offsets.push(total_size);
754 total_size += self.nonce.as_slice().len();
755 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
756 for offset in offsets.into_iter() {
757 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
758 }
759 writer.write_all(self.nonce.as_slice())?;
760 Ok(())
761 }
762 fn build(&self) -> Self::Entity {
763 let mut inner = Vec::with_capacity(self.expected_length());
764 self.write(&mut inner)
765 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
766 Ping::new_unchecked(inner.into())
767 }
768}
769#[derive(Clone)]
770pub struct Pong(molecule::bytes::Bytes);
771impl ::core::fmt::LowerHex for Pong {
772 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
773 use molecule::hex_string;
774 if f.alternate() {
775 write!(f, "0x")?;
776 }
777 write!(f, "{}", hex_string(self.as_slice()))
778 }
779}
780impl ::core::fmt::Debug for Pong {
781 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
782 write!(f, "{}({:#x})", Self::NAME, self)
783 }
784}
785impl ::core::fmt::Display for Pong {
786 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
787 write!(f, "{} {{ ", Self::NAME)?;
788 write!(f, "{}: {}", "nonce", self.nonce())?;
789 let extra_count = self.count_extra_fields();
790 if extra_count != 0 {
791 write!(f, ", .. ({} fields)", extra_count)?;
792 }
793 write!(f, " }}")
794 }
795}
796impl ::core::default::Default for Pong {
797 fn default() -> Self {
798 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
799 Pong::new_unchecked(v)
800 }
801}
802impl Pong {
803 const DEFAULT_VALUE: [u8; 12] = [12, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0];
804 pub const FIELD_COUNT: usize = 1;
805 pub fn total_size(&self) -> usize {
806 molecule::unpack_number(self.as_slice()) as usize
807 }
808 pub fn field_count(&self) -> usize {
809 if self.total_size() == molecule::NUMBER_SIZE {
810 0
811 } else {
812 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
813 }
814 }
815 pub fn count_extra_fields(&self) -> usize {
816 self.field_count() - Self::FIELD_COUNT
817 }
818 pub fn has_extra_fields(&self) -> bool {
819 Self::FIELD_COUNT != self.field_count()
820 }
821 pub fn nonce(&self) -> Uint32 {
822 let slice = self.as_slice();
823 let start = molecule::unpack_number(&slice[4..]) as usize;
824 if self.has_extra_fields() {
825 let end = molecule::unpack_number(&slice[8..]) as usize;
826 Uint32::new_unchecked(self.0.slice(start..end))
827 } else {
828 Uint32::new_unchecked(self.0.slice(start..))
829 }
830 }
831 pub fn as_reader<'r>(&'r self) -> PongReader<'r> {
832 PongReader::new_unchecked(self.as_slice())
833 }
834}
835impl molecule::prelude::Entity for Pong {
836 type Builder = PongBuilder;
837 const NAME: &'static str = "Pong";
838 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
839 Pong(data)
840 }
841 fn as_bytes(&self) -> molecule::bytes::Bytes {
842 self.0.clone()
843 }
844 fn as_slice(&self) -> &[u8] {
845 &self.0[..]
846 }
847 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
848 PongReader::from_slice(slice).map(|reader| reader.to_entity())
849 }
850 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
851 PongReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
852 }
853 fn new_builder() -> Self::Builder {
854 ::core::default::Default::default()
855 }
856 fn as_builder(self) -> Self::Builder {
857 Self::new_builder().nonce(self.nonce())
858 }
859}
860#[derive(Clone, Copy)]
861pub struct PongReader<'r>(&'r [u8]);
862impl<'r> ::core::fmt::LowerHex for PongReader<'r> {
863 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
864 use molecule::hex_string;
865 if f.alternate() {
866 write!(f, "0x")?;
867 }
868 write!(f, "{}", hex_string(self.as_slice()))
869 }
870}
871impl<'r> ::core::fmt::Debug for PongReader<'r> {
872 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
873 write!(f, "{}({:#x})", Self::NAME, self)
874 }
875}
876impl<'r> ::core::fmt::Display for PongReader<'r> {
877 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
878 write!(f, "{} {{ ", Self::NAME)?;
879 write!(f, "{}: {}", "nonce", self.nonce())?;
880 let extra_count = self.count_extra_fields();
881 if extra_count != 0 {
882 write!(f, ", .. ({} fields)", extra_count)?;
883 }
884 write!(f, " }}")
885 }
886}
887impl<'r> PongReader<'r> {
888 pub const FIELD_COUNT: usize = 1;
889 pub fn total_size(&self) -> usize {
890 molecule::unpack_number(self.as_slice()) as usize
891 }
892 pub fn field_count(&self) -> usize {
893 if self.total_size() == molecule::NUMBER_SIZE {
894 0
895 } else {
896 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
897 }
898 }
899 pub fn count_extra_fields(&self) -> usize {
900 self.field_count() - Self::FIELD_COUNT
901 }
902 pub fn has_extra_fields(&self) -> bool {
903 Self::FIELD_COUNT != self.field_count()
904 }
905 pub fn nonce(&self) -> Uint32Reader<'r> {
906 let slice = self.as_slice();
907 let start = molecule::unpack_number(&slice[4..]) as usize;
908 if self.has_extra_fields() {
909 let end = molecule::unpack_number(&slice[8..]) as usize;
910 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
911 } else {
912 Uint32Reader::new_unchecked(&self.as_slice()[start..])
913 }
914 }
915}
916impl<'r> molecule::prelude::Reader<'r> for PongReader<'r> {
917 type Entity = Pong;
918 const NAME: &'static str = "PongReader";
919 fn to_entity(&self) -> Self::Entity {
920 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
921 }
922 fn new_unchecked(slice: &'r [u8]) -> Self {
923 PongReader(slice)
924 }
925 fn as_slice(&self) -> &'r [u8] {
926 self.0
927 }
928 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
929 use molecule::verification_error as ve;
930 let slice_len = slice.len();
931 if slice_len < molecule::NUMBER_SIZE {
932 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
933 }
934 let total_size = molecule::unpack_number(slice) as usize;
935 if slice_len != total_size {
936 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
937 }
938 if slice_len < molecule::NUMBER_SIZE * 2 {
939 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
940 }
941 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
942 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
943 return ve!(Self, OffsetsNotMatch);
944 }
945 if slice_len < offset_first {
946 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
947 }
948 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
949 if field_count < Self::FIELD_COUNT {
950 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
951 } else if !compatible && field_count > Self::FIELD_COUNT {
952 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
953 };
954 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
955 .chunks_exact(molecule::NUMBER_SIZE)
956 .map(|x| molecule::unpack_number(x) as usize)
957 .collect();
958 offsets.push(total_size);
959 if offsets.windows(2).any(|i| i[0] > i[1]) {
960 return ve!(Self, OffsetsNotMatch);
961 }
962 Uint32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
963 Ok(())
964 }
965}
966#[derive(Debug, Default)]
967pub struct PongBuilder {
968 pub(crate) nonce: Uint32,
969}
970impl PongBuilder {
971 pub const FIELD_COUNT: usize = 1;
972 pub fn nonce(mut self, v: Uint32) -> Self {
973 self.nonce = v;
974 self
975 }
976}
977impl molecule::prelude::Builder for PongBuilder {
978 type Entity = Pong;
979 const NAME: &'static str = "PongBuilder";
980 fn expected_length(&self) -> usize {
981 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.nonce.as_slice().len()
982 }
983 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
984 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
985 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
986 offsets.push(total_size);
987 total_size += self.nonce.as_slice().len();
988 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
989 for offset in offsets.into_iter() {
990 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
991 }
992 writer.write_all(self.nonce.as_slice())?;
993 Ok(())
994 }
995 fn build(&self) -> Self::Entity {
996 let mut inner = Vec::with_capacity(self.expected_length());
997 self.write(&mut inner)
998 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
999 Pong::new_unchecked(inner.into())
1000 }
1001}
1002#[derive(Clone)]
1003pub struct NodeVec(molecule::bytes::Bytes);
1004impl ::core::fmt::LowerHex for NodeVec {
1005 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1006 use molecule::hex_string;
1007 if f.alternate() {
1008 write!(f, "0x")?;
1009 }
1010 write!(f, "{}", hex_string(self.as_slice()))
1011 }
1012}
1013impl ::core::fmt::Debug for NodeVec {
1014 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1015 write!(f, "{}({:#x})", Self::NAME, self)
1016 }
1017}
1018impl ::core::fmt::Display for NodeVec {
1019 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1020 write!(f, "{} [", Self::NAME)?;
1021 for i in 0..self.len() {
1022 if i == 0 {
1023 write!(f, "{}", self.get_unchecked(i))?;
1024 } else {
1025 write!(f, ", {}", self.get_unchecked(i))?;
1026 }
1027 }
1028 write!(f, "]")
1029 }
1030}
1031impl ::core::default::Default for NodeVec {
1032 fn default() -> Self {
1033 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
1034 NodeVec::new_unchecked(v)
1035 }
1036}
1037impl NodeVec {
1038 const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
1039 pub fn total_size(&self) -> usize {
1040 molecule::unpack_number(self.as_slice()) as usize
1041 }
1042 pub fn item_count(&self) -> usize {
1043 if self.total_size() == molecule::NUMBER_SIZE {
1044 0
1045 } else {
1046 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
1047 }
1048 }
1049 pub fn len(&self) -> usize {
1050 self.item_count()
1051 }
1052 pub fn is_empty(&self) -> bool {
1053 self.len() == 0
1054 }
1055 pub fn get(&self, idx: usize) -> Option<Node> {
1056 if idx >= self.len() {
1057 None
1058 } else {
1059 Some(self.get_unchecked(idx))
1060 }
1061 }
1062 pub fn get_unchecked(&self, idx: usize) -> Node {
1063 let slice = self.as_slice();
1064 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
1065 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
1066 if idx == self.len() - 1 {
1067 Node::new_unchecked(self.0.slice(start..))
1068 } else {
1069 let end_idx = start_idx + molecule::NUMBER_SIZE;
1070 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
1071 Node::new_unchecked(self.0.slice(start..end))
1072 }
1073 }
1074 pub fn as_reader<'r>(&'r self) -> NodeVecReader<'r> {
1075 NodeVecReader::new_unchecked(self.as_slice())
1076 }
1077}
1078impl molecule::prelude::Entity for NodeVec {
1079 type Builder = NodeVecBuilder;
1080 const NAME: &'static str = "NodeVec";
1081 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
1082 NodeVec(data)
1083 }
1084 fn as_bytes(&self) -> molecule::bytes::Bytes {
1085 self.0.clone()
1086 }
1087 fn as_slice(&self) -> &[u8] {
1088 &self.0[..]
1089 }
1090 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1091 NodeVecReader::from_slice(slice).map(|reader| reader.to_entity())
1092 }
1093 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1094 NodeVecReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
1095 }
1096 fn new_builder() -> Self::Builder {
1097 ::core::default::Default::default()
1098 }
1099 fn as_builder(self) -> Self::Builder {
1100 Self::new_builder().extend(self.into_iter())
1101 }
1102}
1103#[derive(Clone, Copy)]
1104pub struct NodeVecReader<'r>(&'r [u8]);
1105impl<'r> ::core::fmt::LowerHex for NodeVecReader<'r> {
1106 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1107 use molecule::hex_string;
1108 if f.alternate() {
1109 write!(f, "0x")?;
1110 }
1111 write!(f, "{}", hex_string(self.as_slice()))
1112 }
1113}
1114impl<'r> ::core::fmt::Debug for NodeVecReader<'r> {
1115 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1116 write!(f, "{}({:#x})", Self::NAME, self)
1117 }
1118}
1119impl<'r> ::core::fmt::Display for NodeVecReader<'r> {
1120 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1121 write!(f, "{} [", Self::NAME)?;
1122 for i in 0..self.len() {
1123 if i == 0 {
1124 write!(f, "{}", self.get_unchecked(i))?;
1125 } else {
1126 write!(f, ", {}", self.get_unchecked(i))?;
1127 }
1128 }
1129 write!(f, "]")
1130 }
1131}
1132impl<'r> NodeVecReader<'r> {
1133 pub fn total_size(&self) -> usize {
1134 molecule::unpack_number(self.as_slice()) as usize
1135 }
1136 pub fn item_count(&self) -> usize {
1137 if self.total_size() == molecule::NUMBER_SIZE {
1138 0
1139 } else {
1140 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
1141 }
1142 }
1143 pub fn len(&self) -> usize {
1144 self.item_count()
1145 }
1146 pub fn is_empty(&self) -> bool {
1147 self.len() == 0
1148 }
1149 pub fn get(&self, idx: usize) -> Option<NodeReader<'r>> {
1150 if idx >= self.len() {
1151 None
1152 } else {
1153 Some(self.get_unchecked(idx))
1154 }
1155 }
1156 pub fn get_unchecked(&self, idx: usize) -> NodeReader<'r> {
1157 let slice = self.as_slice();
1158 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
1159 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
1160 if idx == self.len() - 1 {
1161 NodeReader::new_unchecked(&self.as_slice()[start..])
1162 } else {
1163 let end_idx = start_idx + molecule::NUMBER_SIZE;
1164 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
1165 NodeReader::new_unchecked(&self.as_slice()[start..end])
1166 }
1167 }
1168}
1169impl<'r> molecule::prelude::Reader<'r> for NodeVecReader<'r> {
1170 type Entity = NodeVec;
1171 const NAME: &'static str = "NodeVecReader";
1172 fn to_entity(&self) -> Self::Entity {
1173 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
1174 }
1175 fn new_unchecked(slice: &'r [u8]) -> Self {
1176 NodeVecReader(slice)
1177 }
1178 fn as_slice(&self) -> &'r [u8] {
1179 self.0
1180 }
1181 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
1182 use molecule::verification_error as ve;
1183 let slice_len = slice.len();
1184 if slice_len < molecule::NUMBER_SIZE {
1185 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
1186 }
1187 let total_size = molecule::unpack_number(slice) as usize;
1188 if slice_len != total_size {
1189 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
1190 }
1191 if slice_len == molecule::NUMBER_SIZE {
1192 return Ok(());
1193 }
1194 if slice_len < molecule::NUMBER_SIZE * 2 {
1195 return ve!(
1196 Self,
1197 TotalSizeNotMatch,
1198 molecule::NUMBER_SIZE * 2,
1199 slice_len
1200 );
1201 }
1202 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
1203 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
1204 return ve!(Self, OffsetsNotMatch);
1205 }
1206 if slice_len < offset_first {
1207 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
1208 }
1209 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
1210 .chunks_exact(molecule::NUMBER_SIZE)
1211 .map(|x| molecule::unpack_number(x) as usize)
1212 .collect();
1213 offsets.push(total_size);
1214 if offsets.windows(2).any(|i| i[0] > i[1]) {
1215 return ve!(Self, OffsetsNotMatch);
1216 }
1217 for pair in offsets.windows(2) {
1218 let start = pair[0];
1219 let end = pair[1];
1220 NodeReader::verify(&slice[start..end], compatible)?;
1221 }
1222 Ok(())
1223 }
1224}
1225#[derive(Debug, Default)]
1226pub struct NodeVecBuilder(pub(crate) Vec<Node>);
1227impl NodeVecBuilder {
1228 pub fn set(mut self, v: Vec<Node>) -> Self {
1229 self.0 = v;
1230 self
1231 }
1232 pub fn push(mut self, v: Node) -> Self {
1233 self.0.push(v);
1234 self
1235 }
1236 pub fn extend<T: ::core::iter::IntoIterator<Item = Node>>(mut self, iter: T) -> Self {
1237 for elem in iter {
1238 self.0.push(elem);
1239 }
1240 self
1241 }
1242 pub fn replace(&mut self, index: usize, v: Node) -> Option<Node> {
1243 self.0
1244 .get_mut(index)
1245 .map(|item| ::core::mem::replace(item, v))
1246 }
1247}
1248impl molecule::prelude::Builder for NodeVecBuilder {
1249 type Entity = NodeVec;
1250 const NAME: &'static str = "NodeVecBuilder";
1251 fn expected_length(&self) -> usize {
1252 molecule::NUMBER_SIZE * (self.0.len() + 1)
1253 + self
1254 .0
1255 .iter()
1256 .map(|inner| inner.as_slice().len())
1257 .sum::<usize>()
1258 }
1259 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
1260 let item_count = self.0.len();
1261 if item_count == 0 {
1262 writer.write_all(&molecule::pack_number(
1263 molecule::NUMBER_SIZE as molecule::Number,
1264 ))?;
1265 } else {
1266 let (total_size, offsets) = self.0.iter().fold(
1267 (
1268 molecule::NUMBER_SIZE * (item_count + 1),
1269 Vec::with_capacity(item_count),
1270 ),
1271 |(start, mut offsets), inner| {
1272 offsets.push(start);
1273 (start + inner.as_slice().len(), offsets)
1274 },
1275 );
1276 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
1277 for offset in offsets.into_iter() {
1278 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
1279 }
1280 for inner in self.0.iter() {
1281 writer.write_all(inner.as_slice())?;
1282 }
1283 }
1284 Ok(())
1285 }
1286 fn build(&self) -> Self::Entity {
1287 let mut inner = Vec::with_capacity(self.expected_length());
1288 self.write(&mut inner)
1289 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
1290 NodeVec::new_unchecked(inner.into())
1291 }
1292}
1293pub struct NodeVecIterator(NodeVec, usize, usize);
1294impl ::core::iter::Iterator for NodeVecIterator {
1295 type Item = Node;
1296 fn next(&mut self) -> Option<Self::Item> {
1297 if self.1 >= self.2 {
1298 None
1299 } else {
1300 let ret = self.0.get_unchecked(self.1);
1301 self.1 += 1;
1302 Some(ret)
1303 }
1304 }
1305}
1306impl ::core::iter::ExactSizeIterator for NodeVecIterator {
1307 fn len(&self) -> usize {
1308 self.2 - self.1
1309 }
1310}
1311impl ::core::iter::IntoIterator for NodeVec {
1312 type Item = Node;
1313 type IntoIter = NodeVecIterator;
1314 fn into_iter(self) -> Self::IntoIter {
1315 let len = self.len();
1316 NodeVecIterator(self, 0, len)
1317 }
1318}
1319impl<'r> NodeVecReader<'r> {
1320 pub fn iter<'t>(&'t self) -> NodeVecReaderIterator<'t, 'r> {
1321 NodeVecReaderIterator(&self, 0, self.len())
1322 }
1323}
1324pub struct NodeVecReaderIterator<'t, 'r>(&'t NodeVecReader<'r>, usize, usize);
1325impl<'t: 'r, 'r> ::core::iter::Iterator for NodeVecReaderIterator<'t, 'r> {
1326 type Item = NodeReader<'t>;
1327 fn next(&mut self) -> Option<Self::Item> {
1328 if self.1 >= self.2 {
1329 None
1330 } else {
1331 let ret = self.0.get_unchecked(self.1);
1332 self.1 += 1;
1333 Some(ret)
1334 }
1335 }
1336}
1337impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for NodeVecReaderIterator<'t, 'r> {
1338 fn len(&self) -> usize {
1339 self.2 - self.1
1340 }
1341}
1342#[derive(Clone)]
1343pub struct Node2Vec(molecule::bytes::Bytes);
1344impl ::core::fmt::LowerHex for Node2Vec {
1345 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1346 use molecule::hex_string;
1347 if f.alternate() {
1348 write!(f, "0x")?;
1349 }
1350 write!(f, "{}", hex_string(self.as_slice()))
1351 }
1352}
1353impl ::core::fmt::Debug for Node2Vec {
1354 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1355 write!(f, "{}({:#x})", Self::NAME, self)
1356 }
1357}
1358impl ::core::fmt::Display for Node2Vec {
1359 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1360 write!(f, "{} [", Self::NAME)?;
1361 for i in 0..self.len() {
1362 if i == 0 {
1363 write!(f, "{}", self.get_unchecked(i))?;
1364 } else {
1365 write!(f, ", {}", self.get_unchecked(i))?;
1366 }
1367 }
1368 write!(f, "]")
1369 }
1370}
1371impl ::core::default::Default for Node2Vec {
1372 fn default() -> Self {
1373 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
1374 Node2Vec::new_unchecked(v)
1375 }
1376}
1377impl Node2Vec {
1378 const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
1379 pub fn total_size(&self) -> usize {
1380 molecule::unpack_number(self.as_slice()) as usize
1381 }
1382 pub fn item_count(&self) -> usize {
1383 if self.total_size() == molecule::NUMBER_SIZE {
1384 0
1385 } else {
1386 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
1387 }
1388 }
1389 pub fn len(&self) -> usize {
1390 self.item_count()
1391 }
1392 pub fn is_empty(&self) -> bool {
1393 self.len() == 0
1394 }
1395 pub fn get(&self, idx: usize) -> Option<Node2> {
1396 if idx >= self.len() {
1397 None
1398 } else {
1399 Some(self.get_unchecked(idx))
1400 }
1401 }
1402 pub fn get_unchecked(&self, idx: usize) -> Node2 {
1403 let slice = self.as_slice();
1404 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
1405 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
1406 if idx == self.len() - 1 {
1407 Node2::new_unchecked(self.0.slice(start..))
1408 } else {
1409 let end_idx = start_idx + molecule::NUMBER_SIZE;
1410 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
1411 Node2::new_unchecked(self.0.slice(start..end))
1412 }
1413 }
1414 pub fn as_reader<'r>(&'r self) -> Node2VecReader<'r> {
1415 Node2VecReader::new_unchecked(self.as_slice())
1416 }
1417}
1418impl molecule::prelude::Entity for Node2Vec {
1419 type Builder = Node2VecBuilder;
1420 const NAME: &'static str = "Node2Vec";
1421 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
1422 Node2Vec(data)
1423 }
1424 fn as_bytes(&self) -> molecule::bytes::Bytes {
1425 self.0.clone()
1426 }
1427 fn as_slice(&self) -> &[u8] {
1428 &self.0[..]
1429 }
1430 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1431 Node2VecReader::from_slice(slice).map(|reader| reader.to_entity())
1432 }
1433 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1434 Node2VecReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
1435 }
1436 fn new_builder() -> Self::Builder {
1437 ::core::default::Default::default()
1438 }
1439 fn as_builder(self) -> Self::Builder {
1440 Self::new_builder().extend(self.into_iter())
1441 }
1442}
1443#[derive(Clone, Copy)]
1444pub struct Node2VecReader<'r>(&'r [u8]);
1445impl<'r> ::core::fmt::LowerHex for Node2VecReader<'r> {
1446 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1447 use molecule::hex_string;
1448 if f.alternate() {
1449 write!(f, "0x")?;
1450 }
1451 write!(f, "{}", hex_string(self.as_slice()))
1452 }
1453}
1454impl<'r> ::core::fmt::Debug for Node2VecReader<'r> {
1455 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1456 write!(f, "{}({:#x})", Self::NAME, self)
1457 }
1458}
1459impl<'r> ::core::fmt::Display for Node2VecReader<'r> {
1460 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1461 write!(f, "{} [", Self::NAME)?;
1462 for i in 0..self.len() {
1463 if i == 0 {
1464 write!(f, "{}", self.get_unchecked(i))?;
1465 } else {
1466 write!(f, ", {}", self.get_unchecked(i))?;
1467 }
1468 }
1469 write!(f, "]")
1470 }
1471}
1472impl<'r> Node2VecReader<'r> {
1473 pub fn total_size(&self) -> usize {
1474 molecule::unpack_number(self.as_slice()) as usize
1475 }
1476 pub fn item_count(&self) -> usize {
1477 if self.total_size() == molecule::NUMBER_SIZE {
1478 0
1479 } else {
1480 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
1481 }
1482 }
1483 pub fn len(&self) -> usize {
1484 self.item_count()
1485 }
1486 pub fn is_empty(&self) -> bool {
1487 self.len() == 0
1488 }
1489 pub fn get(&self, idx: usize) -> Option<Node2Reader<'r>> {
1490 if idx >= self.len() {
1491 None
1492 } else {
1493 Some(self.get_unchecked(idx))
1494 }
1495 }
1496 pub fn get_unchecked(&self, idx: usize) -> Node2Reader<'r> {
1497 let slice = self.as_slice();
1498 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
1499 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
1500 if idx == self.len() - 1 {
1501 Node2Reader::new_unchecked(&self.as_slice()[start..])
1502 } else {
1503 let end_idx = start_idx + molecule::NUMBER_SIZE;
1504 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
1505 Node2Reader::new_unchecked(&self.as_slice()[start..end])
1506 }
1507 }
1508}
1509impl<'r> molecule::prelude::Reader<'r> for Node2VecReader<'r> {
1510 type Entity = Node2Vec;
1511 const NAME: &'static str = "Node2VecReader";
1512 fn to_entity(&self) -> Self::Entity {
1513 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
1514 }
1515 fn new_unchecked(slice: &'r [u8]) -> Self {
1516 Node2VecReader(slice)
1517 }
1518 fn as_slice(&self) -> &'r [u8] {
1519 self.0
1520 }
1521 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
1522 use molecule::verification_error as ve;
1523 let slice_len = slice.len();
1524 if slice_len < molecule::NUMBER_SIZE {
1525 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
1526 }
1527 let total_size = molecule::unpack_number(slice) as usize;
1528 if slice_len != total_size {
1529 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
1530 }
1531 if slice_len == molecule::NUMBER_SIZE {
1532 return Ok(());
1533 }
1534 if slice_len < molecule::NUMBER_SIZE * 2 {
1535 return ve!(
1536 Self,
1537 TotalSizeNotMatch,
1538 molecule::NUMBER_SIZE * 2,
1539 slice_len
1540 );
1541 }
1542 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
1543 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
1544 return ve!(Self, OffsetsNotMatch);
1545 }
1546 if slice_len < offset_first {
1547 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
1548 }
1549 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
1550 .chunks_exact(molecule::NUMBER_SIZE)
1551 .map(|x| molecule::unpack_number(x) as usize)
1552 .collect();
1553 offsets.push(total_size);
1554 if offsets.windows(2).any(|i| i[0] > i[1]) {
1555 return ve!(Self, OffsetsNotMatch);
1556 }
1557 for pair in offsets.windows(2) {
1558 let start = pair[0];
1559 let end = pair[1];
1560 Node2Reader::verify(&slice[start..end], compatible)?;
1561 }
1562 Ok(())
1563 }
1564}
1565#[derive(Debug, Default)]
1566pub struct Node2VecBuilder(pub(crate) Vec<Node2>);
1567impl Node2VecBuilder {
1568 pub fn set(mut self, v: Vec<Node2>) -> Self {
1569 self.0 = v;
1570 self
1571 }
1572 pub fn push(mut self, v: Node2) -> Self {
1573 self.0.push(v);
1574 self
1575 }
1576 pub fn extend<T: ::core::iter::IntoIterator<Item = Node2>>(mut self, iter: T) -> Self {
1577 for elem in iter {
1578 self.0.push(elem);
1579 }
1580 self
1581 }
1582 pub fn replace(&mut self, index: usize, v: Node2) -> Option<Node2> {
1583 self.0
1584 .get_mut(index)
1585 .map(|item| ::core::mem::replace(item, v))
1586 }
1587}
1588impl molecule::prelude::Builder for Node2VecBuilder {
1589 type Entity = Node2Vec;
1590 const NAME: &'static str = "Node2VecBuilder";
1591 fn expected_length(&self) -> usize {
1592 molecule::NUMBER_SIZE * (self.0.len() + 1)
1593 + self
1594 .0
1595 .iter()
1596 .map(|inner| inner.as_slice().len())
1597 .sum::<usize>()
1598 }
1599 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
1600 let item_count = self.0.len();
1601 if item_count == 0 {
1602 writer.write_all(&molecule::pack_number(
1603 molecule::NUMBER_SIZE as molecule::Number,
1604 ))?;
1605 } else {
1606 let (total_size, offsets) = self.0.iter().fold(
1607 (
1608 molecule::NUMBER_SIZE * (item_count + 1),
1609 Vec::with_capacity(item_count),
1610 ),
1611 |(start, mut offsets), inner| {
1612 offsets.push(start);
1613 (start + inner.as_slice().len(), offsets)
1614 },
1615 );
1616 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
1617 for offset in offsets.into_iter() {
1618 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
1619 }
1620 for inner in self.0.iter() {
1621 writer.write_all(inner.as_slice())?;
1622 }
1623 }
1624 Ok(())
1625 }
1626 fn build(&self) -> Self::Entity {
1627 let mut inner = Vec::with_capacity(self.expected_length());
1628 self.write(&mut inner)
1629 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
1630 Node2Vec::new_unchecked(inner.into())
1631 }
1632}
1633pub struct Node2VecIterator(Node2Vec, usize, usize);
1634impl ::core::iter::Iterator for Node2VecIterator {
1635 type Item = Node2;
1636 fn next(&mut self) -> Option<Self::Item> {
1637 if self.1 >= self.2 {
1638 None
1639 } else {
1640 let ret = self.0.get_unchecked(self.1);
1641 self.1 += 1;
1642 Some(ret)
1643 }
1644 }
1645}
1646impl ::core::iter::ExactSizeIterator for Node2VecIterator {
1647 fn len(&self) -> usize {
1648 self.2 - self.1
1649 }
1650}
1651impl ::core::iter::IntoIterator for Node2Vec {
1652 type Item = Node2;
1653 type IntoIter = Node2VecIterator;
1654 fn into_iter(self) -> Self::IntoIter {
1655 let len = self.len();
1656 Node2VecIterator(self, 0, len)
1657 }
1658}
1659impl<'r> Node2VecReader<'r> {
1660 pub fn iter<'t>(&'t self) -> Node2VecReaderIterator<'t, 'r> {
1661 Node2VecReaderIterator(&self, 0, self.len())
1662 }
1663}
1664pub struct Node2VecReaderIterator<'t, 'r>(&'t Node2VecReader<'r>, usize, usize);
1665impl<'t: 'r, 'r> ::core::iter::Iterator for Node2VecReaderIterator<'t, 'r> {
1666 type Item = Node2Reader<'t>;
1667 fn next(&mut self) -> Option<Self::Item> {
1668 if self.1 >= self.2 {
1669 None
1670 } else {
1671 let ret = self.0.get_unchecked(self.1);
1672 self.1 += 1;
1673 Some(ret)
1674 }
1675 }
1676}
1677impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Node2VecReaderIterator<'t, 'r> {
1678 fn len(&self) -> usize {
1679 self.2 - self.1
1680 }
1681}
1682#[derive(Clone)]
1683pub struct Uint16(molecule::bytes::Bytes);
1684impl ::core::fmt::LowerHex for Uint16 {
1685 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1686 use molecule::hex_string;
1687 if f.alternate() {
1688 write!(f, "0x")?;
1689 }
1690 write!(f, "{}", hex_string(self.as_slice()))
1691 }
1692}
1693impl ::core::fmt::Debug for Uint16 {
1694 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1695 write!(f, "{}({:#x})", Self::NAME, self)
1696 }
1697}
1698impl ::core::fmt::Display for Uint16 {
1699 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1700 use molecule::hex_string;
1701 let raw_data = hex_string(&self.raw_data());
1702 write!(f, "{}(0x{})", Self::NAME, raw_data)
1703 }
1704}
1705impl ::core::default::Default for Uint16 {
1706 fn default() -> Self {
1707 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
1708 Uint16::new_unchecked(v)
1709 }
1710}
1711impl Uint16 {
1712 const DEFAULT_VALUE: [u8; 2] = [0, 0];
1713 pub const TOTAL_SIZE: usize = 2;
1714 pub const ITEM_SIZE: usize = 1;
1715 pub const ITEM_COUNT: usize = 2;
1716 pub fn nth0(&self) -> Byte {
1717 Byte::new_unchecked(self.0.slice(0..1))
1718 }
1719 pub fn nth1(&self) -> Byte {
1720 Byte::new_unchecked(self.0.slice(1..2))
1721 }
1722 pub fn raw_data(&self) -> molecule::bytes::Bytes {
1723 self.as_bytes()
1724 }
1725 pub fn as_reader<'r>(&'r self) -> Uint16Reader<'r> {
1726 Uint16Reader::new_unchecked(self.as_slice())
1727 }
1728}
1729impl molecule::prelude::Entity for Uint16 {
1730 type Builder = Uint16Builder;
1731 const NAME: &'static str = "Uint16";
1732 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
1733 Uint16(data)
1734 }
1735 fn as_bytes(&self) -> molecule::bytes::Bytes {
1736 self.0.clone()
1737 }
1738 fn as_slice(&self) -> &[u8] {
1739 &self.0[..]
1740 }
1741 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1742 Uint16Reader::from_slice(slice).map(|reader| reader.to_entity())
1743 }
1744 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1745 Uint16Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
1746 }
1747 fn new_builder() -> Self::Builder {
1748 ::core::default::Default::default()
1749 }
1750 fn as_builder(self) -> Self::Builder {
1751 Self::new_builder().set([self.nth0(), self.nth1()])
1752 }
1753}
1754#[derive(Clone, Copy)]
1755pub struct Uint16Reader<'r>(&'r [u8]);
1756impl<'r> ::core::fmt::LowerHex for Uint16Reader<'r> {
1757 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1758 use molecule::hex_string;
1759 if f.alternate() {
1760 write!(f, "0x")?;
1761 }
1762 write!(f, "{}", hex_string(self.as_slice()))
1763 }
1764}
1765impl<'r> ::core::fmt::Debug for Uint16Reader<'r> {
1766 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1767 write!(f, "{}({:#x})", Self::NAME, self)
1768 }
1769}
1770impl<'r> ::core::fmt::Display for Uint16Reader<'r> {
1771 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1772 use molecule::hex_string;
1773 let raw_data = hex_string(&self.raw_data());
1774 write!(f, "{}(0x{})", Self::NAME, raw_data)
1775 }
1776}
1777impl<'r> Uint16Reader<'r> {
1778 pub const TOTAL_SIZE: usize = 2;
1779 pub const ITEM_SIZE: usize = 1;
1780 pub const ITEM_COUNT: usize = 2;
1781 pub fn nth0(&self) -> ByteReader<'r> {
1782 ByteReader::new_unchecked(&self.as_slice()[0..1])
1783 }
1784 pub fn nth1(&self) -> ByteReader<'r> {
1785 ByteReader::new_unchecked(&self.as_slice()[1..2])
1786 }
1787 pub fn raw_data(&self) -> &'r [u8] {
1788 self.as_slice()
1789 }
1790}
1791impl<'r> molecule::prelude::Reader<'r> for Uint16Reader<'r> {
1792 type Entity = Uint16;
1793 const NAME: &'static str = "Uint16Reader";
1794 fn to_entity(&self) -> Self::Entity {
1795 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
1796 }
1797 fn new_unchecked(slice: &'r [u8]) -> Self {
1798 Uint16Reader(slice)
1799 }
1800 fn as_slice(&self) -> &'r [u8] {
1801 self.0
1802 }
1803 fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
1804 use molecule::verification_error as ve;
1805 let slice_len = slice.len();
1806 if slice_len != Self::TOTAL_SIZE {
1807 return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
1808 }
1809 Ok(())
1810 }
1811}
1812pub struct Uint16Builder(pub(crate) [Byte; 2]);
1813impl ::core::fmt::Debug for Uint16Builder {
1814 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1815 write!(f, "{}({:?})", Self::NAME, &self.0[..])
1816 }
1817}
1818impl ::core::default::Default for Uint16Builder {
1819 fn default() -> Self {
1820 Uint16Builder([Byte::default(), Byte::default()])
1821 }
1822}
1823impl Uint16Builder {
1824 pub const TOTAL_SIZE: usize = 2;
1825 pub const ITEM_SIZE: usize = 1;
1826 pub const ITEM_COUNT: usize = 2;
1827 pub fn set(mut self, v: [Byte; 2]) -> Self {
1828 self.0 = v;
1829 self
1830 }
1831 pub fn nth0(mut self, v: Byte) -> Self {
1832 self.0[0] = v;
1833 self
1834 }
1835 pub fn nth1(mut self, v: Byte) -> Self {
1836 self.0[1] = v;
1837 self
1838 }
1839}
1840impl molecule::prelude::Builder for Uint16Builder {
1841 type Entity = Uint16;
1842 const NAME: &'static str = "Uint16Builder";
1843 fn expected_length(&self) -> usize {
1844 Self::TOTAL_SIZE
1845 }
1846 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
1847 writer.write_all(self.0[0].as_slice())?;
1848 writer.write_all(self.0[1].as_slice())?;
1849 Ok(())
1850 }
1851 fn build(&self) -> Self::Entity {
1852 let mut inner = Vec::with_capacity(self.expected_length());
1853 self.write(&mut inner)
1854 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
1855 Uint16::new_unchecked(inner.into())
1856 }
1857}
1858#[derive(Clone)]
1859pub struct PortOpt(molecule::bytes::Bytes);
1860impl ::core::fmt::LowerHex for PortOpt {
1861 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1862 use molecule::hex_string;
1863 if f.alternate() {
1864 write!(f, "0x")?;
1865 }
1866 write!(f, "{}", hex_string(self.as_slice()))
1867 }
1868}
1869impl ::core::fmt::Debug for PortOpt {
1870 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1871 write!(f, "{}({:#x})", Self::NAME, self)
1872 }
1873}
1874impl ::core::fmt::Display for PortOpt {
1875 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1876 if let Some(v) = self.to_opt() {
1877 write!(f, "{}(Some({}))", Self::NAME, v)
1878 } else {
1879 write!(f, "{}(None)", Self::NAME)
1880 }
1881 }
1882}
1883impl ::core::default::Default for PortOpt {
1884 fn default() -> Self {
1885 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
1886 PortOpt::new_unchecked(v)
1887 }
1888}
1889impl PortOpt {
1890 const DEFAULT_VALUE: [u8; 0] = [];
1891 pub fn is_none(&self) -> bool {
1892 self.0.is_empty()
1893 }
1894 pub fn is_some(&self) -> bool {
1895 !self.0.is_empty()
1896 }
1897 pub fn to_opt(&self) -> Option<Uint16> {
1898 if self.is_none() {
1899 None
1900 } else {
1901 Some(Uint16::new_unchecked(self.0.clone()))
1902 }
1903 }
1904 pub fn as_reader<'r>(&'r self) -> PortOptReader<'r> {
1905 PortOptReader::new_unchecked(self.as_slice())
1906 }
1907}
1908impl molecule::prelude::Entity for PortOpt {
1909 type Builder = PortOptBuilder;
1910 const NAME: &'static str = "PortOpt";
1911 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
1912 PortOpt(data)
1913 }
1914 fn as_bytes(&self) -> molecule::bytes::Bytes {
1915 self.0.clone()
1916 }
1917 fn as_slice(&self) -> &[u8] {
1918 &self.0[..]
1919 }
1920 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1921 PortOptReader::from_slice(slice).map(|reader| reader.to_entity())
1922 }
1923 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
1924 PortOptReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
1925 }
1926 fn new_builder() -> Self::Builder {
1927 ::core::default::Default::default()
1928 }
1929 fn as_builder(self) -> Self::Builder {
1930 Self::new_builder().set(self.to_opt())
1931 }
1932}
1933#[derive(Clone, Copy)]
1934pub struct PortOptReader<'r>(&'r [u8]);
1935impl<'r> ::core::fmt::LowerHex for PortOptReader<'r> {
1936 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1937 use molecule::hex_string;
1938 if f.alternate() {
1939 write!(f, "0x")?;
1940 }
1941 write!(f, "{}", hex_string(self.as_slice()))
1942 }
1943}
1944impl<'r> ::core::fmt::Debug for PortOptReader<'r> {
1945 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1946 write!(f, "{}({:#x})", Self::NAME, self)
1947 }
1948}
1949impl<'r> ::core::fmt::Display for PortOptReader<'r> {
1950 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
1951 if let Some(v) = self.to_opt() {
1952 write!(f, "{}(Some({}))", Self::NAME, v)
1953 } else {
1954 write!(f, "{}(None)", Self::NAME)
1955 }
1956 }
1957}
1958impl<'r> PortOptReader<'r> {
1959 pub fn is_none(&self) -> bool {
1960 self.0.is_empty()
1961 }
1962 pub fn is_some(&self) -> bool {
1963 !self.0.is_empty()
1964 }
1965 pub fn to_opt(&self) -> Option<Uint16Reader<'r>> {
1966 if self.is_none() {
1967 None
1968 } else {
1969 Some(Uint16Reader::new_unchecked(self.as_slice()))
1970 }
1971 }
1972}
1973impl<'r> molecule::prelude::Reader<'r> for PortOptReader<'r> {
1974 type Entity = PortOpt;
1975 const NAME: &'static str = "PortOptReader";
1976 fn to_entity(&self) -> Self::Entity {
1977 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
1978 }
1979 fn new_unchecked(slice: &'r [u8]) -> Self {
1980 PortOptReader(slice)
1981 }
1982 fn as_slice(&self) -> &'r [u8] {
1983 self.0
1984 }
1985 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
1986 if !slice.is_empty() {
1987 Uint16Reader::verify(&slice[..], compatible)?;
1988 }
1989 Ok(())
1990 }
1991}
1992#[derive(Debug, Default)]
1993pub struct PortOptBuilder(pub(crate) Option<Uint16>);
1994impl PortOptBuilder {
1995 pub fn set(mut self, v: Option<Uint16>) -> Self {
1996 self.0 = v;
1997 self
1998 }
1999}
2000impl molecule::prelude::Builder for PortOptBuilder {
2001 type Entity = PortOpt;
2002 const NAME: &'static str = "PortOptBuilder";
2003 fn expected_length(&self) -> usize {
2004 self.0
2005 .as_ref()
2006 .map(|ref inner| inner.as_slice().len())
2007 .unwrap_or(0)
2008 }
2009 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
2010 self.0
2011 .as_ref()
2012 .map(|ref inner| writer.write_all(inner.as_slice()))
2013 .unwrap_or(Ok(()))
2014 }
2015 fn build(&self) -> Self::Entity {
2016 let mut inner = Vec::with_capacity(self.expected_length());
2017 self.write(&mut inner)
2018 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
2019 PortOpt::new_unchecked(inner.into())
2020 }
2021}
2022#[derive(Clone)]
2023pub struct DiscoveryPayload(molecule::bytes::Bytes);
2024impl ::core::fmt::LowerHex for DiscoveryPayload {
2025 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2026 use molecule::hex_string;
2027 if f.alternate() {
2028 write!(f, "0x")?;
2029 }
2030 write!(f, "{}", hex_string(self.as_slice()))
2031 }
2032}
2033impl ::core::fmt::Debug for DiscoveryPayload {
2034 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2035 write!(f, "{}({:#x})", Self::NAME, self)
2036 }
2037}
2038impl ::core::fmt::Display for DiscoveryPayload {
2039 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2040 write!(f, "{}(", Self::NAME)?;
2041 self.to_enum().display_inner(f)?;
2042 write!(f, ")")
2043 }
2044}
2045impl ::core::default::Default for DiscoveryPayload {
2046 fn default() -> Self {
2047 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
2048 DiscoveryPayload::new_unchecked(v)
2049 }
2050}
2051impl DiscoveryPayload {
2052 const DEFAULT_VALUE: [u8; 28] = [
2053 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2054 ];
2055 pub const ITEMS_COUNT: usize = 2;
2056 pub fn item_id(&self) -> molecule::Number {
2057 molecule::unpack_number(self.as_slice())
2058 }
2059 pub fn to_enum(&self) -> DiscoveryPayloadUnion {
2060 let inner = self.0.slice(molecule::NUMBER_SIZE..);
2061 match self.item_id() {
2062 0 => GetNodes::new_unchecked(inner).into(),
2063 1 => Nodes::new_unchecked(inner).into(),
2064 _ => panic!("{}: invalid data", Self::NAME),
2065 }
2066 }
2067 pub fn as_reader<'r>(&'r self) -> DiscoveryPayloadReader<'r> {
2068 DiscoveryPayloadReader::new_unchecked(self.as_slice())
2069 }
2070}
2071impl molecule::prelude::Entity for DiscoveryPayload {
2072 type Builder = DiscoveryPayloadBuilder;
2073 const NAME: &'static str = "DiscoveryPayload";
2074 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
2075 DiscoveryPayload(data)
2076 }
2077 fn as_bytes(&self) -> molecule::bytes::Bytes {
2078 self.0.clone()
2079 }
2080 fn as_slice(&self) -> &[u8] {
2081 &self.0[..]
2082 }
2083 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2084 DiscoveryPayloadReader::from_slice(slice).map(|reader| reader.to_entity())
2085 }
2086 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2087 DiscoveryPayloadReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
2088 }
2089 fn new_builder() -> Self::Builder {
2090 ::core::default::Default::default()
2091 }
2092 fn as_builder(self) -> Self::Builder {
2093 Self::new_builder().set(self.to_enum())
2094 }
2095}
2096#[derive(Clone, Copy)]
2097pub struct DiscoveryPayloadReader<'r>(&'r [u8]);
2098impl<'r> ::core::fmt::LowerHex for DiscoveryPayloadReader<'r> {
2099 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2100 use molecule::hex_string;
2101 if f.alternate() {
2102 write!(f, "0x")?;
2103 }
2104 write!(f, "{}", hex_string(self.as_slice()))
2105 }
2106}
2107impl<'r> ::core::fmt::Debug for DiscoveryPayloadReader<'r> {
2108 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2109 write!(f, "{}({:#x})", Self::NAME, self)
2110 }
2111}
2112impl<'r> ::core::fmt::Display for DiscoveryPayloadReader<'r> {
2113 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2114 write!(f, "{}(", Self::NAME)?;
2115 self.to_enum().display_inner(f)?;
2116 write!(f, ")")
2117 }
2118}
2119impl<'r> DiscoveryPayloadReader<'r> {
2120 pub const ITEMS_COUNT: usize = 2;
2121 pub fn item_id(&self) -> molecule::Number {
2122 molecule::unpack_number(self.as_slice())
2123 }
2124 pub fn to_enum(&self) -> DiscoveryPayloadUnionReader<'r> {
2125 let inner = &self.as_slice()[molecule::NUMBER_SIZE..];
2126 match self.item_id() {
2127 0 => GetNodesReader::new_unchecked(inner).into(),
2128 1 => NodesReader::new_unchecked(inner).into(),
2129 _ => panic!("{}: invalid data", Self::NAME),
2130 }
2131 }
2132}
2133impl<'r> molecule::prelude::Reader<'r> for DiscoveryPayloadReader<'r> {
2134 type Entity = DiscoveryPayload;
2135 const NAME: &'static str = "DiscoveryPayloadReader";
2136 fn to_entity(&self) -> Self::Entity {
2137 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
2138 }
2139 fn new_unchecked(slice: &'r [u8]) -> Self {
2140 DiscoveryPayloadReader(slice)
2141 }
2142 fn as_slice(&self) -> &'r [u8] {
2143 self.0
2144 }
2145 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
2146 use molecule::verification_error as ve;
2147 let slice_len = slice.len();
2148 if slice_len < molecule::NUMBER_SIZE {
2149 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
2150 }
2151 let item_id = molecule::unpack_number(slice);
2152 let inner_slice = &slice[molecule::NUMBER_SIZE..];
2153 match item_id {
2154 0 => GetNodesReader::verify(inner_slice, compatible),
2155 1 => NodesReader::verify(inner_slice, compatible),
2156 _ => ve!(Self, UnknownItem, Self::ITEMS_COUNT, item_id),
2157 }?;
2158 Ok(())
2159 }
2160}
2161#[derive(Debug, Default)]
2162pub struct DiscoveryPayloadBuilder(pub(crate) DiscoveryPayloadUnion);
2163impl DiscoveryPayloadBuilder {
2164 pub const ITEMS_COUNT: usize = 2;
2165 pub fn set<I>(mut self, v: I) -> Self
2166 where
2167 I: ::core::convert::Into<DiscoveryPayloadUnion>,
2168 {
2169 self.0 = v.into();
2170 self
2171 }
2172}
2173impl molecule::prelude::Builder for DiscoveryPayloadBuilder {
2174 type Entity = DiscoveryPayload;
2175 const NAME: &'static str = "DiscoveryPayloadBuilder";
2176 fn expected_length(&self) -> usize {
2177 molecule::NUMBER_SIZE + self.0.as_slice().len()
2178 }
2179 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
2180 writer.write_all(&molecule::pack_number(self.0.item_id()))?;
2181 writer.write_all(self.0.as_slice())
2182 }
2183 fn build(&self) -> Self::Entity {
2184 let mut inner = Vec::with_capacity(self.expected_length());
2185 self.write(&mut inner)
2186 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
2187 DiscoveryPayload::new_unchecked(inner.into())
2188 }
2189}
2190#[derive(Debug, Clone)]
2191pub enum DiscoveryPayloadUnion {
2192 GetNodes(GetNodes),
2193 Nodes(Nodes),
2194}
2195#[derive(Debug, Clone, Copy)]
2196pub enum DiscoveryPayloadUnionReader<'r> {
2197 GetNodes(GetNodesReader<'r>),
2198 Nodes(NodesReader<'r>),
2199}
2200impl ::core::default::Default for DiscoveryPayloadUnion {
2201 fn default() -> Self {
2202 DiscoveryPayloadUnion::GetNodes(::core::default::Default::default())
2203 }
2204}
2205impl ::core::fmt::Display for DiscoveryPayloadUnion {
2206 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2207 match self {
2208 DiscoveryPayloadUnion::GetNodes(ref item) => {
2209 write!(f, "{}::{}({})", Self::NAME, GetNodes::NAME, item)
2210 }
2211 DiscoveryPayloadUnion::Nodes(ref item) => {
2212 write!(f, "{}::{}({})", Self::NAME, Nodes::NAME, item)
2213 }
2214 }
2215 }
2216}
2217impl<'r> ::core::fmt::Display for DiscoveryPayloadUnionReader<'r> {
2218 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2219 match self {
2220 DiscoveryPayloadUnionReader::GetNodes(ref item) => {
2221 write!(f, "{}::{}({})", Self::NAME, GetNodes::NAME, item)
2222 }
2223 DiscoveryPayloadUnionReader::Nodes(ref item) => {
2224 write!(f, "{}::{}({})", Self::NAME, Nodes::NAME, item)
2225 }
2226 }
2227 }
2228}
2229impl DiscoveryPayloadUnion {
2230 pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2231 match self {
2232 DiscoveryPayloadUnion::GetNodes(ref item) => write!(f, "{}", item),
2233 DiscoveryPayloadUnion::Nodes(ref item) => write!(f, "{}", item),
2234 }
2235 }
2236}
2237impl<'r> DiscoveryPayloadUnionReader<'r> {
2238 pub(crate) fn display_inner(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2239 match self {
2240 DiscoveryPayloadUnionReader::GetNodes(ref item) => write!(f, "{}", item),
2241 DiscoveryPayloadUnionReader::Nodes(ref item) => write!(f, "{}", item),
2242 }
2243 }
2244}
2245impl ::core::convert::From<GetNodes> for DiscoveryPayloadUnion {
2246 fn from(item: GetNodes) -> Self {
2247 DiscoveryPayloadUnion::GetNodes(item)
2248 }
2249}
2250impl ::core::convert::From<Nodes> for DiscoveryPayloadUnion {
2251 fn from(item: Nodes) -> Self {
2252 DiscoveryPayloadUnion::Nodes(item)
2253 }
2254}
2255impl<'r> ::core::convert::From<GetNodesReader<'r>> for DiscoveryPayloadUnionReader<'r> {
2256 fn from(item: GetNodesReader<'r>) -> Self {
2257 DiscoveryPayloadUnionReader::GetNodes(item)
2258 }
2259}
2260impl<'r> ::core::convert::From<NodesReader<'r>> for DiscoveryPayloadUnionReader<'r> {
2261 fn from(item: NodesReader<'r>) -> Self {
2262 DiscoveryPayloadUnionReader::Nodes(item)
2263 }
2264}
2265impl DiscoveryPayloadUnion {
2266 pub const NAME: &'static str = "DiscoveryPayloadUnion";
2267 pub fn as_bytes(&self) -> molecule::bytes::Bytes {
2268 match self {
2269 DiscoveryPayloadUnion::GetNodes(item) => item.as_bytes(),
2270 DiscoveryPayloadUnion::Nodes(item) => item.as_bytes(),
2271 }
2272 }
2273 pub fn as_slice(&self) -> &[u8] {
2274 match self {
2275 DiscoveryPayloadUnion::GetNodes(item) => item.as_slice(),
2276 DiscoveryPayloadUnion::Nodes(item) => item.as_slice(),
2277 }
2278 }
2279 pub fn item_id(&self) -> molecule::Number {
2280 match self {
2281 DiscoveryPayloadUnion::GetNodes(_) => 0,
2282 DiscoveryPayloadUnion::Nodes(_) => 1,
2283 }
2284 }
2285 pub fn item_name(&self) -> &str {
2286 match self {
2287 DiscoveryPayloadUnion::GetNodes(_) => "GetNodes",
2288 DiscoveryPayloadUnion::Nodes(_) => "Nodes",
2289 }
2290 }
2291 pub fn as_reader<'r>(&'r self) -> DiscoveryPayloadUnionReader<'r> {
2292 match self {
2293 DiscoveryPayloadUnion::GetNodes(item) => item.as_reader().into(),
2294 DiscoveryPayloadUnion::Nodes(item) => item.as_reader().into(),
2295 }
2296 }
2297}
2298impl<'r> DiscoveryPayloadUnionReader<'r> {
2299 pub const NAME: &'r str = "DiscoveryPayloadUnionReader";
2300 pub fn as_slice(&self) -> &'r [u8] {
2301 match self {
2302 DiscoveryPayloadUnionReader::GetNodes(item) => item.as_slice(),
2303 DiscoveryPayloadUnionReader::Nodes(item) => item.as_slice(),
2304 }
2305 }
2306 pub fn item_id(&self) -> molecule::Number {
2307 match self {
2308 DiscoveryPayloadUnionReader::GetNodes(_) => 0,
2309 DiscoveryPayloadUnionReader::Nodes(_) => 1,
2310 }
2311 }
2312 pub fn item_name(&self) -> &str {
2313 match self {
2314 DiscoveryPayloadUnionReader::GetNodes(_) => "GetNodes",
2315 DiscoveryPayloadUnionReader::Nodes(_) => "Nodes",
2316 }
2317 }
2318}
2319#[derive(Clone)]
2320pub struct DiscoveryMessage(molecule::bytes::Bytes);
2321impl ::core::fmt::LowerHex for DiscoveryMessage {
2322 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2323 use molecule::hex_string;
2324 if f.alternate() {
2325 write!(f, "0x")?;
2326 }
2327 write!(f, "{}", hex_string(self.as_slice()))
2328 }
2329}
2330impl ::core::fmt::Debug for DiscoveryMessage {
2331 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2332 write!(f, "{}({:#x})", Self::NAME, self)
2333 }
2334}
2335impl ::core::fmt::Display for DiscoveryMessage {
2336 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2337 write!(f, "{} {{ ", Self::NAME)?;
2338 write!(f, "{}: {}", "payload", self.payload())?;
2339 let extra_count = self.count_extra_fields();
2340 if extra_count != 0 {
2341 write!(f, ", .. ({} fields)", extra_count)?;
2342 }
2343 write!(f, " }}")
2344 }
2345}
2346impl ::core::default::Default for DiscoveryMessage {
2347 fn default() -> Self {
2348 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
2349 DiscoveryMessage::new_unchecked(v)
2350 }
2351}
2352impl DiscoveryMessage {
2353 const DEFAULT_VALUE: [u8; 36] = [
2354 36, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 0,
2355 0, 0, 0, 0, 0, 0, 0,
2356 ];
2357 pub const FIELD_COUNT: usize = 1;
2358 pub fn total_size(&self) -> usize {
2359 molecule::unpack_number(self.as_slice()) as usize
2360 }
2361 pub fn field_count(&self) -> usize {
2362 if self.total_size() == molecule::NUMBER_SIZE {
2363 0
2364 } else {
2365 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
2366 }
2367 }
2368 pub fn count_extra_fields(&self) -> usize {
2369 self.field_count() - Self::FIELD_COUNT
2370 }
2371 pub fn has_extra_fields(&self) -> bool {
2372 Self::FIELD_COUNT != self.field_count()
2373 }
2374 pub fn payload(&self) -> DiscoveryPayload {
2375 let slice = self.as_slice();
2376 let start = molecule::unpack_number(&slice[4..]) as usize;
2377 if self.has_extra_fields() {
2378 let end = molecule::unpack_number(&slice[8..]) as usize;
2379 DiscoveryPayload::new_unchecked(self.0.slice(start..end))
2380 } else {
2381 DiscoveryPayload::new_unchecked(self.0.slice(start..))
2382 }
2383 }
2384 pub fn as_reader<'r>(&'r self) -> DiscoveryMessageReader<'r> {
2385 DiscoveryMessageReader::new_unchecked(self.as_slice())
2386 }
2387}
2388impl molecule::prelude::Entity for DiscoveryMessage {
2389 type Builder = DiscoveryMessageBuilder;
2390 const NAME: &'static str = "DiscoveryMessage";
2391 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
2392 DiscoveryMessage(data)
2393 }
2394 fn as_bytes(&self) -> molecule::bytes::Bytes {
2395 self.0.clone()
2396 }
2397 fn as_slice(&self) -> &[u8] {
2398 &self.0[..]
2399 }
2400 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2401 DiscoveryMessageReader::from_slice(slice).map(|reader| reader.to_entity())
2402 }
2403 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2404 DiscoveryMessageReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
2405 }
2406 fn new_builder() -> Self::Builder {
2407 ::core::default::Default::default()
2408 }
2409 fn as_builder(self) -> Self::Builder {
2410 Self::new_builder().payload(self.payload())
2411 }
2412}
2413#[derive(Clone, Copy)]
2414pub struct DiscoveryMessageReader<'r>(&'r [u8]);
2415impl<'r> ::core::fmt::LowerHex for DiscoveryMessageReader<'r> {
2416 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2417 use molecule::hex_string;
2418 if f.alternate() {
2419 write!(f, "0x")?;
2420 }
2421 write!(f, "{}", hex_string(self.as_slice()))
2422 }
2423}
2424impl<'r> ::core::fmt::Debug for DiscoveryMessageReader<'r> {
2425 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2426 write!(f, "{}({:#x})", Self::NAME, self)
2427 }
2428}
2429impl<'r> ::core::fmt::Display for DiscoveryMessageReader<'r> {
2430 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2431 write!(f, "{} {{ ", Self::NAME)?;
2432 write!(f, "{}: {}", "payload", self.payload())?;
2433 let extra_count = self.count_extra_fields();
2434 if extra_count != 0 {
2435 write!(f, ", .. ({} fields)", extra_count)?;
2436 }
2437 write!(f, " }}")
2438 }
2439}
2440impl<'r> DiscoveryMessageReader<'r> {
2441 pub const FIELD_COUNT: usize = 1;
2442 pub fn total_size(&self) -> usize {
2443 molecule::unpack_number(self.as_slice()) as usize
2444 }
2445 pub fn field_count(&self) -> usize {
2446 if self.total_size() == molecule::NUMBER_SIZE {
2447 0
2448 } else {
2449 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
2450 }
2451 }
2452 pub fn count_extra_fields(&self) -> usize {
2453 self.field_count() - Self::FIELD_COUNT
2454 }
2455 pub fn has_extra_fields(&self) -> bool {
2456 Self::FIELD_COUNT != self.field_count()
2457 }
2458 pub fn payload(&self) -> DiscoveryPayloadReader<'r> {
2459 let slice = self.as_slice();
2460 let start = molecule::unpack_number(&slice[4..]) as usize;
2461 if self.has_extra_fields() {
2462 let end = molecule::unpack_number(&slice[8..]) as usize;
2463 DiscoveryPayloadReader::new_unchecked(&self.as_slice()[start..end])
2464 } else {
2465 DiscoveryPayloadReader::new_unchecked(&self.as_slice()[start..])
2466 }
2467 }
2468}
2469impl<'r> molecule::prelude::Reader<'r> for DiscoveryMessageReader<'r> {
2470 type Entity = DiscoveryMessage;
2471 const NAME: &'static str = "DiscoveryMessageReader";
2472 fn to_entity(&self) -> Self::Entity {
2473 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
2474 }
2475 fn new_unchecked(slice: &'r [u8]) -> Self {
2476 DiscoveryMessageReader(slice)
2477 }
2478 fn as_slice(&self) -> &'r [u8] {
2479 self.0
2480 }
2481 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
2482 use molecule::verification_error as ve;
2483 let slice_len = slice.len();
2484 if slice_len < molecule::NUMBER_SIZE {
2485 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
2486 }
2487 let total_size = molecule::unpack_number(slice) as usize;
2488 if slice_len != total_size {
2489 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
2490 }
2491 if slice_len < molecule::NUMBER_SIZE * 2 {
2492 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
2493 }
2494 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
2495 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
2496 return ve!(Self, OffsetsNotMatch);
2497 }
2498 if slice_len < offset_first {
2499 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
2500 }
2501 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
2502 if field_count < Self::FIELD_COUNT {
2503 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
2504 } else if !compatible && field_count > Self::FIELD_COUNT {
2505 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
2506 };
2507 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
2508 .chunks_exact(molecule::NUMBER_SIZE)
2509 .map(|x| molecule::unpack_number(x) as usize)
2510 .collect();
2511 offsets.push(total_size);
2512 if offsets.windows(2).any(|i| i[0] > i[1]) {
2513 return ve!(Self, OffsetsNotMatch);
2514 }
2515 DiscoveryPayloadReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
2516 Ok(())
2517 }
2518}
2519#[derive(Debug, Default)]
2520pub struct DiscoveryMessageBuilder {
2521 pub(crate) payload: DiscoveryPayload,
2522}
2523impl DiscoveryMessageBuilder {
2524 pub const FIELD_COUNT: usize = 1;
2525 pub fn payload(mut self, v: DiscoveryPayload) -> Self {
2526 self.payload = v;
2527 self
2528 }
2529}
2530impl molecule::prelude::Builder for DiscoveryMessageBuilder {
2531 type Entity = DiscoveryMessage;
2532 const NAME: &'static str = "DiscoveryMessageBuilder";
2533 fn expected_length(&self) -> usize {
2534 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.payload.as_slice().len()
2535 }
2536 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
2537 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
2538 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
2539 offsets.push(total_size);
2540 total_size += self.payload.as_slice().len();
2541 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
2542 for offset in offsets.into_iter() {
2543 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
2544 }
2545 writer.write_all(self.payload.as_slice())?;
2546 Ok(())
2547 }
2548 fn build(&self) -> Self::Entity {
2549 let mut inner = Vec::with_capacity(self.expected_length());
2550 self.write(&mut inner)
2551 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
2552 DiscoveryMessage::new_unchecked(inner.into())
2553 }
2554}
2555#[derive(Clone)]
2556pub struct GetNodes(molecule::bytes::Bytes);
2557impl ::core::fmt::LowerHex for GetNodes {
2558 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2559 use molecule::hex_string;
2560 if f.alternate() {
2561 write!(f, "0x")?;
2562 }
2563 write!(f, "{}", hex_string(self.as_slice()))
2564 }
2565}
2566impl ::core::fmt::Debug for GetNodes {
2567 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2568 write!(f, "{}({:#x})", Self::NAME, self)
2569 }
2570}
2571impl ::core::fmt::Display for GetNodes {
2572 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2573 write!(f, "{} {{ ", Self::NAME)?;
2574 write!(f, "{}: {}", "version", self.version())?;
2575 write!(f, ", {}: {}", "count", self.count())?;
2576 write!(f, ", {}: {}", "listen_port", self.listen_port())?;
2577 let extra_count = self.count_extra_fields();
2578 if extra_count != 0 {
2579 write!(f, ", .. ({} fields)", extra_count)?;
2580 }
2581 write!(f, " }}")
2582 }
2583}
2584impl ::core::default::Default for GetNodes {
2585 fn default() -> Self {
2586 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
2587 GetNodes::new_unchecked(v)
2588 }
2589}
2590impl GetNodes {
2591 const DEFAULT_VALUE: [u8; 24] = [
2592 24, 0, 0, 0, 16, 0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2593 ];
2594 pub const FIELD_COUNT: usize = 3;
2595 pub fn total_size(&self) -> usize {
2596 molecule::unpack_number(self.as_slice()) as usize
2597 }
2598 pub fn field_count(&self) -> usize {
2599 if self.total_size() == molecule::NUMBER_SIZE {
2600 0
2601 } else {
2602 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
2603 }
2604 }
2605 pub fn count_extra_fields(&self) -> usize {
2606 self.field_count() - Self::FIELD_COUNT
2607 }
2608 pub fn has_extra_fields(&self) -> bool {
2609 Self::FIELD_COUNT != self.field_count()
2610 }
2611 pub fn version(&self) -> Uint32 {
2612 let slice = self.as_slice();
2613 let start = molecule::unpack_number(&slice[4..]) as usize;
2614 let end = molecule::unpack_number(&slice[8..]) as usize;
2615 Uint32::new_unchecked(self.0.slice(start..end))
2616 }
2617 pub fn count(&self) -> Uint32 {
2618 let slice = self.as_slice();
2619 let start = molecule::unpack_number(&slice[8..]) as usize;
2620 let end = molecule::unpack_number(&slice[12..]) as usize;
2621 Uint32::new_unchecked(self.0.slice(start..end))
2622 }
2623 pub fn listen_port(&self) -> PortOpt {
2624 let slice = self.as_slice();
2625 let start = molecule::unpack_number(&slice[12..]) as usize;
2626 if self.has_extra_fields() {
2627 let end = molecule::unpack_number(&slice[16..]) as usize;
2628 PortOpt::new_unchecked(self.0.slice(start..end))
2629 } else {
2630 PortOpt::new_unchecked(self.0.slice(start..))
2631 }
2632 }
2633 pub fn as_reader<'r>(&'r self) -> GetNodesReader<'r> {
2634 GetNodesReader::new_unchecked(self.as_slice())
2635 }
2636}
2637impl molecule::prelude::Entity for GetNodes {
2638 type Builder = GetNodesBuilder;
2639 const NAME: &'static str = "GetNodes";
2640 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
2641 GetNodes(data)
2642 }
2643 fn as_bytes(&self) -> molecule::bytes::Bytes {
2644 self.0.clone()
2645 }
2646 fn as_slice(&self) -> &[u8] {
2647 &self.0[..]
2648 }
2649 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2650 GetNodesReader::from_slice(slice).map(|reader| reader.to_entity())
2651 }
2652 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2653 GetNodesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
2654 }
2655 fn new_builder() -> Self::Builder {
2656 ::core::default::Default::default()
2657 }
2658 fn as_builder(self) -> Self::Builder {
2659 Self::new_builder()
2660 .version(self.version())
2661 .count(self.count())
2662 .listen_port(self.listen_port())
2663 }
2664}
2665#[derive(Clone, Copy)]
2666pub struct GetNodesReader<'r>(&'r [u8]);
2667impl<'r> ::core::fmt::LowerHex for GetNodesReader<'r> {
2668 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2669 use molecule::hex_string;
2670 if f.alternate() {
2671 write!(f, "0x")?;
2672 }
2673 write!(f, "{}", hex_string(self.as_slice()))
2674 }
2675}
2676impl<'r> ::core::fmt::Debug for GetNodesReader<'r> {
2677 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2678 write!(f, "{}({:#x})", Self::NAME, self)
2679 }
2680}
2681impl<'r> ::core::fmt::Display for GetNodesReader<'r> {
2682 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2683 write!(f, "{} {{ ", Self::NAME)?;
2684 write!(f, "{}: {}", "version", self.version())?;
2685 write!(f, ", {}: {}", "count", self.count())?;
2686 write!(f, ", {}: {}", "listen_port", self.listen_port())?;
2687 let extra_count = self.count_extra_fields();
2688 if extra_count != 0 {
2689 write!(f, ", .. ({} fields)", extra_count)?;
2690 }
2691 write!(f, " }}")
2692 }
2693}
2694impl<'r> GetNodesReader<'r> {
2695 pub const FIELD_COUNT: usize = 3;
2696 pub fn total_size(&self) -> usize {
2697 molecule::unpack_number(self.as_slice()) as usize
2698 }
2699 pub fn field_count(&self) -> usize {
2700 if self.total_size() == molecule::NUMBER_SIZE {
2701 0
2702 } else {
2703 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
2704 }
2705 }
2706 pub fn count_extra_fields(&self) -> usize {
2707 self.field_count() - Self::FIELD_COUNT
2708 }
2709 pub fn has_extra_fields(&self) -> bool {
2710 Self::FIELD_COUNT != self.field_count()
2711 }
2712 pub fn version(&self) -> Uint32Reader<'r> {
2713 let slice = self.as_slice();
2714 let start = molecule::unpack_number(&slice[4..]) as usize;
2715 let end = molecule::unpack_number(&slice[8..]) as usize;
2716 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
2717 }
2718 pub fn count(&self) -> Uint32Reader<'r> {
2719 let slice = self.as_slice();
2720 let start = molecule::unpack_number(&slice[8..]) as usize;
2721 let end = molecule::unpack_number(&slice[12..]) as usize;
2722 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
2723 }
2724 pub fn listen_port(&self) -> PortOptReader<'r> {
2725 let slice = self.as_slice();
2726 let start = molecule::unpack_number(&slice[12..]) as usize;
2727 if self.has_extra_fields() {
2728 let end = molecule::unpack_number(&slice[16..]) as usize;
2729 PortOptReader::new_unchecked(&self.as_slice()[start..end])
2730 } else {
2731 PortOptReader::new_unchecked(&self.as_slice()[start..])
2732 }
2733 }
2734}
2735impl<'r> molecule::prelude::Reader<'r> for GetNodesReader<'r> {
2736 type Entity = GetNodes;
2737 const NAME: &'static str = "GetNodesReader";
2738 fn to_entity(&self) -> Self::Entity {
2739 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
2740 }
2741 fn new_unchecked(slice: &'r [u8]) -> Self {
2742 GetNodesReader(slice)
2743 }
2744 fn as_slice(&self) -> &'r [u8] {
2745 self.0
2746 }
2747 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
2748 use molecule::verification_error as ve;
2749 let slice_len = slice.len();
2750 if slice_len < molecule::NUMBER_SIZE {
2751 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
2752 }
2753 let total_size = molecule::unpack_number(slice) as usize;
2754 if slice_len != total_size {
2755 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
2756 }
2757 if slice_len < molecule::NUMBER_SIZE * 2 {
2758 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
2759 }
2760 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
2761 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
2762 return ve!(Self, OffsetsNotMatch);
2763 }
2764 if slice_len < offset_first {
2765 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
2766 }
2767 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
2768 if field_count < Self::FIELD_COUNT {
2769 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
2770 } else if !compatible && field_count > Self::FIELD_COUNT {
2771 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
2772 };
2773 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
2774 .chunks_exact(molecule::NUMBER_SIZE)
2775 .map(|x| molecule::unpack_number(x) as usize)
2776 .collect();
2777 offsets.push(total_size);
2778 if offsets.windows(2).any(|i| i[0] > i[1]) {
2779 return ve!(Self, OffsetsNotMatch);
2780 }
2781 Uint32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
2782 Uint32Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
2783 PortOptReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
2784 Ok(())
2785 }
2786}
2787#[derive(Debug, Default)]
2788pub struct GetNodesBuilder {
2789 pub(crate) version: Uint32,
2790 pub(crate) count: Uint32,
2791 pub(crate) listen_port: PortOpt,
2792}
2793impl GetNodesBuilder {
2794 pub const FIELD_COUNT: usize = 3;
2795 pub fn version(mut self, v: Uint32) -> Self {
2796 self.version = v;
2797 self
2798 }
2799 pub fn count(mut self, v: Uint32) -> Self {
2800 self.count = v;
2801 self
2802 }
2803 pub fn listen_port(mut self, v: PortOpt) -> Self {
2804 self.listen_port = v;
2805 self
2806 }
2807}
2808impl molecule::prelude::Builder for GetNodesBuilder {
2809 type Entity = GetNodes;
2810 const NAME: &'static str = "GetNodesBuilder";
2811 fn expected_length(&self) -> usize {
2812 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
2813 + self.version.as_slice().len()
2814 + self.count.as_slice().len()
2815 + self.listen_port.as_slice().len()
2816 }
2817 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
2818 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
2819 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
2820 offsets.push(total_size);
2821 total_size += self.version.as_slice().len();
2822 offsets.push(total_size);
2823 total_size += self.count.as_slice().len();
2824 offsets.push(total_size);
2825 total_size += self.listen_port.as_slice().len();
2826 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
2827 for offset in offsets.into_iter() {
2828 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
2829 }
2830 writer.write_all(self.version.as_slice())?;
2831 writer.write_all(self.count.as_slice())?;
2832 writer.write_all(self.listen_port.as_slice())?;
2833 Ok(())
2834 }
2835 fn build(&self) -> Self::Entity {
2836 let mut inner = Vec::with_capacity(self.expected_length());
2837 self.write(&mut inner)
2838 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
2839 GetNodes::new_unchecked(inner.into())
2840 }
2841}
2842#[derive(Clone)]
2843pub struct GetNodes2(molecule::bytes::Bytes);
2844impl ::core::fmt::LowerHex for GetNodes2 {
2845 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2846 use molecule::hex_string;
2847 if f.alternate() {
2848 write!(f, "0x")?;
2849 }
2850 write!(f, "{}", hex_string(self.as_slice()))
2851 }
2852}
2853impl ::core::fmt::Debug for GetNodes2 {
2854 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2855 write!(f, "{}({:#x})", Self::NAME, self)
2856 }
2857}
2858impl ::core::fmt::Display for GetNodes2 {
2859 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2860 write!(f, "{} {{ ", Self::NAME)?;
2861 write!(f, "{}: {}", "version", self.version())?;
2862 write!(f, ", {}: {}", "count", self.count())?;
2863 write!(f, ", {}: {}", "listen_port", self.listen_port())?;
2864 write!(f, ", {}: {}", "required_flags", self.required_flags())?;
2865 let extra_count = self.count_extra_fields();
2866 if extra_count != 0 {
2867 write!(f, ", .. ({} fields)", extra_count)?;
2868 }
2869 write!(f, " }}")
2870 }
2871}
2872impl ::core::default::Default for GetNodes2 {
2873 fn default() -> Self {
2874 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
2875 GetNodes2::new_unchecked(v)
2876 }
2877}
2878impl GetNodes2 {
2879 const DEFAULT_VALUE: [u8; 36] = [
2880 36, 0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 28, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2881 0, 0, 0, 0, 0, 0, 0,
2882 ];
2883 pub const FIELD_COUNT: usize = 4;
2884 pub fn total_size(&self) -> usize {
2885 molecule::unpack_number(self.as_slice()) as usize
2886 }
2887 pub fn field_count(&self) -> usize {
2888 if self.total_size() == molecule::NUMBER_SIZE {
2889 0
2890 } else {
2891 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
2892 }
2893 }
2894 pub fn count_extra_fields(&self) -> usize {
2895 self.field_count() - Self::FIELD_COUNT
2896 }
2897 pub fn has_extra_fields(&self) -> bool {
2898 Self::FIELD_COUNT != self.field_count()
2899 }
2900 pub fn version(&self) -> Uint32 {
2901 let slice = self.as_slice();
2902 let start = molecule::unpack_number(&slice[4..]) as usize;
2903 let end = molecule::unpack_number(&slice[8..]) as usize;
2904 Uint32::new_unchecked(self.0.slice(start..end))
2905 }
2906 pub fn count(&self) -> Uint32 {
2907 let slice = self.as_slice();
2908 let start = molecule::unpack_number(&slice[8..]) as usize;
2909 let end = molecule::unpack_number(&slice[12..]) as usize;
2910 Uint32::new_unchecked(self.0.slice(start..end))
2911 }
2912 pub fn listen_port(&self) -> PortOpt {
2913 let slice = self.as_slice();
2914 let start = molecule::unpack_number(&slice[12..]) as usize;
2915 let end = molecule::unpack_number(&slice[16..]) as usize;
2916 PortOpt::new_unchecked(self.0.slice(start..end))
2917 }
2918 pub fn required_flags(&self) -> Uint64 {
2919 let slice = self.as_slice();
2920 let start = molecule::unpack_number(&slice[16..]) as usize;
2921 if self.has_extra_fields() {
2922 let end = molecule::unpack_number(&slice[20..]) as usize;
2923 Uint64::new_unchecked(self.0.slice(start..end))
2924 } else {
2925 Uint64::new_unchecked(self.0.slice(start..))
2926 }
2927 }
2928 pub fn as_reader<'r>(&'r self) -> GetNodes2Reader<'r> {
2929 GetNodes2Reader::new_unchecked(self.as_slice())
2930 }
2931}
2932impl molecule::prelude::Entity for GetNodes2 {
2933 type Builder = GetNodes2Builder;
2934 const NAME: &'static str = "GetNodes2";
2935 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
2936 GetNodes2(data)
2937 }
2938 fn as_bytes(&self) -> molecule::bytes::Bytes {
2939 self.0.clone()
2940 }
2941 fn as_slice(&self) -> &[u8] {
2942 &self.0[..]
2943 }
2944 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2945 GetNodes2Reader::from_slice(slice).map(|reader| reader.to_entity())
2946 }
2947 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
2948 GetNodes2Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
2949 }
2950 fn new_builder() -> Self::Builder {
2951 ::core::default::Default::default()
2952 }
2953 fn as_builder(self) -> Self::Builder {
2954 Self::new_builder()
2955 .version(self.version())
2956 .count(self.count())
2957 .listen_port(self.listen_port())
2958 .required_flags(self.required_flags())
2959 }
2960}
2961#[derive(Clone, Copy)]
2962pub struct GetNodes2Reader<'r>(&'r [u8]);
2963impl<'r> ::core::fmt::LowerHex for GetNodes2Reader<'r> {
2964 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2965 use molecule::hex_string;
2966 if f.alternate() {
2967 write!(f, "0x")?;
2968 }
2969 write!(f, "{}", hex_string(self.as_slice()))
2970 }
2971}
2972impl<'r> ::core::fmt::Debug for GetNodes2Reader<'r> {
2973 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2974 write!(f, "{}({:#x})", Self::NAME, self)
2975 }
2976}
2977impl<'r> ::core::fmt::Display for GetNodes2Reader<'r> {
2978 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
2979 write!(f, "{} {{ ", Self::NAME)?;
2980 write!(f, "{}: {}", "version", self.version())?;
2981 write!(f, ", {}: {}", "count", self.count())?;
2982 write!(f, ", {}: {}", "listen_port", self.listen_port())?;
2983 write!(f, ", {}: {}", "required_flags", self.required_flags())?;
2984 let extra_count = self.count_extra_fields();
2985 if extra_count != 0 {
2986 write!(f, ", .. ({} fields)", extra_count)?;
2987 }
2988 write!(f, " }}")
2989 }
2990}
2991impl<'r> GetNodes2Reader<'r> {
2992 pub const FIELD_COUNT: usize = 4;
2993 pub fn total_size(&self) -> usize {
2994 molecule::unpack_number(self.as_slice()) as usize
2995 }
2996 pub fn field_count(&self) -> usize {
2997 if self.total_size() == molecule::NUMBER_SIZE {
2998 0
2999 } else {
3000 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3001 }
3002 }
3003 pub fn count_extra_fields(&self) -> usize {
3004 self.field_count() - Self::FIELD_COUNT
3005 }
3006 pub fn has_extra_fields(&self) -> bool {
3007 Self::FIELD_COUNT != self.field_count()
3008 }
3009 pub fn version(&self) -> Uint32Reader<'r> {
3010 let slice = self.as_slice();
3011 let start = molecule::unpack_number(&slice[4..]) as usize;
3012 let end = molecule::unpack_number(&slice[8..]) as usize;
3013 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
3014 }
3015 pub fn count(&self) -> Uint32Reader<'r> {
3016 let slice = self.as_slice();
3017 let start = molecule::unpack_number(&slice[8..]) as usize;
3018 let end = molecule::unpack_number(&slice[12..]) as usize;
3019 Uint32Reader::new_unchecked(&self.as_slice()[start..end])
3020 }
3021 pub fn listen_port(&self) -> PortOptReader<'r> {
3022 let slice = self.as_slice();
3023 let start = molecule::unpack_number(&slice[12..]) as usize;
3024 let end = molecule::unpack_number(&slice[16..]) as usize;
3025 PortOptReader::new_unchecked(&self.as_slice()[start..end])
3026 }
3027 pub fn required_flags(&self) -> Uint64Reader<'r> {
3028 let slice = self.as_slice();
3029 let start = molecule::unpack_number(&slice[16..]) as usize;
3030 if self.has_extra_fields() {
3031 let end = molecule::unpack_number(&slice[20..]) as usize;
3032 Uint64Reader::new_unchecked(&self.as_slice()[start..end])
3033 } else {
3034 Uint64Reader::new_unchecked(&self.as_slice()[start..])
3035 }
3036 }
3037}
3038impl<'r> molecule::prelude::Reader<'r> for GetNodes2Reader<'r> {
3039 type Entity = GetNodes2;
3040 const NAME: &'static str = "GetNodes2Reader";
3041 fn to_entity(&self) -> Self::Entity {
3042 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
3043 }
3044 fn new_unchecked(slice: &'r [u8]) -> Self {
3045 GetNodes2Reader(slice)
3046 }
3047 fn as_slice(&self) -> &'r [u8] {
3048 self.0
3049 }
3050 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
3051 use molecule::verification_error as ve;
3052 let slice_len = slice.len();
3053 if slice_len < molecule::NUMBER_SIZE {
3054 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
3055 }
3056 let total_size = molecule::unpack_number(slice) as usize;
3057 if slice_len != total_size {
3058 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
3059 }
3060 if slice_len < molecule::NUMBER_SIZE * 2 {
3061 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
3062 }
3063 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
3064 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
3065 return ve!(Self, OffsetsNotMatch);
3066 }
3067 if slice_len < offset_first {
3068 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
3069 }
3070 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
3071 if field_count < Self::FIELD_COUNT {
3072 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3073 } else if !compatible && field_count > Self::FIELD_COUNT {
3074 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3075 };
3076 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
3077 .chunks_exact(molecule::NUMBER_SIZE)
3078 .map(|x| molecule::unpack_number(x) as usize)
3079 .collect();
3080 offsets.push(total_size);
3081 if offsets.windows(2).any(|i| i[0] > i[1]) {
3082 return ve!(Self, OffsetsNotMatch);
3083 }
3084 Uint32Reader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
3085 Uint32Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
3086 PortOptReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
3087 Uint64Reader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
3088 Ok(())
3089 }
3090}
3091#[derive(Debug, Default)]
3092pub struct GetNodes2Builder {
3093 pub(crate) version: Uint32,
3094 pub(crate) count: Uint32,
3095 pub(crate) listen_port: PortOpt,
3096 pub(crate) required_flags: Uint64,
3097}
3098impl GetNodes2Builder {
3099 pub const FIELD_COUNT: usize = 4;
3100 pub fn version(mut self, v: Uint32) -> Self {
3101 self.version = v;
3102 self
3103 }
3104 pub fn count(mut self, v: Uint32) -> Self {
3105 self.count = v;
3106 self
3107 }
3108 pub fn listen_port(mut self, v: PortOpt) -> Self {
3109 self.listen_port = v;
3110 self
3111 }
3112 pub fn required_flags(mut self, v: Uint64) -> Self {
3113 self.required_flags = v;
3114 self
3115 }
3116}
3117impl molecule::prelude::Builder for GetNodes2Builder {
3118 type Entity = GetNodes2;
3119 const NAME: &'static str = "GetNodes2Builder";
3120 fn expected_length(&self) -> usize {
3121 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
3122 + self.version.as_slice().len()
3123 + self.count.as_slice().len()
3124 + self.listen_port.as_slice().len()
3125 + self.required_flags.as_slice().len()
3126 }
3127 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
3128 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
3129 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
3130 offsets.push(total_size);
3131 total_size += self.version.as_slice().len();
3132 offsets.push(total_size);
3133 total_size += self.count.as_slice().len();
3134 offsets.push(total_size);
3135 total_size += self.listen_port.as_slice().len();
3136 offsets.push(total_size);
3137 total_size += self.required_flags.as_slice().len();
3138 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
3139 for offset in offsets.into_iter() {
3140 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
3141 }
3142 writer.write_all(self.version.as_slice())?;
3143 writer.write_all(self.count.as_slice())?;
3144 writer.write_all(self.listen_port.as_slice())?;
3145 writer.write_all(self.required_flags.as_slice())?;
3146 Ok(())
3147 }
3148 fn build(&self) -> Self::Entity {
3149 let mut inner = Vec::with_capacity(self.expected_length());
3150 self.write(&mut inner)
3151 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
3152 GetNodes2::new_unchecked(inner.into())
3153 }
3154}
3155#[derive(Clone)]
3156pub struct Nodes(molecule::bytes::Bytes);
3157impl ::core::fmt::LowerHex for Nodes {
3158 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3159 use molecule::hex_string;
3160 if f.alternate() {
3161 write!(f, "0x")?;
3162 }
3163 write!(f, "{}", hex_string(self.as_slice()))
3164 }
3165}
3166impl ::core::fmt::Debug for Nodes {
3167 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3168 write!(f, "{}({:#x})", Self::NAME, self)
3169 }
3170}
3171impl ::core::fmt::Display for Nodes {
3172 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3173 write!(f, "{} {{ ", Self::NAME)?;
3174 write!(f, "{}: {}", "announce", self.announce())?;
3175 write!(f, ", {}: {}", "items", self.items())?;
3176 let extra_count = self.count_extra_fields();
3177 if extra_count != 0 {
3178 write!(f, ", .. ({} fields)", extra_count)?;
3179 }
3180 write!(f, " }}")
3181 }
3182}
3183impl ::core::default::Default for Nodes {
3184 fn default() -> Self {
3185 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
3186 Nodes::new_unchecked(v)
3187 }
3188}
3189impl Nodes {
3190 const DEFAULT_VALUE: [u8; 17] = [17, 0, 0, 0, 12, 0, 0, 0, 13, 0, 0, 0, 0, 4, 0, 0, 0];
3191 pub const FIELD_COUNT: usize = 2;
3192 pub fn total_size(&self) -> usize {
3193 molecule::unpack_number(self.as_slice()) as usize
3194 }
3195 pub fn field_count(&self) -> usize {
3196 if self.total_size() == molecule::NUMBER_SIZE {
3197 0
3198 } else {
3199 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3200 }
3201 }
3202 pub fn count_extra_fields(&self) -> usize {
3203 self.field_count() - Self::FIELD_COUNT
3204 }
3205 pub fn has_extra_fields(&self) -> bool {
3206 Self::FIELD_COUNT != self.field_count()
3207 }
3208 pub fn announce(&self) -> Bool {
3209 let slice = self.as_slice();
3210 let start = molecule::unpack_number(&slice[4..]) as usize;
3211 let end = molecule::unpack_number(&slice[8..]) as usize;
3212 Bool::new_unchecked(self.0.slice(start..end))
3213 }
3214 pub fn items(&self) -> NodeVec {
3215 let slice = self.as_slice();
3216 let start = molecule::unpack_number(&slice[8..]) as usize;
3217 if self.has_extra_fields() {
3218 let end = molecule::unpack_number(&slice[12..]) as usize;
3219 NodeVec::new_unchecked(self.0.slice(start..end))
3220 } else {
3221 NodeVec::new_unchecked(self.0.slice(start..))
3222 }
3223 }
3224 pub fn as_reader<'r>(&'r self) -> NodesReader<'r> {
3225 NodesReader::new_unchecked(self.as_slice())
3226 }
3227}
3228impl molecule::prelude::Entity for Nodes {
3229 type Builder = NodesBuilder;
3230 const NAME: &'static str = "Nodes";
3231 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
3232 Nodes(data)
3233 }
3234 fn as_bytes(&self) -> molecule::bytes::Bytes {
3235 self.0.clone()
3236 }
3237 fn as_slice(&self) -> &[u8] {
3238 &self.0[..]
3239 }
3240 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3241 NodesReader::from_slice(slice).map(|reader| reader.to_entity())
3242 }
3243 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3244 NodesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
3245 }
3246 fn new_builder() -> Self::Builder {
3247 ::core::default::Default::default()
3248 }
3249 fn as_builder(self) -> Self::Builder {
3250 Self::new_builder()
3251 .announce(self.announce())
3252 .items(self.items())
3253 }
3254}
3255#[derive(Clone, Copy)]
3256pub struct NodesReader<'r>(&'r [u8]);
3257impl<'r> ::core::fmt::LowerHex for NodesReader<'r> {
3258 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3259 use molecule::hex_string;
3260 if f.alternate() {
3261 write!(f, "0x")?;
3262 }
3263 write!(f, "{}", hex_string(self.as_slice()))
3264 }
3265}
3266impl<'r> ::core::fmt::Debug for NodesReader<'r> {
3267 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3268 write!(f, "{}({:#x})", Self::NAME, self)
3269 }
3270}
3271impl<'r> ::core::fmt::Display for NodesReader<'r> {
3272 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3273 write!(f, "{} {{ ", Self::NAME)?;
3274 write!(f, "{}: {}", "announce", self.announce())?;
3275 write!(f, ", {}: {}", "items", self.items())?;
3276 let extra_count = self.count_extra_fields();
3277 if extra_count != 0 {
3278 write!(f, ", .. ({} fields)", extra_count)?;
3279 }
3280 write!(f, " }}")
3281 }
3282}
3283impl<'r> NodesReader<'r> {
3284 pub const FIELD_COUNT: usize = 2;
3285 pub fn total_size(&self) -> usize {
3286 molecule::unpack_number(self.as_slice()) as usize
3287 }
3288 pub fn field_count(&self) -> usize {
3289 if self.total_size() == molecule::NUMBER_SIZE {
3290 0
3291 } else {
3292 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3293 }
3294 }
3295 pub fn count_extra_fields(&self) -> usize {
3296 self.field_count() - Self::FIELD_COUNT
3297 }
3298 pub fn has_extra_fields(&self) -> bool {
3299 Self::FIELD_COUNT != self.field_count()
3300 }
3301 pub fn announce(&self) -> BoolReader<'r> {
3302 let slice = self.as_slice();
3303 let start = molecule::unpack_number(&slice[4..]) as usize;
3304 let end = molecule::unpack_number(&slice[8..]) as usize;
3305 BoolReader::new_unchecked(&self.as_slice()[start..end])
3306 }
3307 pub fn items(&self) -> NodeVecReader<'r> {
3308 let slice = self.as_slice();
3309 let start = molecule::unpack_number(&slice[8..]) as usize;
3310 if self.has_extra_fields() {
3311 let end = molecule::unpack_number(&slice[12..]) as usize;
3312 NodeVecReader::new_unchecked(&self.as_slice()[start..end])
3313 } else {
3314 NodeVecReader::new_unchecked(&self.as_slice()[start..])
3315 }
3316 }
3317}
3318impl<'r> molecule::prelude::Reader<'r> for NodesReader<'r> {
3319 type Entity = Nodes;
3320 const NAME: &'static str = "NodesReader";
3321 fn to_entity(&self) -> Self::Entity {
3322 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
3323 }
3324 fn new_unchecked(slice: &'r [u8]) -> Self {
3325 NodesReader(slice)
3326 }
3327 fn as_slice(&self) -> &'r [u8] {
3328 self.0
3329 }
3330 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
3331 use molecule::verification_error as ve;
3332 let slice_len = slice.len();
3333 if slice_len < molecule::NUMBER_SIZE {
3334 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
3335 }
3336 let total_size = molecule::unpack_number(slice) as usize;
3337 if slice_len != total_size {
3338 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
3339 }
3340 if slice_len < molecule::NUMBER_SIZE * 2 {
3341 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
3342 }
3343 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
3344 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
3345 return ve!(Self, OffsetsNotMatch);
3346 }
3347 if slice_len < offset_first {
3348 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
3349 }
3350 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
3351 if field_count < Self::FIELD_COUNT {
3352 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3353 } else if !compatible && field_count > Self::FIELD_COUNT {
3354 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3355 };
3356 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
3357 .chunks_exact(molecule::NUMBER_SIZE)
3358 .map(|x| molecule::unpack_number(x) as usize)
3359 .collect();
3360 offsets.push(total_size);
3361 if offsets.windows(2).any(|i| i[0] > i[1]) {
3362 return ve!(Self, OffsetsNotMatch);
3363 }
3364 BoolReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
3365 NodeVecReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
3366 Ok(())
3367 }
3368}
3369#[derive(Debug, Default)]
3370pub struct NodesBuilder {
3371 pub(crate) announce: Bool,
3372 pub(crate) items: NodeVec,
3373}
3374impl NodesBuilder {
3375 pub const FIELD_COUNT: usize = 2;
3376 pub fn announce(mut self, v: Bool) -> Self {
3377 self.announce = v;
3378 self
3379 }
3380 pub fn items(mut self, v: NodeVec) -> Self {
3381 self.items = v;
3382 self
3383 }
3384}
3385impl molecule::prelude::Builder for NodesBuilder {
3386 type Entity = Nodes;
3387 const NAME: &'static str = "NodesBuilder";
3388 fn expected_length(&self) -> usize {
3389 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
3390 + self.announce.as_slice().len()
3391 + self.items.as_slice().len()
3392 }
3393 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
3394 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
3395 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
3396 offsets.push(total_size);
3397 total_size += self.announce.as_slice().len();
3398 offsets.push(total_size);
3399 total_size += self.items.as_slice().len();
3400 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
3401 for offset in offsets.into_iter() {
3402 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
3403 }
3404 writer.write_all(self.announce.as_slice())?;
3405 writer.write_all(self.items.as_slice())?;
3406 Ok(())
3407 }
3408 fn build(&self) -> Self::Entity {
3409 let mut inner = Vec::with_capacity(self.expected_length());
3410 self.write(&mut inner)
3411 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
3412 Nodes::new_unchecked(inner.into())
3413 }
3414}
3415#[derive(Clone)]
3416pub struct Nodes2(molecule::bytes::Bytes);
3417impl ::core::fmt::LowerHex for Nodes2 {
3418 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3419 use molecule::hex_string;
3420 if f.alternate() {
3421 write!(f, "0x")?;
3422 }
3423 write!(f, "{}", hex_string(self.as_slice()))
3424 }
3425}
3426impl ::core::fmt::Debug for Nodes2 {
3427 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3428 write!(f, "{}({:#x})", Self::NAME, self)
3429 }
3430}
3431impl ::core::fmt::Display for Nodes2 {
3432 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3433 write!(f, "{} {{ ", Self::NAME)?;
3434 write!(f, "{}: {}", "announce", self.announce())?;
3435 write!(f, ", {}: {}", "items", self.items())?;
3436 let extra_count = self.count_extra_fields();
3437 if extra_count != 0 {
3438 write!(f, ", .. ({} fields)", extra_count)?;
3439 }
3440 write!(f, " }}")
3441 }
3442}
3443impl ::core::default::Default for Nodes2 {
3444 fn default() -> Self {
3445 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
3446 Nodes2::new_unchecked(v)
3447 }
3448}
3449impl Nodes2 {
3450 const DEFAULT_VALUE: [u8; 17] = [17, 0, 0, 0, 12, 0, 0, 0, 13, 0, 0, 0, 0, 4, 0, 0, 0];
3451 pub const FIELD_COUNT: usize = 2;
3452 pub fn total_size(&self) -> usize {
3453 molecule::unpack_number(self.as_slice()) as usize
3454 }
3455 pub fn field_count(&self) -> usize {
3456 if self.total_size() == molecule::NUMBER_SIZE {
3457 0
3458 } else {
3459 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3460 }
3461 }
3462 pub fn count_extra_fields(&self) -> usize {
3463 self.field_count() - Self::FIELD_COUNT
3464 }
3465 pub fn has_extra_fields(&self) -> bool {
3466 Self::FIELD_COUNT != self.field_count()
3467 }
3468 pub fn announce(&self) -> Bool {
3469 let slice = self.as_slice();
3470 let start = molecule::unpack_number(&slice[4..]) as usize;
3471 let end = molecule::unpack_number(&slice[8..]) as usize;
3472 Bool::new_unchecked(self.0.slice(start..end))
3473 }
3474 pub fn items(&self) -> Node2Vec {
3475 let slice = self.as_slice();
3476 let start = molecule::unpack_number(&slice[8..]) as usize;
3477 if self.has_extra_fields() {
3478 let end = molecule::unpack_number(&slice[12..]) as usize;
3479 Node2Vec::new_unchecked(self.0.slice(start..end))
3480 } else {
3481 Node2Vec::new_unchecked(self.0.slice(start..))
3482 }
3483 }
3484 pub fn as_reader<'r>(&'r self) -> Nodes2Reader<'r> {
3485 Nodes2Reader::new_unchecked(self.as_slice())
3486 }
3487}
3488impl molecule::prelude::Entity for Nodes2 {
3489 type Builder = Nodes2Builder;
3490 const NAME: &'static str = "Nodes2";
3491 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
3492 Nodes2(data)
3493 }
3494 fn as_bytes(&self) -> molecule::bytes::Bytes {
3495 self.0.clone()
3496 }
3497 fn as_slice(&self) -> &[u8] {
3498 &self.0[..]
3499 }
3500 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3501 Nodes2Reader::from_slice(slice).map(|reader| reader.to_entity())
3502 }
3503 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3504 Nodes2Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
3505 }
3506 fn new_builder() -> Self::Builder {
3507 ::core::default::Default::default()
3508 }
3509 fn as_builder(self) -> Self::Builder {
3510 Self::new_builder()
3511 .announce(self.announce())
3512 .items(self.items())
3513 }
3514}
3515#[derive(Clone, Copy)]
3516pub struct Nodes2Reader<'r>(&'r [u8]);
3517impl<'r> ::core::fmt::LowerHex for Nodes2Reader<'r> {
3518 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3519 use molecule::hex_string;
3520 if f.alternate() {
3521 write!(f, "0x")?;
3522 }
3523 write!(f, "{}", hex_string(self.as_slice()))
3524 }
3525}
3526impl<'r> ::core::fmt::Debug for Nodes2Reader<'r> {
3527 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3528 write!(f, "{}({:#x})", Self::NAME, self)
3529 }
3530}
3531impl<'r> ::core::fmt::Display for Nodes2Reader<'r> {
3532 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3533 write!(f, "{} {{ ", Self::NAME)?;
3534 write!(f, "{}: {}", "announce", self.announce())?;
3535 write!(f, ", {}: {}", "items", self.items())?;
3536 let extra_count = self.count_extra_fields();
3537 if extra_count != 0 {
3538 write!(f, ", .. ({} fields)", extra_count)?;
3539 }
3540 write!(f, " }}")
3541 }
3542}
3543impl<'r> Nodes2Reader<'r> {
3544 pub const FIELD_COUNT: usize = 2;
3545 pub fn total_size(&self) -> usize {
3546 molecule::unpack_number(self.as_slice()) as usize
3547 }
3548 pub fn field_count(&self) -> usize {
3549 if self.total_size() == molecule::NUMBER_SIZE {
3550 0
3551 } else {
3552 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3553 }
3554 }
3555 pub fn count_extra_fields(&self) -> usize {
3556 self.field_count() - Self::FIELD_COUNT
3557 }
3558 pub fn has_extra_fields(&self) -> bool {
3559 Self::FIELD_COUNT != self.field_count()
3560 }
3561 pub fn announce(&self) -> BoolReader<'r> {
3562 let slice = self.as_slice();
3563 let start = molecule::unpack_number(&slice[4..]) as usize;
3564 let end = molecule::unpack_number(&slice[8..]) as usize;
3565 BoolReader::new_unchecked(&self.as_slice()[start..end])
3566 }
3567 pub fn items(&self) -> Node2VecReader<'r> {
3568 let slice = self.as_slice();
3569 let start = molecule::unpack_number(&slice[8..]) as usize;
3570 if self.has_extra_fields() {
3571 let end = molecule::unpack_number(&slice[12..]) as usize;
3572 Node2VecReader::new_unchecked(&self.as_slice()[start..end])
3573 } else {
3574 Node2VecReader::new_unchecked(&self.as_slice()[start..])
3575 }
3576 }
3577}
3578impl<'r> molecule::prelude::Reader<'r> for Nodes2Reader<'r> {
3579 type Entity = Nodes2;
3580 const NAME: &'static str = "Nodes2Reader";
3581 fn to_entity(&self) -> Self::Entity {
3582 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
3583 }
3584 fn new_unchecked(slice: &'r [u8]) -> Self {
3585 Nodes2Reader(slice)
3586 }
3587 fn as_slice(&self) -> &'r [u8] {
3588 self.0
3589 }
3590 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
3591 use molecule::verification_error as ve;
3592 let slice_len = slice.len();
3593 if slice_len < molecule::NUMBER_SIZE {
3594 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
3595 }
3596 let total_size = molecule::unpack_number(slice) as usize;
3597 if slice_len != total_size {
3598 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
3599 }
3600 if slice_len < molecule::NUMBER_SIZE * 2 {
3601 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
3602 }
3603 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
3604 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
3605 return ve!(Self, OffsetsNotMatch);
3606 }
3607 if slice_len < offset_first {
3608 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
3609 }
3610 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
3611 if field_count < Self::FIELD_COUNT {
3612 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3613 } else if !compatible && field_count > Self::FIELD_COUNT {
3614 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3615 };
3616 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
3617 .chunks_exact(molecule::NUMBER_SIZE)
3618 .map(|x| molecule::unpack_number(x) as usize)
3619 .collect();
3620 offsets.push(total_size);
3621 if offsets.windows(2).any(|i| i[0] > i[1]) {
3622 return ve!(Self, OffsetsNotMatch);
3623 }
3624 BoolReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
3625 Node2VecReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
3626 Ok(())
3627 }
3628}
3629#[derive(Debug, Default)]
3630pub struct Nodes2Builder {
3631 pub(crate) announce: Bool,
3632 pub(crate) items: Node2Vec,
3633}
3634impl Nodes2Builder {
3635 pub const FIELD_COUNT: usize = 2;
3636 pub fn announce(mut self, v: Bool) -> Self {
3637 self.announce = v;
3638 self
3639 }
3640 pub fn items(mut self, v: Node2Vec) -> Self {
3641 self.items = v;
3642 self
3643 }
3644}
3645impl molecule::prelude::Builder for Nodes2Builder {
3646 type Entity = Nodes2;
3647 const NAME: &'static str = "Nodes2Builder";
3648 fn expected_length(&self) -> usize {
3649 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
3650 + self.announce.as_slice().len()
3651 + self.items.as_slice().len()
3652 }
3653 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
3654 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
3655 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
3656 offsets.push(total_size);
3657 total_size += self.announce.as_slice().len();
3658 offsets.push(total_size);
3659 total_size += self.items.as_slice().len();
3660 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
3661 for offset in offsets.into_iter() {
3662 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
3663 }
3664 writer.write_all(self.announce.as_slice())?;
3665 writer.write_all(self.items.as_slice())?;
3666 Ok(())
3667 }
3668 fn build(&self) -> Self::Entity {
3669 let mut inner = Vec::with_capacity(self.expected_length());
3670 self.write(&mut inner)
3671 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
3672 Nodes2::new_unchecked(inner.into())
3673 }
3674}
3675#[derive(Clone)]
3676pub struct Node(molecule::bytes::Bytes);
3677impl ::core::fmt::LowerHex for Node {
3678 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3679 use molecule::hex_string;
3680 if f.alternate() {
3681 write!(f, "0x")?;
3682 }
3683 write!(f, "{}", hex_string(self.as_slice()))
3684 }
3685}
3686impl ::core::fmt::Debug for Node {
3687 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3688 write!(f, "{}({:#x})", Self::NAME, self)
3689 }
3690}
3691impl ::core::fmt::Display for Node {
3692 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3693 write!(f, "{} {{ ", Self::NAME)?;
3694 write!(f, "{}: {}", "addresses", self.addresses())?;
3695 let extra_count = self.count_extra_fields();
3696 if extra_count != 0 {
3697 write!(f, ", .. ({} fields)", extra_count)?;
3698 }
3699 write!(f, " }}")
3700 }
3701}
3702impl ::core::default::Default for Node {
3703 fn default() -> Self {
3704 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
3705 Node::new_unchecked(v)
3706 }
3707}
3708impl Node {
3709 const DEFAULT_VALUE: [u8; 12] = [12, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 0];
3710 pub const FIELD_COUNT: usize = 1;
3711 pub fn total_size(&self) -> usize {
3712 molecule::unpack_number(self.as_slice()) as usize
3713 }
3714 pub fn field_count(&self) -> usize {
3715 if self.total_size() == molecule::NUMBER_SIZE {
3716 0
3717 } else {
3718 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3719 }
3720 }
3721 pub fn count_extra_fields(&self) -> usize {
3722 self.field_count() - Self::FIELD_COUNT
3723 }
3724 pub fn has_extra_fields(&self) -> bool {
3725 Self::FIELD_COUNT != self.field_count()
3726 }
3727 pub fn addresses(&self) -> BytesVec {
3728 let slice = self.as_slice();
3729 let start = molecule::unpack_number(&slice[4..]) as usize;
3730 if self.has_extra_fields() {
3731 let end = molecule::unpack_number(&slice[8..]) as usize;
3732 BytesVec::new_unchecked(self.0.slice(start..end))
3733 } else {
3734 BytesVec::new_unchecked(self.0.slice(start..))
3735 }
3736 }
3737 pub fn as_reader<'r>(&'r self) -> NodeReader<'r> {
3738 NodeReader::new_unchecked(self.as_slice())
3739 }
3740}
3741impl molecule::prelude::Entity for Node {
3742 type Builder = NodeBuilder;
3743 const NAME: &'static str = "Node";
3744 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
3745 Node(data)
3746 }
3747 fn as_bytes(&self) -> molecule::bytes::Bytes {
3748 self.0.clone()
3749 }
3750 fn as_slice(&self) -> &[u8] {
3751 &self.0[..]
3752 }
3753 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3754 NodeReader::from_slice(slice).map(|reader| reader.to_entity())
3755 }
3756 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3757 NodeReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
3758 }
3759 fn new_builder() -> Self::Builder {
3760 ::core::default::Default::default()
3761 }
3762 fn as_builder(self) -> Self::Builder {
3763 Self::new_builder().addresses(self.addresses())
3764 }
3765}
3766#[derive(Clone, Copy)]
3767pub struct NodeReader<'r>(&'r [u8]);
3768impl<'r> ::core::fmt::LowerHex for NodeReader<'r> {
3769 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3770 use molecule::hex_string;
3771 if f.alternate() {
3772 write!(f, "0x")?;
3773 }
3774 write!(f, "{}", hex_string(self.as_slice()))
3775 }
3776}
3777impl<'r> ::core::fmt::Debug for NodeReader<'r> {
3778 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3779 write!(f, "{}({:#x})", Self::NAME, self)
3780 }
3781}
3782impl<'r> ::core::fmt::Display for NodeReader<'r> {
3783 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3784 write!(f, "{} {{ ", Self::NAME)?;
3785 write!(f, "{}: {}", "addresses", self.addresses())?;
3786 let extra_count = self.count_extra_fields();
3787 if extra_count != 0 {
3788 write!(f, ", .. ({} fields)", extra_count)?;
3789 }
3790 write!(f, " }}")
3791 }
3792}
3793impl<'r> NodeReader<'r> {
3794 pub const FIELD_COUNT: usize = 1;
3795 pub fn total_size(&self) -> usize {
3796 molecule::unpack_number(self.as_slice()) as usize
3797 }
3798 pub fn field_count(&self) -> usize {
3799 if self.total_size() == molecule::NUMBER_SIZE {
3800 0
3801 } else {
3802 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3803 }
3804 }
3805 pub fn count_extra_fields(&self) -> usize {
3806 self.field_count() - Self::FIELD_COUNT
3807 }
3808 pub fn has_extra_fields(&self) -> bool {
3809 Self::FIELD_COUNT != self.field_count()
3810 }
3811 pub fn addresses(&self) -> BytesVecReader<'r> {
3812 let slice = self.as_slice();
3813 let start = molecule::unpack_number(&slice[4..]) as usize;
3814 if self.has_extra_fields() {
3815 let end = molecule::unpack_number(&slice[8..]) as usize;
3816 BytesVecReader::new_unchecked(&self.as_slice()[start..end])
3817 } else {
3818 BytesVecReader::new_unchecked(&self.as_slice()[start..])
3819 }
3820 }
3821}
3822impl<'r> molecule::prelude::Reader<'r> for NodeReader<'r> {
3823 type Entity = Node;
3824 const NAME: &'static str = "NodeReader";
3825 fn to_entity(&self) -> Self::Entity {
3826 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
3827 }
3828 fn new_unchecked(slice: &'r [u8]) -> Self {
3829 NodeReader(slice)
3830 }
3831 fn as_slice(&self) -> &'r [u8] {
3832 self.0
3833 }
3834 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
3835 use molecule::verification_error as ve;
3836 let slice_len = slice.len();
3837 if slice_len < molecule::NUMBER_SIZE {
3838 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
3839 }
3840 let total_size = molecule::unpack_number(slice) as usize;
3841 if slice_len != total_size {
3842 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
3843 }
3844 if slice_len < molecule::NUMBER_SIZE * 2 {
3845 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
3846 }
3847 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
3848 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
3849 return ve!(Self, OffsetsNotMatch);
3850 }
3851 if slice_len < offset_first {
3852 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
3853 }
3854 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
3855 if field_count < Self::FIELD_COUNT {
3856 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3857 } else if !compatible && field_count > Self::FIELD_COUNT {
3858 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
3859 };
3860 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
3861 .chunks_exact(molecule::NUMBER_SIZE)
3862 .map(|x| molecule::unpack_number(x) as usize)
3863 .collect();
3864 offsets.push(total_size);
3865 if offsets.windows(2).any(|i| i[0] > i[1]) {
3866 return ve!(Self, OffsetsNotMatch);
3867 }
3868 BytesVecReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
3869 Ok(())
3870 }
3871}
3872#[derive(Debug, Default)]
3873pub struct NodeBuilder {
3874 pub(crate) addresses: BytesVec,
3875}
3876impl NodeBuilder {
3877 pub const FIELD_COUNT: usize = 1;
3878 pub fn addresses(mut self, v: BytesVec) -> Self {
3879 self.addresses = v;
3880 self
3881 }
3882}
3883impl molecule::prelude::Builder for NodeBuilder {
3884 type Entity = Node;
3885 const NAME: &'static str = "NodeBuilder";
3886 fn expected_length(&self) -> usize {
3887 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.addresses.as_slice().len()
3888 }
3889 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
3890 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
3891 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
3892 offsets.push(total_size);
3893 total_size += self.addresses.as_slice().len();
3894 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
3895 for offset in offsets.into_iter() {
3896 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
3897 }
3898 writer.write_all(self.addresses.as_slice())?;
3899 Ok(())
3900 }
3901 fn build(&self) -> Self::Entity {
3902 let mut inner = Vec::with_capacity(self.expected_length());
3903 self.write(&mut inner)
3904 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
3905 Node::new_unchecked(inner.into())
3906 }
3907}
3908#[derive(Clone)]
3909pub struct Node2(molecule::bytes::Bytes);
3910impl ::core::fmt::LowerHex for Node2 {
3911 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3912 use molecule::hex_string;
3913 if f.alternate() {
3914 write!(f, "0x")?;
3915 }
3916 write!(f, "{}", hex_string(self.as_slice()))
3917 }
3918}
3919impl ::core::fmt::Debug for Node2 {
3920 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3921 write!(f, "{}({:#x})", Self::NAME, self)
3922 }
3923}
3924impl ::core::fmt::Display for Node2 {
3925 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
3926 write!(f, "{} {{ ", Self::NAME)?;
3927 write!(f, "{}: {}", "addresses", self.addresses())?;
3928 write!(f, ", {}: {}", "flags", self.flags())?;
3929 let extra_count = self.count_extra_fields();
3930 if extra_count != 0 {
3931 write!(f, ", .. ({} fields)", extra_count)?;
3932 }
3933 write!(f, " }}")
3934 }
3935}
3936impl ::core::default::Default for Node2 {
3937 fn default() -> Self {
3938 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
3939 Node2::new_unchecked(v)
3940 }
3941}
3942impl Node2 {
3943 const DEFAULT_VALUE: [u8; 24] = [
3944 24, 0, 0, 0, 12, 0, 0, 0, 16, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3945 ];
3946 pub const FIELD_COUNT: usize = 2;
3947 pub fn total_size(&self) -> usize {
3948 molecule::unpack_number(self.as_slice()) as usize
3949 }
3950 pub fn field_count(&self) -> usize {
3951 if self.total_size() == molecule::NUMBER_SIZE {
3952 0
3953 } else {
3954 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
3955 }
3956 }
3957 pub fn count_extra_fields(&self) -> usize {
3958 self.field_count() - Self::FIELD_COUNT
3959 }
3960 pub fn has_extra_fields(&self) -> bool {
3961 Self::FIELD_COUNT != self.field_count()
3962 }
3963 pub fn addresses(&self) -> BytesVec {
3964 let slice = self.as_slice();
3965 let start = molecule::unpack_number(&slice[4..]) as usize;
3966 let end = molecule::unpack_number(&slice[8..]) as usize;
3967 BytesVec::new_unchecked(self.0.slice(start..end))
3968 }
3969 pub fn flags(&self) -> Uint64 {
3970 let slice = self.as_slice();
3971 let start = molecule::unpack_number(&slice[8..]) as usize;
3972 if self.has_extra_fields() {
3973 let end = molecule::unpack_number(&slice[12..]) as usize;
3974 Uint64::new_unchecked(self.0.slice(start..end))
3975 } else {
3976 Uint64::new_unchecked(self.0.slice(start..))
3977 }
3978 }
3979 pub fn as_reader<'r>(&'r self) -> Node2Reader<'r> {
3980 Node2Reader::new_unchecked(self.as_slice())
3981 }
3982}
3983impl molecule::prelude::Entity for Node2 {
3984 type Builder = Node2Builder;
3985 const NAME: &'static str = "Node2";
3986 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
3987 Node2(data)
3988 }
3989 fn as_bytes(&self) -> molecule::bytes::Bytes {
3990 self.0.clone()
3991 }
3992 fn as_slice(&self) -> &[u8] {
3993 &self.0[..]
3994 }
3995 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3996 Node2Reader::from_slice(slice).map(|reader| reader.to_entity())
3997 }
3998 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
3999 Node2Reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
4000 }
4001 fn new_builder() -> Self::Builder {
4002 ::core::default::Default::default()
4003 }
4004 fn as_builder(self) -> Self::Builder {
4005 Self::new_builder()
4006 .addresses(self.addresses())
4007 .flags(self.flags())
4008 }
4009}
4010#[derive(Clone, Copy)]
4011pub struct Node2Reader<'r>(&'r [u8]);
4012impl<'r> ::core::fmt::LowerHex for Node2Reader<'r> {
4013 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4014 use molecule::hex_string;
4015 if f.alternate() {
4016 write!(f, "0x")?;
4017 }
4018 write!(f, "{}", hex_string(self.as_slice()))
4019 }
4020}
4021impl<'r> ::core::fmt::Debug for Node2Reader<'r> {
4022 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4023 write!(f, "{}({:#x})", Self::NAME, self)
4024 }
4025}
4026impl<'r> ::core::fmt::Display for Node2Reader<'r> {
4027 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4028 write!(f, "{} {{ ", Self::NAME)?;
4029 write!(f, "{}: {}", "addresses", self.addresses())?;
4030 write!(f, ", {}: {}", "flags", self.flags())?;
4031 let extra_count = self.count_extra_fields();
4032 if extra_count != 0 {
4033 write!(f, ", .. ({} fields)", extra_count)?;
4034 }
4035 write!(f, " }}")
4036 }
4037}
4038impl<'r> Node2Reader<'r> {
4039 pub const FIELD_COUNT: usize = 2;
4040 pub fn total_size(&self) -> usize {
4041 molecule::unpack_number(self.as_slice()) as usize
4042 }
4043 pub fn field_count(&self) -> usize {
4044 if self.total_size() == molecule::NUMBER_SIZE {
4045 0
4046 } else {
4047 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4048 }
4049 }
4050 pub fn count_extra_fields(&self) -> usize {
4051 self.field_count() - Self::FIELD_COUNT
4052 }
4053 pub fn has_extra_fields(&self) -> bool {
4054 Self::FIELD_COUNT != self.field_count()
4055 }
4056 pub fn addresses(&self) -> BytesVecReader<'r> {
4057 let slice = self.as_slice();
4058 let start = molecule::unpack_number(&slice[4..]) as usize;
4059 let end = molecule::unpack_number(&slice[8..]) as usize;
4060 BytesVecReader::new_unchecked(&self.as_slice()[start..end])
4061 }
4062 pub fn flags(&self) -> Uint64Reader<'r> {
4063 let slice = self.as_slice();
4064 let start = molecule::unpack_number(&slice[8..]) as usize;
4065 if self.has_extra_fields() {
4066 let end = molecule::unpack_number(&slice[12..]) as usize;
4067 Uint64Reader::new_unchecked(&self.as_slice()[start..end])
4068 } else {
4069 Uint64Reader::new_unchecked(&self.as_slice()[start..])
4070 }
4071 }
4072}
4073impl<'r> molecule::prelude::Reader<'r> for Node2Reader<'r> {
4074 type Entity = Node2;
4075 const NAME: &'static str = "Node2Reader";
4076 fn to_entity(&self) -> Self::Entity {
4077 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
4078 }
4079 fn new_unchecked(slice: &'r [u8]) -> Self {
4080 Node2Reader(slice)
4081 }
4082 fn as_slice(&self) -> &'r [u8] {
4083 self.0
4084 }
4085 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
4086 use molecule::verification_error as ve;
4087 let slice_len = slice.len();
4088 if slice_len < molecule::NUMBER_SIZE {
4089 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
4090 }
4091 let total_size = molecule::unpack_number(slice) as usize;
4092 if slice_len != total_size {
4093 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
4094 }
4095 if slice_len < molecule::NUMBER_SIZE * 2 {
4096 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
4097 }
4098 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
4099 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
4100 return ve!(Self, OffsetsNotMatch);
4101 }
4102 if slice_len < offset_first {
4103 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
4104 }
4105 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
4106 if field_count < Self::FIELD_COUNT {
4107 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4108 } else if !compatible && field_count > Self::FIELD_COUNT {
4109 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4110 };
4111 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
4112 .chunks_exact(molecule::NUMBER_SIZE)
4113 .map(|x| molecule::unpack_number(x) as usize)
4114 .collect();
4115 offsets.push(total_size);
4116 if offsets.windows(2).any(|i| i[0] > i[1]) {
4117 return ve!(Self, OffsetsNotMatch);
4118 }
4119 BytesVecReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
4120 Uint64Reader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
4121 Ok(())
4122 }
4123}
4124#[derive(Debug, Default)]
4125pub struct Node2Builder {
4126 pub(crate) addresses: BytesVec,
4127 pub(crate) flags: Uint64,
4128}
4129impl Node2Builder {
4130 pub const FIELD_COUNT: usize = 2;
4131 pub fn addresses(mut self, v: BytesVec) -> Self {
4132 self.addresses = v;
4133 self
4134 }
4135 pub fn flags(mut self, v: Uint64) -> Self {
4136 self.flags = v;
4137 self
4138 }
4139}
4140impl molecule::prelude::Builder for Node2Builder {
4141 type Entity = Node2;
4142 const NAME: &'static str = "Node2Builder";
4143 fn expected_length(&self) -> usize {
4144 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
4145 + self.addresses.as_slice().len()
4146 + self.flags.as_slice().len()
4147 }
4148 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
4149 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
4150 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
4151 offsets.push(total_size);
4152 total_size += self.addresses.as_slice().len();
4153 offsets.push(total_size);
4154 total_size += self.flags.as_slice().len();
4155 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
4156 for offset in offsets.into_iter() {
4157 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
4158 }
4159 writer.write_all(self.addresses.as_slice())?;
4160 writer.write_all(self.flags.as_slice())?;
4161 Ok(())
4162 }
4163 fn build(&self) -> Self::Entity {
4164 let mut inner = Vec::with_capacity(self.expected_length());
4165 self.write(&mut inner)
4166 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
4167 Node2::new_unchecked(inner.into())
4168 }
4169}
4170#[derive(Clone)]
4171pub struct AddressVec(molecule::bytes::Bytes);
4172impl ::core::fmt::LowerHex for AddressVec {
4173 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4174 use molecule::hex_string;
4175 if f.alternate() {
4176 write!(f, "0x")?;
4177 }
4178 write!(f, "{}", hex_string(self.as_slice()))
4179 }
4180}
4181impl ::core::fmt::Debug for AddressVec {
4182 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4183 write!(f, "{}({:#x})", Self::NAME, self)
4184 }
4185}
4186impl ::core::fmt::Display for AddressVec {
4187 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4188 write!(f, "{} [", Self::NAME)?;
4189 for i in 0..self.len() {
4190 if i == 0 {
4191 write!(f, "{}", self.get_unchecked(i))?;
4192 } else {
4193 write!(f, ", {}", self.get_unchecked(i))?;
4194 }
4195 }
4196 write!(f, "]")
4197 }
4198}
4199impl ::core::default::Default for AddressVec {
4200 fn default() -> Self {
4201 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
4202 AddressVec::new_unchecked(v)
4203 }
4204}
4205impl AddressVec {
4206 const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
4207 pub fn total_size(&self) -> usize {
4208 molecule::unpack_number(self.as_slice()) as usize
4209 }
4210 pub fn item_count(&self) -> usize {
4211 if self.total_size() == molecule::NUMBER_SIZE {
4212 0
4213 } else {
4214 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4215 }
4216 }
4217 pub fn len(&self) -> usize {
4218 self.item_count()
4219 }
4220 pub fn is_empty(&self) -> bool {
4221 self.len() == 0
4222 }
4223 pub fn get(&self, idx: usize) -> Option<Address> {
4224 if idx >= self.len() {
4225 None
4226 } else {
4227 Some(self.get_unchecked(idx))
4228 }
4229 }
4230 pub fn get_unchecked(&self, idx: usize) -> Address {
4231 let slice = self.as_slice();
4232 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
4233 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
4234 if idx == self.len() - 1 {
4235 Address::new_unchecked(self.0.slice(start..))
4236 } else {
4237 let end_idx = start_idx + molecule::NUMBER_SIZE;
4238 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
4239 Address::new_unchecked(self.0.slice(start..end))
4240 }
4241 }
4242 pub fn as_reader<'r>(&'r self) -> AddressVecReader<'r> {
4243 AddressVecReader::new_unchecked(self.as_slice())
4244 }
4245}
4246impl molecule::prelude::Entity for AddressVec {
4247 type Builder = AddressVecBuilder;
4248 const NAME: &'static str = "AddressVec";
4249 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
4250 AddressVec(data)
4251 }
4252 fn as_bytes(&self) -> molecule::bytes::Bytes {
4253 self.0.clone()
4254 }
4255 fn as_slice(&self) -> &[u8] {
4256 &self.0[..]
4257 }
4258 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4259 AddressVecReader::from_slice(slice).map(|reader| reader.to_entity())
4260 }
4261 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4262 AddressVecReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
4263 }
4264 fn new_builder() -> Self::Builder {
4265 ::core::default::Default::default()
4266 }
4267 fn as_builder(self) -> Self::Builder {
4268 Self::new_builder().extend(self.into_iter())
4269 }
4270}
4271#[derive(Clone, Copy)]
4272pub struct AddressVecReader<'r>(&'r [u8]);
4273impl<'r> ::core::fmt::LowerHex for AddressVecReader<'r> {
4274 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4275 use molecule::hex_string;
4276 if f.alternate() {
4277 write!(f, "0x")?;
4278 }
4279 write!(f, "{}", hex_string(self.as_slice()))
4280 }
4281}
4282impl<'r> ::core::fmt::Debug for AddressVecReader<'r> {
4283 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4284 write!(f, "{}({:#x})", Self::NAME, self)
4285 }
4286}
4287impl<'r> ::core::fmt::Display for AddressVecReader<'r> {
4288 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4289 write!(f, "{} [", Self::NAME)?;
4290 for i in 0..self.len() {
4291 if i == 0 {
4292 write!(f, "{}", self.get_unchecked(i))?;
4293 } else {
4294 write!(f, ", {}", self.get_unchecked(i))?;
4295 }
4296 }
4297 write!(f, "]")
4298 }
4299}
4300impl<'r> AddressVecReader<'r> {
4301 pub fn total_size(&self) -> usize {
4302 molecule::unpack_number(self.as_slice()) as usize
4303 }
4304 pub fn item_count(&self) -> usize {
4305 if self.total_size() == molecule::NUMBER_SIZE {
4306 0
4307 } else {
4308 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4309 }
4310 }
4311 pub fn len(&self) -> usize {
4312 self.item_count()
4313 }
4314 pub fn is_empty(&self) -> bool {
4315 self.len() == 0
4316 }
4317 pub fn get(&self, idx: usize) -> Option<AddressReader<'r>> {
4318 if idx >= self.len() {
4319 None
4320 } else {
4321 Some(self.get_unchecked(idx))
4322 }
4323 }
4324 pub fn get_unchecked(&self, idx: usize) -> AddressReader<'r> {
4325 let slice = self.as_slice();
4326 let start_idx = molecule::NUMBER_SIZE * (1 + idx);
4327 let start = molecule::unpack_number(&slice[start_idx..]) as usize;
4328 if idx == self.len() - 1 {
4329 AddressReader::new_unchecked(&self.as_slice()[start..])
4330 } else {
4331 let end_idx = start_idx + molecule::NUMBER_SIZE;
4332 let end = molecule::unpack_number(&slice[end_idx..]) as usize;
4333 AddressReader::new_unchecked(&self.as_slice()[start..end])
4334 }
4335 }
4336}
4337impl<'r> molecule::prelude::Reader<'r> for AddressVecReader<'r> {
4338 type Entity = AddressVec;
4339 const NAME: &'static str = "AddressVecReader";
4340 fn to_entity(&self) -> Self::Entity {
4341 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
4342 }
4343 fn new_unchecked(slice: &'r [u8]) -> Self {
4344 AddressVecReader(slice)
4345 }
4346 fn as_slice(&self) -> &'r [u8] {
4347 self.0
4348 }
4349 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
4350 use molecule::verification_error as ve;
4351 let slice_len = slice.len();
4352 if slice_len < molecule::NUMBER_SIZE {
4353 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
4354 }
4355 let total_size = molecule::unpack_number(slice) as usize;
4356 if slice_len != total_size {
4357 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
4358 }
4359 if slice_len == molecule::NUMBER_SIZE {
4360 return Ok(());
4361 }
4362 if slice_len < molecule::NUMBER_SIZE * 2 {
4363 return ve!(
4364 Self,
4365 TotalSizeNotMatch,
4366 molecule::NUMBER_SIZE * 2,
4367 slice_len
4368 );
4369 }
4370 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
4371 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
4372 return ve!(Self, OffsetsNotMatch);
4373 }
4374 if slice_len < offset_first {
4375 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
4376 }
4377 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
4378 .chunks_exact(molecule::NUMBER_SIZE)
4379 .map(|x| molecule::unpack_number(x) as usize)
4380 .collect();
4381 offsets.push(total_size);
4382 if offsets.windows(2).any(|i| i[0] > i[1]) {
4383 return ve!(Self, OffsetsNotMatch);
4384 }
4385 for pair in offsets.windows(2) {
4386 let start = pair[0];
4387 let end = pair[1];
4388 AddressReader::verify(&slice[start..end], compatible)?;
4389 }
4390 Ok(())
4391 }
4392}
4393#[derive(Debug, Default)]
4394pub struct AddressVecBuilder(pub(crate) Vec<Address>);
4395impl AddressVecBuilder {
4396 pub fn set(mut self, v: Vec<Address>) -> Self {
4397 self.0 = v;
4398 self
4399 }
4400 pub fn push(mut self, v: Address) -> Self {
4401 self.0.push(v);
4402 self
4403 }
4404 pub fn extend<T: ::core::iter::IntoIterator<Item = Address>>(mut self, iter: T) -> Self {
4405 for elem in iter {
4406 self.0.push(elem);
4407 }
4408 self
4409 }
4410 pub fn replace(&mut self, index: usize, v: Address) -> Option<Address> {
4411 self.0
4412 .get_mut(index)
4413 .map(|item| ::core::mem::replace(item, v))
4414 }
4415}
4416impl molecule::prelude::Builder for AddressVecBuilder {
4417 type Entity = AddressVec;
4418 const NAME: &'static str = "AddressVecBuilder";
4419 fn expected_length(&self) -> usize {
4420 molecule::NUMBER_SIZE * (self.0.len() + 1)
4421 + self
4422 .0
4423 .iter()
4424 .map(|inner| inner.as_slice().len())
4425 .sum::<usize>()
4426 }
4427 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
4428 let item_count = self.0.len();
4429 if item_count == 0 {
4430 writer.write_all(&molecule::pack_number(
4431 molecule::NUMBER_SIZE as molecule::Number,
4432 ))?;
4433 } else {
4434 let (total_size, offsets) = self.0.iter().fold(
4435 (
4436 molecule::NUMBER_SIZE * (item_count + 1),
4437 Vec::with_capacity(item_count),
4438 ),
4439 |(start, mut offsets), inner| {
4440 offsets.push(start);
4441 (start + inner.as_slice().len(), offsets)
4442 },
4443 );
4444 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
4445 for offset in offsets.into_iter() {
4446 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
4447 }
4448 for inner in self.0.iter() {
4449 writer.write_all(inner.as_slice())?;
4450 }
4451 }
4452 Ok(())
4453 }
4454 fn build(&self) -> Self::Entity {
4455 let mut inner = Vec::with_capacity(self.expected_length());
4456 self.write(&mut inner)
4457 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
4458 AddressVec::new_unchecked(inner.into())
4459 }
4460}
4461pub struct AddressVecIterator(AddressVec, usize, usize);
4462impl ::core::iter::Iterator for AddressVecIterator {
4463 type Item = Address;
4464 fn next(&mut self) -> Option<Self::Item> {
4465 if self.1 >= self.2 {
4466 None
4467 } else {
4468 let ret = self.0.get_unchecked(self.1);
4469 self.1 += 1;
4470 Some(ret)
4471 }
4472 }
4473}
4474impl ::core::iter::ExactSizeIterator for AddressVecIterator {
4475 fn len(&self) -> usize {
4476 self.2 - self.1
4477 }
4478}
4479impl ::core::iter::IntoIterator for AddressVec {
4480 type Item = Address;
4481 type IntoIter = AddressVecIterator;
4482 fn into_iter(self) -> Self::IntoIter {
4483 let len = self.len();
4484 AddressVecIterator(self, 0, len)
4485 }
4486}
4487impl<'r> AddressVecReader<'r> {
4488 pub fn iter<'t>(&'t self) -> AddressVecReaderIterator<'t, 'r> {
4489 AddressVecReaderIterator(&self, 0, self.len())
4490 }
4491}
4492pub struct AddressVecReaderIterator<'t, 'r>(&'t AddressVecReader<'r>, usize, usize);
4493impl<'t: 'r, 'r> ::core::iter::Iterator for AddressVecReaderIterator<'t, 'r> {
4494 type Item = AddressReader<'t>;
4495 fn next(&mut self) -> Option<Self::Item> {
4496 if self.1 >= self.2 {
4497 None
4498 } else {
4499 let ret = self.0.get_unchecked(self.1);
4500 self.1 += 1;
4501 Some(ret)
4502 }
4503 }
4504}
4505impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for AddressVecReaderIterator<'t, 'r> {
4506 fn len(&self) -> usize {
4507 self.2 - self.1
4508 }
4509}
4510#[derive(Clone)]
4511pub struct Address(molecule::bytes::Bytes);
4512impl ::core::fmt::LowerHex for Address {
4513 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4514 use molecule::hex_string;
4515 if f.alternate() {
4516 write!(f, "0x")?;
4517 }
4518 write!(f, "{}", hex_string(self.as_slice()))
4519 }
4520}
4521impl ::core::fmt::Debug for Address {
4522 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4523 write!(f, "{}({:#x})", Self::NAME, self)
4524 }
4525}
4526impl ::core::fmt::Display for Address {
4527 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4528 write!(f, "{} {{ ", Self::NAME)?;
4529 write!(f, "{}: {}", "bytes", self.bytes())?;
4530 let extra_count = self.count_extra_fields();
4531 if extra_count != 0 {
4532 write!(f, ", .. ({} fields)", extra_count)?;
4533 }
4534 write!(f, " }}")
4535 }
4536}
4537impl ::core::default::Default for Address {
4538 fn default() -> Self {
4539 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
4540 Address::new_unchecked(v)
4541 }
4542}
4543impl Address {
4544 const DEFAULT_VALUE: [u8; 12] = [12, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0];
4545 pub const FIELD_COUNT: usize = 1;
4546 pub fn total_size(&self) -> usize {
4547 molecule::unpack_number(self.as_slice()) as usize
4548 }
4549 pub fn field_count(&self) -> usize {
4550 if self.total_size() == molecule::NUMBER_SIZE {
4551 0
4552 } else {
4553 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4554 }
4555 }
4556 pub fn count_extra_fields(&self) -> usize {
4557 self.field_count() - Self::FIELD_COUNT
4558 }
4559 pub fn has_extra_fields(&self) -> bool {
4560 Self::FIELD_COUNT != self.field_count()
4561 }
4562 pub fn bytes(&self) -> Bytes {
4563 let slice = self.as_slice();
4564 let start = molecule::unpack_number(&slice[4..]) as usize;
4565 if self.has_extra_fields() {
4566 let end = molecule::unpack_number(&slice[8..]) as usize;
4567 Bytes::new_unchecked(self.0.slice(start..end))
4568 } else {
4569 Bytes::new_unchecked(self.0.slice(start..))
4570 }
4571 }
4572 pub fn as_reader<'r>(&'r self) -> AddressReader<'r> {
4573 AddressReader::new_unchecked(self.as_slice())
4574 }
4575}
4576impl molecule::prelude::Entity for Address {
4577 type Builder = AddressBuilder;
4578 const NAME: &'static str = "Address";
4579 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
4580 Address(data)
4581 }
4582 fn as_bytes(&self) -> molecule::bytes::Bytes {
4583 self.0.clone()
4584 }
4585 fn as_slice(&self) -> &[u8] {
4586 &self.0[..]
4587 }
4588 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4589 AddressReader::from_slice(slice).map(|reader| reader.to_entity())
4590 }
4591 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4592 AddressReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
4593 }
4594 fn new_builder() -> Self::Builder {
4595 ::core::default::Default::default()
4596 }
4597 fn as_builder(self) -> Self::Builder {
4598 Self::new_builder().bytes(self.bytes())
4599 }
4600}
4601#[derive(Clone, Copy)]
4602pub struct AddressReader<'r>(&'r [u8]);
4603impl<'r> ::core::fmt::LowerHex for AddressReader<'r> {
4604 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4605 use molecule::hex_string;
4606 if f.alternate() {
4607 write!(f, "0x")?;
4608 }
4609 write!(f, "{}", hex_string(self.as_slice()))
4610 }
4611}
4612impl<'r> ::core::fmt::Debug for AddressReader<'r> {
4613 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4614 write!(f, "{}({:#x})", Self::NAME, self)
4615 }
4616}
4617impl<'r> ::core::fmt::Display for AddressReader<'r> {
4618 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4619 write!(f, "{} {{ ", Self::NAME)?;
4620 write!(f, "{}: {}", "bytes", self.bytes())?;
4621 let extra_count = self.count_extra_fields();
4622 if extra_count != 0 {
4623 write!(f, ", .. ({} fields)", extra_count)?;
4624 }
4625 write!(f, " }}")
4626 }
4627}
4628impl<'r> AddressReader<'r> {
4629 pub const FIELD_COUNT: usize = 1;
4630 pub fn total_size(&self) -> usize {
4631 molecule::unpack_number(self.as_slice()) as usize
4632 }
4633 pub fn field_count(&self) -> usize {
4634 if self.total_size() == molecule::NUMBER_SIZE {
4635 0
4636 } else {
4637 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4638 }
4639 }
4640 pub fn count_extra_fields(&self) -> usize {
4641 self.field_count() - Self::FIELD_COUNT
4642 }
4643 pub fn has_extra_fields(&self) -> bool {
4644 Self::FIELD_COUNT != self.field_count()
4645 }
4646 pub fn bytes(&self) -> BytesReader<'r> {
4647 let slice = self.as_slice();
4648 let start = molecule::unpack_number(&slice[4..]) as usize;
4649 if self.has_extra_fields() {
4650 let end = molecule::unpack_number(&slice[8..]) as usize;
4651 BytesReader::new_unchecked(&self.as_slice()[start..end])
4652 } else {
4653 BytesReader::new_unchecked(&self.as_slice()[start..])
4654 }
4655 }
4656}
4657impl<'r> molecule::prelude::Reader<'r> for AddressReader<'r> {
4658 type Entity = Address;
4659 const NAME: &'static str = "AddressReader";
4660 fn to_entity(&self) -> Self::Entity {
4661 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
4662 }
4663 fn new_unchecked(slice: &'r [u8]) -> Self {
4664 AddressReader(slice)
4665 }
4666 fn as_slice(&self) -> &'r [u8] {
4667 self.0
4668 }
4669 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
4670 use molecule::verification_error as ve;
4671 let slice_len = slice.len();
4672 if slice_len < molecule::NUMBER_SIZE {
4673 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
4674 }
4675 let total_size = molecule::unpack_number(slice) as usize;
4676 if slice_len != total_size {
4677 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
4678 }
4679 if slice_len < molecule::NUMBER_SIZE * 2 {
4680 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
4681 }
4682 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
4683 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
4684 return ve!(Self, OffsetsNotMatch);
4685 }
4686 if slice_len < offset_first {
4687 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
4688 }
4689 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
4690 if field_count < Self::FIELD_COUNT {
4691 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4692 } else if !compatible && field_count > Self::FIELD_COUNT {
4693 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4694 };
4695 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
4696 .chunks_exact(molecule::NUMBER_SIZE)
4697 .map(|x| molecule::unpack_number(x) as usize)
4698 .collect();
4699 offsets.push(total_size);
4700 if offsets.windows(2).any(|i| i[0] > i[1]) {
4701 return ve!(Self, OffsetsNotMatch);
4702 }
4703 BytesReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
4704 Ok(())
4705 }
4706}
4707#[derive(Debug, Default)]
4708pub struct AddressBuilder {
4709 pub(crate) bytes: Bytes,
4710}
4711impl AddressBuilder {
4712 pub const FIELD_COUNT: usize = 1;
4713 pub fn bytes(mut self, v: Bytes) -> Self {
4714 self.bytes = v;
4715 self
4716 }
4717}
4718impl molecule::prelude::Builder for AddressBuilder {
4719 type Entity = Address;
4720 const NAME: &'static str = "AddressBuilder";
4721 fn expected_length(&self) -> usize {
4722 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1) + self.bytes.as_slice().len()
4723 }
4724 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
4725 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
4726 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
4727 offsets.push(total_size);
4728 total_size += self.bytes.as_slice().len();
4729 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
4730 for offset in offsets.into_iter() {
4731 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
4732 }
4733 writer.write_all(self.bytes.as_slice())?;
4734 Ok(())
4735 }
4736 fn build(&self) -> Self::Entity {
4737 let mut inner = Vec::with_capacity(self.expected_length());
4738 self.write(&mut inner)
4739 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
4740 Address::new_unchecked(inner.into())
4741 }
4742}
4743#[derive(Clone)]
4744pub struct IdentifyMessage(molecule::bytes::Bytes);
4745impl ::core::fmt::LowerHex for IdentifyMessage {
4746 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4747 use molecule::hex_string;
4748 if f.alternate() {
4749 write!(f, "0x")?;
4750 }
4751 write!(f, "{}", hex_string(self.as_slice()))
4752 }
4753}
4754impl ::core::fmt::Debug for IdentifyMessage {
4755 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4756 write!(f, "{}({:#x})", Self::NAME, self)
4757 }
4758}
4759impl ::core::fmt::Display for IdentifyMessage {
4760 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4761 write!(f, "{} {{ ", Self::NAME)?;
4762 write!(f, "{}: {}", "listen_addrs", self.listen_addrs())?;
4763 write!(f, ", {}: {}", "observed_addr", self.observed_addr())?;
4764 write!(f, ", {}: {}", "identify", self.identify())?;
4765 let extra_count = self.count_extra_fields();
4766 if extra_count != 0 {
4767 write!(f, ", .. ({} fields)", extra_count)?;
4768 }
4769 write!(f, " }}")
4770 }
4771}
4772impl ::core::default::Default for IdentifyMessage {
4773 fn default() -> Self {
4774 let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
4775 IdentifyMessage::new_unchecked(v)
4776 }
4777}
4778impl IdentifyMessage {
4779 const DEFAULT_VALUE: [u8; 36] = [
4780 36, 0, 0, 0, 16, 0, 0, 0, 20, 0, 0, 0, 32, 0, 0, 0, 4, 0, 0, 0, 12, 0, 0, 0, 8, 0, 0, 0, 0,
4781 0, 0, 0, 0, 0, 0, 0,
4782 ];
4783 pub const FIELD_COUNT: usize = 3;
4784 pub fn total_size(&self) -> usize {
4785 molecule::unpack_number(self.as_slice()) as usize
4786 }
4787 pub fn field_count(&self) -> usize {
4788 if self.total_size() == molecule::NUMBER_SIZE {
4789 0
4790 } else {
4791 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4792 }
4793 }
4794 pub fn count_extra_fields(&self) -> usize {
4795 self.field_count() - Self::FIELD_COUNT
4796 }
4797 pub fn has_extra_fields(&self) -> bool {
4798 Self::FIELD_COUNT != self.field_count()
4799 }
4800 pub fn listen_addrs(&self) -> AddressVec {
4801 let slice = self.as_slice();
4802 let start = molecule::unpack_number(&slice[4..]) as usize;
4803 let end = molecule::unpack_number(&slice[8..]) as usize;
4804 AddressVec::new_unchecked(self.0.slice(start..end))
4805 }
4806 pub fn observed_addr(&self) -> Address {
4807 let slice = self.as_slice();
4808 let start = molecule::unpack_number(&slice[8..]) as usize;
4809 let end = molecule::unpack_number(&slice[12..]) as usize;
4810 Address::new_unchecked(self.0.slice(start..end))
4811 }
4812 pub fn identify(&self) -> Bytes {
4813 let slice = self.as_slice();
4814 let start = molecule::unpack_number(&slice[12..]) as usize;
4815 if self.has_extra_fields() {
4816 let end = molecule::unpack_number(&slice[16..]) as usize;
4817 Bytes::new_unchecked(self.0.slice(start..end))
4818 } else {
4819 Bytes::new_unchecked(self.0.slice(start..))
4820 }
4821 }
4822 pub fn as_reader<'r>(&'r self) -> IdentifyMessageReader<'r> {
4823 IdentifyMessageReader::new_unchecked(self.as_slice())
4824 }
4825}
4826impl molecule::prelude::Entity for IdentifyMessage {
4827 type Builder = IdentifyMessageBuilder;
4828 const NAME: &'static str = "IdentifyMessage";
4829 fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
4830 IdentifyMessage(data)
4831 }
4832 fn as_bytes(&self) -> molecule::bytes::Bytes {
4833 self.0.clone()
4834 }
4835 fn as_slice(&self) -> &[u8] {
4836 &self.0[..]
4837 }
4838 fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4839 IdentifyMessageReader::from_slice(slice).map(|reader| reader.to_entity())
4840 }
4841 fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
4842 IdentifyMessageReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
4843 }
4844 fn new_builder() -> Self::Builder {
4845 ::core::default::Default::default()
4846 }
4847 fn as_builder(self) -> Self::Builder {
4848 Self::new_builder()
4849 .listen_addrs(self.listen_addrs())
4850 .observed_addr(self.observed_addr())
4851 .identify(self.identify())
4852 }
4853}
4854#[derive(Clone, Copy)]
4855pub struct IdentifyMessageReader<'r>(&'r [u8]);
4856impl<'r> ::core::fmt::LowerHex for IdentifyMessageReader<'r> {
4857 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4858 use molecule::hex_string;
4859 if f.alternate() {
4860 write!(f, "0x")?;
4861 }
4862 write!(f, "{}", hex_string(self.as_slice()))
4863 }
4864}
4865impl<'r> ::core::fmt::Debug for IdentifyMessageReader<'r> {
4866 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4867 write!(f, "{}({:#x})", Self::NAME, self)
4868 }
4869}
4870impl<'r> ::core::fmt::Display for IdentifyMessageReader<'r> {
4871 fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
4872 write!(f, "{} {{ ", Self::NAME)?;
4873 write!(f, "{}: {}", "listen_addrs", self.listen_addrs())?;
4874 write!(f, ", {}: {}", "observed_addr", self.observed_addr())?;
4875 write!(f, ", {}: {}", "identify", self.identify())?;
4876 let extra_count = self.count_extra_fields();
4877 if extra_count != 0 {
4878 write!(f, ", .. ({} fields)", extra_count)?;
4879 }
4880 write!(f, " }}")
4881 }
4882}
4883impl<'r> IdentifyMessageReader<'r> {
4884 pub const FIELD_COUNT: usize = 3;
4885 pub fn total_size(&self) -> usize {
4886 molecule::unpack_number(self.as_slice()) as usize
4887 }
4888 pub fn field_count(&self) -> usize {
4889 if self.total_size() == molecule::NUMBER_SIZE {
4890 0
4891 } else {
4892 (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
4893 }
4894 }
4895 pub fn count_extra_fields(&self) -> usize {
4896 self.field_count() - Self::FIELD_COUNT
4897 }
4898 pub fn has_extra_fields(&self) -> bool {
4899 Self::FIELD_COUNT != self.field_count()
4900 }
4901 pub fn listen_addrs(&self) -> AddressVecReader<'r> {
4902 let slice = self.as_slice();
4903 let start = molecule::unpack_number(&slice[4..]) as usize;
4904 let end = molecule::unpack_number(&slice[8..]) as usize;
4905 AddressVecReader::new_unchecked(&self.as_slice()[start..end])
4906 }
4907 pub fn observed_addr(&self) -> AddressReader<'r> {
4908 let slice = self.as_slice();
4909 let start = molecule::unpack_number(&slice[8..]) as usize;
4910 let end = molecule::unpack_number(&slice[12..]) as usize;
4911 AddressReader::new_unchecked(&self.as_slice()[start..end])
4912 }
4913 pub fn identify(&self) -> BytesReader<'r> {
4914 let slice = self.as_slice();
4915 let start = molecule::unpack_number(&slice[12..]) as usize;
4916 if self.has_extra_fields() {
4917 let end = molecule::unpack_number(&slice[16..]) as usize;
4918 BytesReader::new_unchecked(&self.as_slice()[start..end])
4919 } else {
4920 BytesReader::new_unchecked(&self.as_slice()[start..])
4921 }
4922 }
4923}
4924impl<'r> molecule::prelude::Reader<'r> for IdentifyMessageReader<'r> {
4925 type Entity = IdentifyMessage;
4926 const NAME: &'static str = "IdentifyMessageReader";
4927 fn to_entity(&self) -> Self::Entity {
4928 Self::Entity::new_unchecked(self.as_slice().to_owned().into())
4929 }
4930 fn new_unchecked(slice: &'r [u8]) -> Self {
4931 IdentifyMessageReader(slice)
4932 }
4933 fn as_slice(&self) -> &'r [u8] {
4934 self.0
4935 }
4936 fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
4937 use molecule::verification_error as ve;
4938 let slice_len = slice.len();
4939 if slice_len < molecule::NUMBER_SIZE {
4940 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
4941 }
4942 let total_size = molecule::unpack_number(slice) as usize;
4943 if slice_len != total_size {
4944 return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
4945 }
4946 if slice_len < molecule::NUMBER_SIZE * 2 {
4947 return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
4948 }
4949 let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
4950 if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
4951 return ve!(Self, OffsetsNotMatch);
4952 }
4953 if slice_len < offset_first {
4954 return ve!(Self, HeaderIsBroken, offset_first, slice_len);
4955 }
4956 let field_count = offset_first / molecule::NUMBER_SIZE - 1;
4957 if field_count < Self::FIELD_COUNT {
4958 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4959 } else if !compatible && field_count > Self::FIELD_COUNT {
4960 return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
4961 };
4962 let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
4963 .chunks_exact(molecule::NUMBER_SIZE)
4964 .map(|x| molecule::unpack_number(x) as usize)
4965 .collect();
4966 offsets.push(total_size);
4967 if offsets.windows(2).any(|i| i[0] > i[1]) {
4968 return ve!(Self, OffsetsNotMatch);
4969 }
4970 AddressVecReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
4971 AddressReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
4972 BytesReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
4973 Ok(())
4974 }
4975}
4976#[derive(Debug, Default)]
4977pub struct IdentifyMessageBuilder {
4978 pub(crate) listen_addrs: AddressVec,
4979 pub(crate) observed_addr: Address,
4980 pub(crate) identify: Bytes,
4981}
4982impl IdentifyMessageBuilder {
4983 pub const FIELD_COUNT: usize = 3;
4984 pub fn listen_addrs(mut self, v: AddressVec) -> Self {
4985 self.listen_addrs = v;
4986 self
4987 }
4988 pub fn observed_addr(mut self, v: Address) -> Self {
4989 self.observed_addr = v;
4990 self
4991 }
4992 pub fn identify(mut self, v: Bytes) -> Self {
4993 self.identify = v;
4994 self
4995 }
4996}
4997impl molecule::prelude::Builder for IdentifyMessageBuilder {
4998 type Entity = IdentifyMessage;
4999 const NAME: &'static str = "IdentifyMessageBuilder";
5000 fn expected_length(&self) -> usize {
5001 molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
5002 + self.listen_addrs.as_slice().len()
5003 + self.observed_addr.as_slice().len()
5004 + self.identify.as_slice().len()
5005 }
5006 fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
5007 let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
5008 let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
5009 offsets.push(total_size);
5010 total_size += self.listen_addrs.as_slice().len();
5011 offsets.push(total_size);
5012 total_size += self.observed_addr.as_slice().len();
5013 offsets.push(total_size);
5014 total_size += self.identify.as_slice().len();
5015 writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
5016 for offset in offsets.into_iter() {
5017 writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
5018 }
5019 writer.write_all(self.listen_addrs.as_slice())?;
5020 writer.write_all(self.observed_addr.as_slice())?;
5021 writer.write_all(self.identify.as_slice())?;
5022 Ok(())
5023 }
5024 fn build(&self) -> Self::Entity {
5025 let mut inner = Vec::with_capacity(self.expected_length());
5026 self.write(&mut inner)
5027 .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
5028 IdentifyMessage::new_unchecked(inner.into())
5029 }
5030}