serialization.rs (5987B)
1 //! Closed value codecs. Successful decoding still proves no stock authority. 2 use super::{ 3 ObligationBacking, PhysicalBalances, PoolBalances, PoolSnapshot, PoolUnit, StockTicks, 4 }; 5 use crate::{PoolId, Sequence, listing::MeasurementUnit}; 6 use core::fmt; 7 use serde::{Deserialize, Deserializer, Serialize, Serializer, de}; 8 9 #[derive(Clone, Copy)] 10 struct Scale(u8); 11 impl Serialize for Scale { 12 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 13 serializer.collect_str(&self.0) 14 } 15 } 16 impl<'de> Deserialize<'de> for Scale { 17 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 18 struct Visitor; 19 impl de::Visitor<'_> for Visitor { 20 type Value = Scale; 21 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 22 f.write_str("one canonical pool precision string from0 through6") 23 } 24 fn visit_str<E: de::Error>(self, value: &str) -> Result<Scale, E> { 25 match value.as_bytes() { 26 [byte @ b'0'..=b'6'] => Ok(Scale(byte - b'0')), 27 _ => Err(E::custom("invalid pool precision")), 28 } 29 } 30 } 31 deserializer.deserialize_str(Visitor) 32 } 33 } 34 #[derive(Serialize, Deserialize)] 35 #[serde(deny_unknown_fields)] 36 struct Unit { 37 unit: MeasurementUnit, 38 scale: Scale, 39 } 40 impl Serialize for PoolUnit { 41 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 42 Unit { 43 unit: self.unit(), 44 scale: Scale(self.scale()), 45 } 46 .serialize(serializer) 47 } 48 } 49 impl<'de> Deserialize<'de> for PoolUnit { 50 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 51 let wire: Unit = object(deserializer)?; 52 Self::new(wire.unit, wire.scale.0).map_err(de::Error::custom) 53 } 54 } 55 #[derive(Serialize, Deserialize)] 56 #[serde(deny_unknown_fields)] 57 struct Physical { 58 available: StockTicks, 59 preparatory_hold: StockTicks, 60 committed_hold: StockTicks, 61 physical_quarantine: StockTicks, 62 consumed: StockTicks, 63 waste: StockTicks, 64 removed: StockTicks, 65 } 66 impl Serialize for PhysicalBalances { 67 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 68 Physical { 69 available: self.available, 70 preparatory_hold: self.preparatory_hold, 71 committed_hold: self.committed_hold, 72 physical_quarantine: self.physical_quarantine, 73 consumed: self.consumed, 74 waste: self.waste, 75 removed: self.removed, 76 } 77 .serialize(serializer) 78 } 79 } 80 impl<'de> Deserialize<'de> for PhysicalBalances { 81 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 82 let v: Physical = object(deserializer)?; 83 Ok(Self { 84 available: v.available, 85 preparatory_hold: v.preparatory_hold, 86 committed_hold: v.committed_hold, 87 physical_quarantine: v.physical_quarantine, 88 consumed: v.consumed, 89 waste: v.waste, 90 removed: v.removed, 91 }) 92 } 93 } 94 #[derive(Serialize, Deserialize)] 95 #[serde(deny_unknown_fields)] 96 struct Balances { 97 introduced: StockTicks, 98 physical: PhysicalBalances, 99 } 100 impl Serialize for PoolBalances { 101 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 102 Balances { 103 introduced: self.introduced(), 104 physical: self.physical(), 105 } 106 .serialize(serializer) 107 } 108 } 109 impl<'de> Deserialize<'de> for PoolBalances { 110 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 111 let v: Balances = object(deserializer)?; 112 Self::new(v.introduced, v.physical).map_err(de::Error::custom) 113 } 114 } 115 #[derive(Serialize, Deserialize)] 116 #[serde(deny_unknown_fields)] 117 struct Backing { 118 remaining: StockTicks, 119 backed: StockTicks, 120 deficit: StockTicks, 121 } 122 impl Serialize for ObligationBacking { 123 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 124 Backing { 125 remaining: self.remaining(), 126 backed: self.backed(), 127 deficit: self.deficit(), 128 } 129 .serialize(serializer) 130 } 131 } 132 impl<'de> Deserialize<'de> for ObligationBacking { 133 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 134 let value: Backing = object(deserializer)?; 135 Self::new(value.remaining, value.backed, value.deficit).map_err(de::Error::custom) 136 } 137 } 138 139 #[derive(Serialize, Deserialize)] 140 #[serde(deny_unknown_fields)] 141 struct Snapshot { 142 id: PoolId, 143 unit: PoolUnit, 144 balances: PoolBalances, 145 version: Sequence, 146 } 147 impl Serialize for PoolSnapshot { 148 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 149 Snapshot { 150 id: self.id(), 151 unit: self.unit(), 152 balances: self.balances(), 153 version: self.version(), 154 } 155 .serialize(serializer) 156 } 157 } 158 impl<'de> Deserialize<'de> for PoolSnapshot { 159 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { 160 let v: Snapshot = object(deserializer)?; 161 Ok(Self::new(v.id, v.unit, v.balances, v.version)) 162 } 163 } 164 165 pub(super) fn object<'de, D: Deserializer<'de>, T: Deserialize<'de>>( 166 deserializer: D, 167 ) -> Result<T, D::Error> { 168 struct Visitor<T>(core::marker::PhantomData<T>); 169 impl<'de, T: Deserialize<'de>> de::Visitor<'de> for Visitor<T> { 170 type Value = T; 171 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 172 f.write_str("a closed stock value object") 173 } 174 fn visit_map<A: de::MapAccess<'de>>(self, map: A) -> Result<T, A::Error> { 175 T::deserialize(de::value::MapAccessDeserializer::new(map)) 176 } 177 } 178 deserializer.deserialize_map(Visitor(core::marker::PhantomData)) 179 }