ixc_schema/state_object/
key.rs

1use crate::buffer::{Reader, ReverseSliceWriter, Writer, WriterFactory};
2use crate::decoder::DecodeError;
3use crate::encoder::EncodeError;
4use crate::mem::MemoryManager;
5use crate::state_object::value::ObjectValue;
6use crate::state_object::KeyFieldValue;
7
8/// Encode an object key with the given prefix.
9pub fn encode_object_key<'a, 'b, K: ObjectKey>(prefix: &[u8], key: &K::In<'a>, writer_factory: &'b dyn WriterFactory) -> Result<&'b [u8], EncodeError> {
10    let out_size = <K as ObjectKey>::out_size(key) + prefix.len();
11    let mut writer = writer_factory.new_reverse(out_size)?;
12    <K as ObjectKey>::encode(key, &mut writer)?;
13    // write the prefix last because we are encoding in reverse order
14    writer.write(prefix)?;
15    Ok(writer.finish())
16}
17
18/// Decode an object key. This function assumes that the input has already had any prefix stripped.
19pub fn decode_object_key<'a, K: ObjectKey>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<K::Out<'a>, DecodeError> {
20    <K as ObjectKey>::decode(input, memory_manager)
21}
22
23/// This trait is implemented for types that can be used as keys in state objects.
24pub trait ObjectKey: ObjectValue {
25    /// Encode the key.
26    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError>;
27
28    /// Decode the key.
29    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError>;
30
31    /// Compute the output buffer size for the key.
32    fn out_size<'a>(key: &Self::In<'a>) -> usize;
33}
34
35impl ObjectKey for () {
36    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
37        Ok(())
38    }
39
40    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
41        Ok(())
42    }
43
44    fn out_size<'a>(key: &Self::In<'a>) -> usize { 0 }
45}
46
47impl<A: KeyFieldValue> ObjectKey for A {
48    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
49        A::encode_terminal(key, writer)
50    }
51
52    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
53        let mut reader = input;
54        let a = A::decode_terminal(&mut reader, memory_manager)?;
55        reader.is_done()?;
56        Ok(a)
57    }
58
59    fn out_size<'a>(key: &Self::In<'a>) -> usize {
60        A::out_size_terminal(key)
61    }
62}
63
64impl<A: KeyFieldValue> ObjectKey for (A,) {
65    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
66        A::encode(&key.0, writer)
67    }
68
69    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
70        let mut reader = input;
71        let a = A::decode(&mut reader, memory_manager)?;
72        reader.is_done()?;
73        Ok((a,))
74    }
75
76    fn out_size<'a>(key: &Self::In<'a>) -> usize {
77        A::out_size_terminal(&key.0)
78    }
79}
80
81impl<A: KeyFieldValue, B: KeyFieldValue> ObjectKey for (A, B) {
82    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
83        B::encode_terminal(&key.1, writer)?;
84        A::encode(&key.0, writer)
85    }
86
87    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
88        let mut reader = input;
89        let a = A::decode(&mut reader, memory_manager)?;
90        let b = B::decode_terminal(&mut reader, memory_manager)?;
91        reader.is_done()?;
92        Ok((a, b))
93    }
94
95    fn out_size<'a>(key: &Self::In<'a>) -> usize {
96        A::out_size(&key.0) + B::out_size_terminal(&key.1)
97    }
98}
99
100impl<A: KeyFieldValue, B: KeyFieldValue, C: KeyFieldValue> ObjectKey for (A, B, C) {
101    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
102        C::encode_terminal(&key.2, writer)?;
103        B::encode(&key.1, writer)?;
104        A::encode(&key.0, writer)
105    }
106
107    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
108        let mut reader = input;
109        let a = A::decode(&mut reader, memory_manager)?;
110        let b = B::decode(&mut reader, memory_manager)?;
111        let c = C::decode_terminal(&mut reader, memory_manager)?;
112        reader.is_done()?;
113        Ok((a, b, c))
114    }
115
116    fn out_size<'a>(key: &Self::In<'a>) -> usize {
117        A::out_size(&key.0) + B::out_size(&key.1) + C::out_size_terminal(&key.2)
118    }
119}
120
121impl<A: KeyFieldValue, B: KeyFieldValue, C: KeyFieldValue, D: KeyFieldValue> ObjectKey for (A, B, C, D) {
122    fn encode<'a>(key: &Self::In<'a>, writer: &mut ReverseSliceWriter) -> Result<(), EncodeError> {
123        D::encode_terminal(&key.3, writer)?;
124        C::encode(&key.2, writer)?;
125        B::encode(&key.1, writer)?;
126        A::encode(&key.0, writer)
127    }
128
129    fn decode<'a>(input: &'a [u8], memory_manager: &'a MemoryManager) -> Result<Self::Out<'a>, DecodeError> {
130        let mut reader = input;
131        let a = A::decode(&mut reader, memory_manager)?;
132        let b = B::decode(&mut reader, memory_manager)?;
133        let c = C::decode(&mut reader, memory_manager)?;
134        let d = D::decode_terminal(&mut reader, memory_manager)?;
135        reader.is_done()?;
136        Ok((a, b, c, d))
137    }
138
139    fn out_size<'a>(key: &Self::In<'a>) -> usize {
140        A::out_size(&key.0) + B::out_size(&key.1) + C::out_size(&key.2) + D::out_size_terminal(&key.3)
141    }
142}
143
ixc_schema/state_object/key.rs

ixc_schema/state_object/
key.rs
