massa_models/
types.rs

1// Copyright (c) 2022 MASSA LABS <info@massa.net>
2
3#![allow(missing_docs)]
4
5use massa_serialization::{Deserializer, SerializeError, Serializer};
6use nom::bytes::complete::take;
7use nom::{
8    error::{ContextError, ParseError},
9    IResult,
10};
11use serde::{Deserialize, Serialize};
12
13/// Trait marking a structure that supports another one (V) being applied to it
14pub trait Applicable<V> {
15    /// apply changes from other to mutable self
16    fn apply(&mut self, _: V);
17}
18
19/// Enumeration representing set/update/delete change on a value T
20#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
21pub enum SetUpdateOrDelete<T: Default + Applicable<V>, V: Applicable<V> + Clone> {
22    /// Sets the value T a new absolute value T
23    Set(T),
24
25    /// Applies an update V to an existing value T.
26    /// If the value T doesn't exist:
27    /// a `new_t = T::default()` is created,
28    /// the update V is applied to it,
29    /// and the enumeration is changed to `SetUpdateOrDelete::Set(new_t)`
30    Update(V),
31
32    /// Deletes the value T
33    Delete,
34}
35
36pub struct SetUpdateOrDeleteDeserializer<
37    T: Default + Applicable<V>,
38    V: Applicable<V> + Clone,
39    DT: Deserializer<T>,
40    DV: Deserializer<V>,
41> {
42    inner_deserializer_set: DT,
43    inner_deserializer_update: DV,
44    phantom_t: std::marker::PhantomData<T>,
45    phantom_v: std::marker::PhantomData<V>,
46}
47
48impl<
49        T: Default + Applicable<V>,
50        V: Applicable<V> + Clone,
51        DT: Deserializer<T>,
52        DV: Deserializer<V>,
53    > SetUpdateOrDeleteDeserializer<T, V, DT, DV>
54{
55    pub fn new(inner_deserializer_set: DT, inner_deserializer_update: DV) -> Self {
56        Self {
57            inner_deserializer_set,
58            inner_deserializer_update,
59            phantom_t: std::marker::PhantomData,
60            phantom_v: std::marker::PhantomData,
61        }
62    }
63}
64
65impl<
66        T: Default + Applicable<V>,
67        V: Applicable<V> + Clone,
68        DT: Deserializer<T>,
69        DV: Deserializer<V>,
70    > Deserializer<SetUpdateOrDelete<T, V>> for SetUpdateOrDeleteDeserializer<T, V, DT, DV>
71{
72    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
73        &self,
74        buffer: &'a [u8],
75    ) -> IResult<&'a [u8], SetUpdateOrDelete<T, V>, E> {
76        let (rest0, buffer0) = take(1usize)(buffer)?;
77        match buffer0[0] {
78            0 => {
79                let (rest, value) = self.inner_deserializer_set.deserialize(rest0)?;
80                Ok((rest, SetUpdateOrDelete::Set(value)))
81            }
82            1 => {
83                let (rest, value) = self.inner_deserializer_update.deserialize(rest0)?;
84                Ok((rest, SetUpdateOrDelete::Update(value)))
85            }
86            2 => Ok((rest0, SetUpdateOrDelete::Delete)),
87            _ => Err(nom::Err::Error(ParseError::from_error_kind(
88                buffer,
89                nom::error::ErrorKind::Digit,
90            ))),
91        }
92    }
93}
94
95pub struct SetUpdateOrDeleteSerializer<
96    T: Default + Applicable<V>,
97    V: Applicable<V> + Clone,
98    ST: Serializer<T>,
99    SV: Serializer<V>,
100> {
101    inner_serializer_set: ST,
102    inner_serializer_update: SV,
103    phantom_t: std::marker::PhantomData<T>,
104    phantom_v: std::marker::PhantomData<V>,
105}
106
107impl<
108        T: Default + Applicable<V>,
109        V: Applicable<V> + Clone,
110        ST: Serializer<T>,
111        SV: Serializer<V>,
112    > SetUpdateOrDeleteSerializer<T, V, ST, SV>
113{
114    pub fn new(inner_serializer_set: ST, inner_serializer_update: SV) -> Self {
115        Self {
116            inner_serializer_set,
117            inner_serializer_update,
118            phantom_t: std::marker::PhantomData,
119            phantom_v: std::marker::PhantomData,
120        }
121    }
122}
123
124impl<
125        T: Default + Applicable<V>,
126        V: Applicable<V> + Clone,
127        ST: Serializer<T>,
128        SV: Serializer<V>,
129    > Serializer<SetUpdateOrDelete<T, V>> for SetUpdateOrDeleteSerializer<T, V, ST, SV>
130{
131    fn serialize(
132        &self,
133        value: &SetUpdateOrDelete<T, V>,
134        buffer: &mut Vec<u8>,
135    ) -> Result<(), SerializeError> {
136        match value {
137            SetUpdateOrDelete::Set(value) => {
138                buffer.push(0);
139                self.inner_serializer_set.serialize(value, buffer)?;
140                Ok(())
141            }
142            SetUpdateOrDelete::Update(value) => {
143                buffer.push(1);
144                self.inner_serializer_update.serialize(value, buffer)?;
145                Ok(())
146            }
147            SetUpdateOrDelete::Delete => {
148                buffer.push(2);
149                Ok(())
150            }
151        }
152    }
153}
154
155/// Support applying another `SetUpdateOrDelete` to self
156impl<T: Default + Applicable<V>, V: Applicable<V>> Applicable<SetUpdateOrDelete<T, V>>
157    for SetUpdateOrDelete<T, V>
158where
159    V: Clone,
160{
161    fn apply(&mut self, other: SetUpdateOrDelete<T, V>) {
162        match other {
163            // the other SetUpdateOrDelete sets a new absolute value => force it on self
164            v @ SetUpdateOrDelete::Set(_) => *self = v,
165
166            // the other SetUpdateOrDelete updates the value
167            SetUpdateOrDelete::Update(u) => match self {
168                // if self currently sets an absolute value, apply other to that value
169                SetUpdateOrDelete::Set(cur) => cur.apply(u),
170
171                // if self currently updates a value, apply the updates of the other to that update
172                SetUpdateOrDelete::Update(cur) => cur.apply(u),
173
174                // if self currently deletes a value,
175                // create a new default value, apply other's updates to it and make self set it as an absolute new value
176                SetUpdateOrDelete::Delete => {
177                    let mut res = T::default();
178                    res.apply(u);
179                    *self = SetUpdateOrDelete::Set(res);
180                }
181            },
182
183            // the other SetUpdateOrDelete deletes a value => force self to delete it as well
184            v @ SetUpdateOrDelete::Delete => *self = v,
185        }
186    }
187}
188
189/// `Enum` representing a set/delete change on a value T
190#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
191pub enum SetOrDelete<T: Clone> {
192    /// sets a new absolute value T
193    Set(T),
194
195    /// deletes the value
196    Delete,
197}
198
199pub struct SetOrDeleteDeserializer<T: Clone, DT: Deserializer<T>> {
200    inner_deserializer: DT,
201    phantom_t: std::marker::PhantomData<T>,
202}
203
204impl<T: Clone, DT: Deserializer<T>> SetOrDeleteDeserializer<T, DT> {
205    pub fn new(inner_deserializer: DT) -> Self {
206        Self {
207            inner_deserializer,
208            phantom_t: std::marker::PhantomData,
209        }
210    }
211}
212
213impl<T: Clone, DT: Deserializer<T>> Deserializer<SetOrDelete<T>>
214    for SetOrDeleteDeserializer<T, DT>
215{
216    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
217        &self,
218        buffer: &'a [u8],
219    ) -> IResult<&'a [u8], SetOrDelete<T>, E> {
220        let (rest0, buffer0) = take(1usize)(buffer)?;
221        match buffer0[0] {
222            0 => {
223                let (rest, value) = self.inner_deserializer.deserialize(rest0)?;
224                Ok((rest, SetOrDelete::Set(value)))
225            }
226            1 => Ok((rest0, SetOrDelete::Delete)),
227            _ => Err(nom::Err::Error(ParseError::from_error_kind(
228                buffer,
229                nom::error::ErrorKind::Digit,
230            ))),
231        }
232    }
233}
234
235pub struct SetOrDeleteSerializer<T: Clone, ST: Serializer<T>> {
236    inner_serializer: ST,
237    phantom_t: std::marker::PhantomData<T>,
238}
239
240impl<T: Clone, ST: Serializer<T>> SetOrDeleteSerializer<T, ST> {
241    pub fn new(inner_serializer: ST) -> Self {
242        Self {
243            inner_serializer,
244            phantom_t: std::marker::PhantomData,
245        }
246    }
247}
248
249impl<T: Clone, ST: Serializer<T>> Serializer<SetOrDelete<T>> for SetOrDeleteSerializer<T, ST> {
250    fn serialize(
251        &self,
252        value: &SetOrDelete<T>,
253        buffer: &mut Vec<u8>,
254    ) -> Result<(), SerializeError> {
255        match value {
256            SetOrDelete::Set(value) => {
257                buffer.push(0);
258                self.inner_serializer.serialize(value, buffer)?;
259                Ok(())
260            }
261            SetOrDelete::Delete => {
262                buffer.push(1);
263                Ok(())
264            }
265        }
266    }
267}
268
269/// allows applying another `SetOrDelete` to the current one
270impl<T: Clone> Applicable<SetOrDelete<T>> for SetOrDelete<T> {
271    fn apply(&mut self, other: Self) {
272        *self = other;
273    }
274}
275
276/// represents a set/keep change
277#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
278pub enum SetOrKeep<T: Clone> {
279    /// sets a new absolute value T
280    Set(T),
281
282    /// keeps the existing value
283    Keep,
284}
285
286pub struct SetOrKeepDeserializer<T: Clone, DT: Deserializer<T>> {
287    inner_deserializer: DT,
288    phantom_t: std::marker::PhantomData<T>,
289}
290
291impl<T: Clone, DT: Deserializer<T>> SetOrKeepDeserializer<T, DT> {
292    pub fn new(inner_deserializer: DT) -> Self {
293        Self {
294            inner_deserializer,
295            phantom_t: std::marker::PhantomData,
296        }
297    }
298}
299
300impl<T: Clone, DT: Deserializer<T>> Deserializer<SetOrKeep<T>> for SetOrKeepDeserializer<T, DT> {
301    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
302        &self,
303        buffer: &'a [u8],
304    ) -> IResult<&'a [u8], SetOrKeep<T>, E> {
305        let (rest0, buffer0) = take(1usize)(buffer)?;
306        match buffer0[0] {
307            0 => {
308                let (rest, value) = self.inner_deserializer.deserialize(rest0)?;
309                Ok((rest, SetOrKeep::Set(value)))
310            }
311            1 => Ok((rest0, SetOrKeep::Keep)),
312            _ => Err(nom::Err::Error(ParseError::from_error_kind(
313                buffer,
314                nom::error::ErrorKind::Digit,
315            ))),
316        }
317    }
318}
319
320pub struct SetOrKeepSerializer<T: Clone, ST: Serializer<T>> {
321    inner_serializer: ST,
322    phantom_t: std::marker::PhantomData<T>,
323}
324
325impl<T: Clone, ST: Serializer<T>> SetOrKeepSerializer<T, ST> {
326    pub fn new(inner_serializer: ST) -> Self {
327        Self {
328            inner_serializer,
329            phantom_t: std::marker::PhantomData,
330        }
331    }
332}
333
334impl<T: Clone, ST: Serializer<T>> Serializer<SetOrKeep<T>> for SetOrKeepSerializer<T, ST> {
335    fn serialize(&self, value: &SetOrKeep<T>, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
336        match value {
337            SetOrKeep::Set(value) => {
338                buffer.push(0);
339                self.inner_serializer.serialize(value, buffer)?;
340                Ok(())
341            }
342            SetOrKeep::Keep => {
343                buffer.push(1);
344                Ok(())
345            }
346        }
347    }
348}
349
350/// allows applying another `SetOrKeep` to the current one
351impl<T: Clone> Applicable<SetOrKeep<T>> for SetOrKeep<T> {
352    fn apply(&mut self, other: SetOrKeep<T>) {
353        if let v @ SetOrKeep::Set(..) = other {
354            // update the current value only if the other SetOrKeep sets a new one
355            *self = v;
356        }
357    }
358}
359
360impl<T: Clone> SetOrKeep<T> {
361    /// applies the current `SetOrKeep` to a target mutable value
362    pub fn apply_to(self, val: &mut T) {
363        if let SetOrKeep::Set(v) = self {
364            // only change the value if self is setting a new one
365            *val = v;
366        }
367    }
368}
369
370/// By default, `SetOrKeep` keeps the existing value
371impl<T: Clone> Default for SetOrKeep<T> {
372    fn default() -> Self {
373        SetOrKeep::Keep
374    }
375}
massa_models/types.rs

massa_models/
types.rs
