encode_decode/
encode_decode.rs

1pub use binary_codec_sv2::{self, Decodable as Deserialize, Encodable as Serialize, *};
2use core::convert::TryInto;
3pub use derive_codec_sv2::{Decodable as Deserialize, Encodable as Serialize};
4
5// The `Test` struct is expanded using the `Deserialize` and `Serialize` procedural macros.
6// These macros provide the necessary methods for serializing and deserializing the struct.
7//
8// mod impl_parse_decodable_test {
9//     use super::binary_codec_sv2::{
10//         decodable::DecodableField, decodable::FieldMarker, Decodable, Error, SizeHint,
11//     };
12//     use super::*;
13//     impl<'decoder> Decodable<'decoder> for Test {
14//         fn get_structure(data: &[u8]) -> Result<Vec<FieldMarker>, Error> {
15//             let mut fields = Vec::new();
16//             let mut offset = 0;
17//             let a: Vec<FieldMarker> = u32::get_structure(&data[offset..])?;
18//             offset += a.size_hint_(&data, offset)?;
19//             let a = a.try_into()?;
20//             fields.push(a);
21//             let b: Vec<FieldMarker> = u8::get_structure(&data[offset..])?;
22//             offset += b.size_hint_(&data, offset)?;
23//             let b = b.try_into()?;
24//             fields.push(b);
25//             let c: Vec<FieldMarker> = U24::get_structure(&data[offset..])?;
26//             offset += c.size_hint_(&data, offset)?;
27//             let c = c.try_into()?;
28//             fields.push(c);
29//             Ok(fields)
30//         }
31//         fn from_decoded_fields(
32//             mut data: Vec<DecodableField<'decoder>>,
33//         ) -> Result<Self, Error> {
34//             Ok(Self {
35//                 c: U24::from_decoded_fields(
36//                     data.pop().ok_or(Error::NoDecodableFieldPassed)?.into(),
37//                 )?,
38//                 b: u8::from_decoded_fields(
39//                     data.pop().ok_or(Error::NoDecodableFieldPassed)?.into(),
40//                 )?,
41//                 a: u32::from_decoded_fields(
42//                     data.pop().ok_or(Error::NoDecodableFieldPassed)?.into(),
43//                 )?,
44//             })
45//         }
46//     }
47//     impl<'decoder> Test {
48//         pub fn into_static(self) -> Test {
49//             Test {
50//                 a: self.a.clone(),
51//                 b: self.b.clone(),
52//                 c: self.c.clone(),
53//             }
54//         }
55//     }
56//     impl<'decoder> Test {
57//         pub fn as_static(&self) -> Test {
58//             Test {
59//                 a: self.a.clone(),
60//                 b: self.b.clone(),
61//                 c: self.c.clone(),
62//             }
63//         }
64//     }
65// }
66// mod impl_parse_encodable_test {
67//     use super::binary_codec_sv2::{encodable::EncodableField, GetSize};
68//     use super::Test;
69//     extern crate alloc;
70//     use alloc::vec::Vec;
71//     impl<'decoder> From<Test> for EncodableField<'decoder> {
72//         fn from(v: Test) -> Self {
73//             let mut fields: Vec<EncodableField> = Vec::new();
74//             let val = v.a;
75//             fields.push(val.into());
76//             let val = v.b;
77//             fields.push(val.into());
78//             let val = v.c;
79//             fields.push(val.into());
80//             Self::Struct(fields)
81//         }
82//     }
83//     impl<'decoder> GetSize for Test {
84//         fn get_size(&self) -> usize {
85//             let mut size = 0;
86//             size += self.a.get_size();
87//             size += self.b.get_size();
88//             size += self.c.get_size();
89//             size
90//         }
91//     }
92// }
93//
94
95#[derive(Clone, Deserialize, Serialize, PartialEq, Debug)]
96struct Test {
97    a: u32,
98    b: u8,
99    c: U24,
100}
101
102fn main() {
103    let expected = Test {
104        a: 456,
105        b: 9,
106        c: 67_u32.try_into().unwrap(),
107    };
108
109    // `to_bytes` serves as the entry point to the `binary_sv2` crate. It acts as a serializer that
110    // converts the struct into bytes.
111    let mut bytes = to_bytes(expected.clone()).unwrap();
112
113    // `from_bytes` is a deserializer that interprets the bytes and reconstructs the original
114    // struct.
115    let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
116
117    assert_eq!(deserialized, expected);
118}
encode_decode/encode_decode.rs

encode_decode/
encode_decode.rs
