ixc_schema/state_object/
value.rs

1use crate::binary::encoder::encode_value;
2use crate::buffer::{WriterFactory, Writer};
3use crate::codec::ValueEncodeVisitor;
4use crate::decoder::{DecodeError, Decoder};
5use crate::encoder::{EncodeError, Encoder};
6use crate::fields::FieldTypes;
7use crate::mem::MemoryManager;
8use crate::state_object::field_types::unnamed_struct_type;
9use crate::state_object::value_field::ObjectFieldValue;
10use crate::structs::{StructDecodeVisitor, StructEncodeVisitor, StructType};
11use crate::value::SchemaValue;
12
13/// Encode an object value.
14pub fn encode_object_value<'a, 'b, V: ObjectValue>(value: &V::In<'b>, writer_factory: &'a dyn WriterFactory) -> Result<&'a [u8], EncodeError> {
15    struct Visitor<'c, 'd, U:ObjectValue>(&'c U::In<'d>);
16    impl <'c, 'd, U:ObjectValue> ValueEncodeVisitor for Visitor<'c, 'd, U> {
17        fn encode(&self, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
18            U::encode(self.0, encoder)
19        }
20    }
21    encode_value(&Visitor::<V>(value), writer_factory)
22}
23
24/// Decode an object value.
25pub fn decode_object_value<'a, V: ObjectValue>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<V::Out<'a>, DecodeError> {
26    let mut decoder = crate::binary::decoder::Decoder { buf: input, scope: memory_manager };
27    V::decode(&mut decoder, memory_manager)
28}
29
30/// This trait is implemented for types that can be used as tuples of value fields in state objects.
31pub trait ObjectValue {
32    /// The object value types as field types.
33    type FieldTypes<'a>: FieldTypes;
34    /// The type that is used when inputting object values to functions.
35    type In<'a>;
36    /// The type that is used in function return values.
37    type Out<'a>;
38    /// The associated "pseudo-struct" type for the object value.
39    const PSEUDO_TYPE: StructType<'static>;
40
41    /// Encode each part of the value in reverse order.
42    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError>;
43
44    /// Decode the value from the decoder.
45    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError>;
46}
47
48impl ObjectValue for () {
49    type FieldTypes<'a> = ();
50    type In<'a> = ();
51    type Out<'a> = ();
52    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
53
54    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
55        Ok(())
56    }
57
58    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
59        Ok(())
60    }
61}
62
63impl<A: ObjectFieldValue> ObjectValue for A {
64    type FieldTypes<'a> = (<<A as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type,);
65    type In<'a> = A::In<'a>;
66    type Out<'a> = A::Out<'a>;
67    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
68
69    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
70        struct Visitor<'b, A>(&'b A);
71        unsafe impl <'b, 'a:'b, A: SchemaValue<'a>> StructEncodeVisitor for Visitor<'b, A> {
72            fn encode_field(&self, index: usize, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
73                match index {
74                    0 => <A as SchemaValue<'a>>::encode(&self.0, encoder),
75                    _ =>
76                        Err(EncodeError::UnknownError),
77                }
78            }
79        }
80
81        encoder.encode_struct(&Visitor(value), &Self::PSEUDO_TYPE)
82    }
83
84    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
85        struct Visitor<'a, A: SchemaValue<'a>>(A::DecodeState);
86        unsafe impl <'a, A: SchemaValue<'a>> StructDecodeVisitor<'a> for Visitor<'a, A> {
87            fn decode_field(&mut self, index: usize, decoder: &mut dyn Decoder<'a>) -> Result<(), DecodeError> {
88                match index {
89                    0 => <A as SchemaValue<'a>>::visit_decode_state(&mut self.0, decoder),
90                    _ => Err(DecodeError::UnknownFieldNumber),
91                }
92            }
93        }
94
95        let mut visitor: Visitor<'a, A::Out<'a>> = Visitor(Default::default());
96        decoder.decode_struct(&mut visitor, &Self::PSEUDO_TYPE)?;
97        Ok(<A::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.0, mem)?)
98    }
99}
100
101impl<A: ObjectFieldValue> ObjectValue for (A,) {
102    type FieldTypes<'a> = (<<A as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type,);
103    type In<'a> = (A::In<'a>,);
104    type Out<'a> = (A::Out<'a>,);
105    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
106
107    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
108        struct Visitor<'b, A>(&'b (A,));
109        unsafe impl <'b, 'a:'b, A: SchemaValue<'a>> StructEncodeVisitor for Visitor<'b, A> {
110            fn encode_field(&self, index: usize, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
111                match index {
112                    0 => <A as SchemaValue<'a>>::encode(&self.0.0, encoder),
113                    _ =>
114                        Err(EncodeError::UnknownError),
115                }
116            }
117        }
118
119        encoder.encode_struct(&Visitor(value), &Self::PSEUDO_TYPE)
120    }
121
122    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
123        Ok((<A as ObjectValue>::decode(decoder, mem)?,))
124    }
125}
126
127impl<A: ObjectFieldValue, B: ObjectFieldValue> ObjectValue for (A, B) {
128    type FieldTypes<'a> = (<<A as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<B as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type);
129    type In<'a> = (A::In<'a>, B::In<'a>);
130    type Out<'a> = (A::Out<'a>, B::Out<'a>);
131    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
132
133    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
134        struct EncodeVisitor<'b, A, B>(&'b (A, B));
135        unsafe impl <'b, 'a:'b, A: SchemaValue<'a>, B: SchemaValue<'a>> StructEncodeVisitor for EncodeVisitor<'b, A, B> {
136            fn encode_field(&self, index: usize, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
137                match index {
138                    0 => <A as SchemaValue<'a>>::encode(&self.0.0, encoder),
139                    1 => <B as SchemaValue<'a>>::encode(&self.0.1, encoder),
140                    _ =>
141                        Err(EncodeError::UnknownError),
142                }
143            }
144        }
145
146        encoder.encode_struct(&EncodeVisitor(value), &Self::PSEUDO_TYPE)
147    }
148
149    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
150        struct Visitor<'a, A: SchemaValue<'a>, B: SchemaValue<'a>>(A::DecodeState, B::DecodeState);
151        unsafe impl <'a, A: SchemaValue<'a>, B: SchemaValue<'a>> StructDecodeVisitor<'a> for Visitor<'a, A, B> {
152            fn decode_field(&mut self, index: usize, decoder: &mut dyn Decoder<'a>) -> Result<(), DecodeError> {
153                match index {
154                    0 => <A as SchemaValue<'a>>::visit_decode_state(&mut self.0, decoder),
155                    1 => <B as SchemaValue<'a>>::visit_decode_state(&mut self.1, decoder),
156                    _ => Err(DecodeError::UnknownFieldNumber),
157                }
158            }
159        }
160
161        let mut visitor: Visitor<'a, A::Out<'a>, B::Out<'a>> = Visitor(Default::default(), Default::default());
162        decoder.decode_struct(&mut visitor, &Self::PSEUDO_TYPE)?;
163        Ok((
164            <A::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.0, mem)?,
165            <B::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.1, mem)?,
166        ))
167    }
168}
169
170impl<A: ObjectFieldValue, B: ObjectFieldValue, C: ObjectFieldValue> ObjectValue for (A, B, C) {
171    type FieldTypes<'a> = (<<A as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<B as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<C as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type);
172    type In<'a> = (A::In<'a>, B::In<'a>, C::In<'a>);
173    type Out<'a> = (A::Out<'a>, B::Out<'a>, C::Out<'a>);
174    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
175
176    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
177        struct EncodeVisitor<'b, A, B, C>(&'b (A, B, C));
178        unsafe impl <'b, 'a:'b, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>> StructEncodeVisitor for EncodeVisitor<'b, A, B, C> {
179            fn encode_field(&self, index: usize, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
180                match index {
181                    0 => <A as SchemaValue<'a>>::encode(&self.0.0, encoder),
182                    1 => <B as SchemaValue<'a>>::encode(&self.0.1, encoder),
183                    2 => <C as SchemaValue<'a>>::encode(&self.0.2, encoder),
184                    _ =>
185                        Err(EncodeError::UnknownError),
186                }
187            }
188        }
189
190        encoder.encode_struct(&EncodeVisitor(value), &Self::PSEUDO_TYPE)
191    }
192
193    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
194        struct Visitor<'a, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>>(A::DecodeState, B::DecodeState, C::DecodeState);
195        unsafe impl <'a, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>> StructDecodeVisitor<'a> for Visitor<'a, A, B, C> {
196            fn decode_field(&mut self, index: usize, decoder: &mut dyn Decoder<'a>) -> Result<(), DecodeError> {
197                match index {
198                    0 => <A as SchemaValue<'a>>::visit_decode_state(&mut self.0, decoder),
199                    1 => <B as SchemaValue<'a>>::visit_decode_state(&mut self.1, decoder),
200                    2 => <C as SchemaValue<'a>>::visit_decode_state(&mut self.2, decoder),
201                    _ => Err(DecodeError::UnknownFieldNumber),
202                }
203            }
204        }
205
206        let mut visitor: Visitor<'a, A::Out<'a>, B::Out<'a>, C::Out<'a>> = Visitor(Default::default(), Default::default(), Default::default());
207        decoder.decode_struct(&mut visitor, &Self::PSEUDO_TYPE)?;
208        Ok((
209            <A::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.0, mem)?,
210            <B::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.1, mem)?,
211            <C::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.2, mem)?,
212        ))
213    }
214}
215
216impl<A: ObjectFieldValue, B: ObjectFieldValue, C: ObjectFieldValue, D: ObjectFieldValue> ObjectValue for (A, B, C, D) {
217    type FieldTypes<'a> = (<<A as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<B as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<C as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type, <<D as ObjectFieldValue>::In<'a> as SchemaValue<'a>>::Type);
218    type In<'a> = (A::In<'a>, B::In<'a>, C::In<'a>, D::In<'a>);
219    type Out<'a> = (A::Out<'a>, B::Out<'a>, C::Out<'a>, D::Out<'a>);
220    const PSEUDO_TYPE: StructType<'static> = unnamed_struct_type::<Self::FieldTypes<'static>>();
221
222    fn encode<'a>(value: &Self::In<'a>, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
223        struct EncodeVisitor<'b, A, B, C, D>(&'b (A, B, C, D));
224        unsafe impl <'b, 'a:'b, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>, D: SchemaValue<'a>> StructEncodeVisitor for EncodeVisitor<'b, A, B, C, D> {
225            fn encode_field(&self, index: usize, encoder: &mut dyn Encoder) -> Result<(), EncodeError> {
226                match index {
227                    0 => <A as SchemaValue<'a>>::encode(&self.0.0, encoder),
228                    1 => <B as SchemaValue<'a>>::encode(&self.0.1, encoder),
229                    2 => <C as SchemaValue<'a>>::encode(&self.0.2, encoder),
230                    3 => <D as SchemaValue<'a>>::encode(&self.0.3, encoder),
231                    _ =>
232                        Err(EncodeError::UnknownError),
233                }
234            }
235        }
236
237        encoder.encode_struct(&EncodeVisitor(value), &Self::PSEUDO_TYPE)
238    }
239
240    fn decode<'a>(decoder: &mut dyn Decoder<'a>, mem: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
241        struct Visitor<'a, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>, D: SchemaValue<'a>>(A::DecodeState, B::DecodeState, C::DecodeState, D::DecodeState);
242        unsafe impl <'a, A: SchemaValue<'a>, B: SchemaValue<'a>, C: SchemaValue<'a>, D: SchemaValue<'a>> StructDecodeVisitor<'a> for Visitor<'a, A, B, C, D> {
243            fn decode_field(&mut self, index: usize, decoder: &mut dyn Decoder<'a>) -> Result<(), DecodeError> {
244                match index {
245                    0 => <A as SchemaValue<'a>>::visit_decode_state(&mut self.0, decoder),
246                    1 => <B as SchemaValue<'a>>::visit_decode_state(&mut self.1, decoder),
247                    2 => <C as SchemaValue<'a>>::visit_decode_state(&mut self.2, decoder),
248                    3 => <D as SchemaValue<'a>>::visit_decode_state(&mut self.3, decoder),
249                    _ => Err(DecodeError::UnknownFieldNumber),
250                }
251            }
252        }
253
254        let mut visitor: Visitor<'a, A::Out<'a>, B::Out<'a>, C::Out<'a>, D::Out<'a>> = Visitor(Default::default(), Default::default(), Default::default(), Default::default());
255        decoder.decode_struct(&mut visitor, &Self::PSEUDO_TYPE)?;
256        Ok((
257            <A::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.0, mem)?,
258            <B::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.1, mem)?,
259            <C::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.2, mem)?,
260            <D::Out<'a> as SchemaValue<'a>>::finish_decode_state(visitor.3, mem)?,
261        ))
262    }
263}
264
ixc_schema/state_object/value.rs

ixc_schema/state_object/
value.rs
