encode_decode/
encode_decode.rs

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

encode_decode/
encode_decode.rs
