ixc_schema/state_object/
key_field.rs

1use crate::buffer::{Reader, ReverseSliceWriter, Writer};
2use crate::decoder::DecodeError;
3use crate::encoder::EncodeError;
4use crate::mem::MemoryManager;
5use crate::state_object::value_field::{Bytes, ObjectFieldValue};
6use crate::Str;
7
8/// This trait is implemented for types that can be used as key fields in state objects.
9pub trait KeyFieldValue: ObjectFieldValue {
10    /// Encode the key segment as a non-terminal segment.
11    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError>;
12
13    /// Encode the key segment as the terminal segment.
14    fn encode_terminal<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
15        Self::encode(key, writer)
16    }
17
18    /// Decode the key segment as a non-terminal segment.
19    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError>;
20
21    /// Decode the key segment as the terminal segment.
22    fn decode_terminal<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
23        Self::decode(reader, memory_manager)
24    }
25
26    /// Get the size of the key segment as a non-terminal segment.
27    fn out_size<'a>(key: &Self::In<'a>) -> usize;
28
29    /// Get the size of the key segment as the terminal segment.
30    fn out_size_terminal<'a>(key: &Self::In<'a>) -> usize {
31        Self::out_size(key)
32    }
33}
34
35impl KeyFieldValue for u8 {
36    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
37        writer.write(&[*key])
38    }
39
40    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
41        Ok(reader.read_bytes(1)?[0])
42    }
43
44    fn out_size<'a>(key: &Self::In<'a>) -> usize { 1 }
45}
46
47impl KeyFieldValue for u16 {
48    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
49        writer.write(&key.to_be_bytes())
50    }
51
52    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
53        let bz = reader.read_bytes(2)?;
54        Ok(u16::from_be_bytes(bz.try_into().unwrap()))
55    }
56
57    fn out_size<'a>(key: &Self::In<'a>) -> usize { 2 }
58}
59
60impl KeyFieldValue for u32 {
61    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
62        writer.write(&key.to_be_bytes())
63    }
64
65    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
66        let bz = reader.read_bytes(4)?;
67        Ok(u32::from_be_bytes(bz.try_into().unwrap()))
68    }
69
70    fn out_size<'a>(key: &Self::In<'a>) -> usize { 4 }
71}
72
73impl KeyFieldValue for u64 {
74    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
75        writer.write(&key.to_be_bytes())
76    }
77
78    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
79        let bz = reader.read_bytes(8)?;
80        Ok(u64::from_be_bytes(bz.try_into().unwrap()))
81    }
82
83    fn out_size<'a>(key: &Self::In<'a>) -> usize { 8 }
84}
85
86impl KeyFieldValue for u128 {
87    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
88        writer.write(&key.to_be_bytes())
89    }
90
91    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
92        let bz = reader.read_bytes(16)?;
93        Ok(u128::from_be_bytes(bz.try_into().unwrap()))
94    }
95
96    fn out_size<'a>(key: &Self::In<'a>) -> usize { 16 }
97}
98
99impl KeyFieldValue for i8 {
100    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
101        let x = *key as u8;
102        // flip first bit for ordering
103        writer.write(&[x ^ 0x80])
104    }
105
106    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
107        let x = reader.read_bytes(1)?[0];
108        // flip first bit back
109        Ok((x ^ 0x80) as i8)
110    }
111
112    fn out_size<'a>(key: &Self::In<'a>) -> usize { 1 }
113}
114
115impl KeyFieldValue for i16 {
116    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
117        // flip first bit for ordering
118        let x = *key as u16 ^ 0x8000;
119        writer.write(&x.to_be_bytes())
120    }
121
122    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
123        let x = u16::from_be_bytes(reader.read_bytes(2)?.try_into().unwrap());
124        // flip first bit back
125        Ok((x ^ 0x8000) as i16)
126    }
127
128    fn out_size<'a>(key: &Self::In<'a>) -> usize { 2 }
129}
130
131impl KeyFieldValue for i32 {
132    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
133        let x = *key as u32 ^ 0x80000000;
134        writer.write(&x.to_be_bytes())
135    }
136
137    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
138        let x = u32::from_be_bytes(reader.read_bytes(4)?.try_into().unwrap());
139        Ok((x ^ 0x80000000) as i32)
140    }
141
142
143    fn out_size<'a>(key: &Self::In<'a>) -> usize { 4 }
144}
145
146impl KeyFieldValue for i64 {
147    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
148        let x = *key as u64 ^ 0x8000000000000000;
149        writer.write(&x.to_be_bytes())
150    }
151
152    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
153        let x = u64::from_be_bytes(reader.read_bytes(8)?.try_into().unwrap());
154        Ok((x ^ 0x8000000000000000) as i64)
155    }
156
157    fn out_size<'a>(key: &Self::In<'a>) -> usize { 8 }
158}
159
160impl KeyFieldValue for i128 {
161    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
162        let x = *key as u128 ^ 0x80000000000000000000000000000000;
163        writer.write(&x.to_be_bytes())
164    }
165
166    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
167        let x = u128::from_be_bytes(reader.read_bytes(16)?.try_into().unwrap());
168        Ok((x ^ 0x80000000000000000000000000000000) as i128)
169    }
170
171    fn out_size<'a>(key: &Self::In<'a>) -> usize { 16 }
172}
173
174impl KeyFieldValue for bool {
175    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
176        writer.write(&[*key as u8])
177    }
178
179    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
180        Ok(reader.read_bytes(1)?[0] != 0)
181    }
182
183    fn out_size<'a>(key: &Self::In<'a>) -> usize { 1 }
184}
185
186impl KeyFieldValue for simple_time::Time {
187    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
188        // TODO we only need 12 bytes max
189        <i128 as KeyFieldValue>::encode(&key.unix_nanos(), writer)
190    }
191
192    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
193        <i128 as KeyFieldValue>::decode(reader, memory_manager)
194            .map(simple_time::Time::from_unix_nanos)
195    }
196
197    fn out_size<'a>(key: &Self::In<'a>) -> usize { 12 }
198}
199
200impl KeyFieldValue for simple_time::Duration {
201    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
202        // TODO we only need 12 bytes max
203        <i128 as KeyFieldValue>::encode(&key.nanos(), writer)
204    }
205
206    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
207        <i128 as KeyFieldValue>::decode(reader, memory_manager)
208            .map(simple_time::Duration::from_nanos)
209    }
210
211    fn out_size<'a>(key: &Self::In<'a>) -> usize { 12 }
212}
213
214impl KeyFieldValue for ixc_message_api::AccountID {
215    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
216        let id: u64 = (*key).into();
217        writer.write(&id.to_be_bytes())
218    }
219
220    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
221        let bz = reader.read_bytes(8)?;
222        Ok(ixc_message_api::AccountID::new(u64::from_be_bytes(bz.try_into().unwrap())))
223    }
224
225    fn out_size<'a>(key: &Self::In<'a>) -> usize { 8 }
226}
227
228impl KeyFieldValue for Str {
229    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
230        // write null terminator
231        writer.write(&[0]);
232        writer.write(key.as_bytes())
233    }
234
235    fn encode_terminal<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
236        // no null terminator needed
237        writer.write(key.as_bytes())
238    }
239
240    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
241        let mut i = 0;
242        while reader[i] != 0 {
243            i += 1;
244        }
245        let s = core::str::from_utf8(&reader[..i])
246            .map_err(|_| DecodeError::InvalidUtf8)?;
247        *reader = &reader[i + 1..];
248        Ok(s)
249    }
250
251    fn decode_terminal<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
252        let s = core::str::from_utf8(reader)
253            .map_err(|_| DecodeError::InvalidUtf8)?;
254        *reader = &reader[s.len()..];
255        Ok(s)
256    }
257
258    fn out_size<'a>(key: &Self::In<'a>) -> usize { key.len() + 1 }
259
260    fn out_size_terminal<'a>(key: &Self::In<'a>) -> usize { key.len() }
261}
262
263impl KeyFieldValue for Bytes {
264    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
265        writer.write(key)?;
266        // write length
267        writer.write(&(key.len() as u32).to_be_bytes())
268    }
269
270    fn encode_terminal<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
271        writer.write(key)
272    }
273
274    fn decode<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
275        let len = u32::from_be_bytes(reader.read_bytes(4)?.try_into().unwrap()) as usize;
276        let key = reader.read_bytes(len)?;
277        Ok(key)
278    }
279
280    fn decode_terminal<'a>(reader: &mut &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
281        Ok(reader)
282    }
283
284    fn out_size<'a>(key: &Self::In<'a>) -> usize { key.len() + 4 }
285    fn out_size_terminal<'a>(key: &Self::In<'a>) -> usize { key.len() }
286}
ixc_schema/state_object/key_field.rs

ixc_schema/state_object/
key_field.rs
