icydb_core/value/
public.rs

1use crate::types::{
2    Account, Date, Decimal, Duration, Float32, Float64, IntBig, NatBig, Principal, Subaccount,
3    Timestamp, U256, Ulid,
4};
5use crate::value::Value;
6use candid::CandidType;
7use serde::Deserialize;
8
9/// Canonical recursive value carried by public input and output boundaries.
10///
11/// `InputValue` and `OutputValue` remain distinct root types. Their recursive
12/// payload is shared here so Candid and Serde derive one value visitor family.
13#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
14pub enum PublicValue {
15    Account(Account),
16    Blob(Vec<u8>),
17    Bool(bool),
18    Date(Date),
19    Decimal(Decimal),
20    Duration(Duration),
21    Enum(PublicEnumValue),
22    Float32(Float32),
23    Float64(Float64),
24    #[serde(rename = "Int")]
25    Int64(i64),
26    Int128(i128),
27    IntBig(IntBig),
28    List(Vec<Self>),
29    Map(Vec<(Self, Self)>),
30    Null,
31    Principal(Principal),
32    Subaccount(Subaccount),
33    Text(String),
34    Timestamp(Timestamp),
35    #[serde(rename = "Nat")]
36    Nat64(u64),
37    Nat128(u128),
38    NatBig(NatBig),
39    Ulid(Ulid),
40    Unit,
41    U256(U256),
42}
43
44impl PublicValue {
45    /// Render one public value into the stable row-projection text form.
46    #[must_use]
47    pub fn render_text(&self) -> String {
48        match self {
49            Self::Account(value) => value.to_string(),
50            Self::Blob(value) => render_blob_value(value),
51            Self::Bool(value) => value.to_string(),
52            Self::Date(value) => value.to_string(),
53            Self::Decimal(value) => value.to_string(),
54            Self::Duration(value) => render_duration_value(value.as_millis()),
55            Self::Enum(value) => render_enum(value),
56            Self::Float32(value) => value.to_string(),
57            Self::Float64(value) => value.to_string(),
58            Self::Int64(value) => value.to_string(),
59            Self::Int128(value) => value.to_string(),
60            Self::IntBig(value) => value.to_string(),
61            Self::List(items) => render_list_value(items),
62            Self::Map(entries) => render_map_value(entries),
63            Self::Null => "null".to_string(),
64            Self::Principal(value) => value.to_string(),
65            Self::Subaccount(value) => value.to_string(),
66            Self::Text(value) => value.clone(),
67            Self::Timestamp(value) => value.as_millis().to_string(),
68            Self::Nat64(value) => value.to_string(),
69            Self::Nat128(value) => value.to_string(),
70            Self::NatBig(value) => value.to_string(),
71            Self::Ulid(value) => value.to_string(),
72            Self::Unit => "()".to_string(),
73            Self::U256(value) => value.to_string(),
74        }
75    }
76
77    pub(crate) fn try_into_runtime_non_enum(self) -> Option<Value> {
78        Some(match self {
79            Self::Account(value) => Value::Account(value),
80            Self::Blob(value) => Value::Blob(value),
81            Self::Bool(value) => Value::Bool(value),
82            Self::Date(value) => Value::Date(value),
83            Self::Decimal(value) => Value::Decimal(value),
84            Self::Duration(value) => Value::Duration(value),
85            Self::Enum(_) => return None,
86            Self::Float32(value) => Value::Float32(value),
87            Self::Float64(value) => Value::Float64(value),
88            Self::Int64(value) => Value::Int64(value),
89            Self::Int128(value) => Value::Int128(value),
90            Self::IntBig(value) => Value::IntBig(value),
91            Self::List(values) => Value::List(
92                values
93                    .into_iter()
94                    .map(Self::try_into_runtime_non_enum)
95                    .collect::<Option<Vec<_>>>()?,
96            ),
97            Self::Map(entries) => Value::Map(
98                entries
99                    .into_iter()
100                    .map(|(key, value)| {
101                        Some((
102                            key.try_into_runtime_non_enum()?,
103                            value.try_into_runtime_non_enum()?,
104                        ))
105                    })
106                    .collect::<Option<Vec<_>>>()?,
107            ),
108            Self::Null => Value::Null,
109            Self::Principal(value) => Value::Principal(value),
110            Self::Subaccount(value) => Value::Subaccount(value),
111            Self::Text(value) => Value::Text(value),
112            Self::Timestamp(value) => Value::Timestamp(value),
113            Self::Nat64(value) => Value::Nat64(value),
114            Self::Nat128(value) => Value::Nat128(value),
115            Self::NatBig(value) => Value::NatBig(value),
116            Self::Ulid(value) => Value::Ulid(value),
117            Self::Unit => Value::Unit,
118            Self::U256(value) => Value::U256(value),
119        })
120    }
121
122    pub(crate) fn try_from_runtime_non_enum(value: &Value) -> Option<Self> {
123        Some(match value {
124            Value::Account(value) => Self::Account(*value),
125            Value::Blob(value) => Self::Blob(value.clone()),
126            Value::Bool(value) => Self::Bool(*value),
127            Value::Date(value) => Self::Date(*value),
128            Value::Decimal(value) => Self::Decimal(*value),
129            Value::Duration(value) => Self::Duration(*value),
130            Value::Enum(_) => return None,
131            Value::Float32(value) => Self::Float32(*value),
132            Value::Float64(value) => Self::Float64(*value),
133            Value::Int64(value) => Self::Int64(*value),
134            Value::Int128(value) => Self::Int128(*value),
135            Value::IntBig(value) => Self::IntBig(value.clone()),
136            Value::List(values) => Self::List(
137                values
138                    .iter()
139                    .map(Self::try_from_runtime_non_enum)
140                    .collect::<Option<Vec<_>>>()?,
141            ),
142            Value::Map(entries) => Self::Map(
143                entries
144                    .iter()
145                    .map(|(key, value)| {
146                        Some((
147                            Self::try_from_runtime_non_enum(key)?,
148                            Self::try_from_runtime_non_enum(value)?,
149                        ))
150                    })
151                    .collect::<Option<Vec<_>>>()?,
152            ),
153            Value::Null => Self::Null,
154            Value::Principal(value) => Self::Principal(*value),
155            Value::Subaccount(value) => Self::Subaccount(*value),
156            Value::Text(value) => Self::Text(value.clone()),
157            Value::Timestamp(value) => Self::Timestamp(*value),
158            Value::Nat64(value) => Self::Nat64(*value),
159            Value::Nat128(value) => Self::Nat128(*value),
160            Value::NatBig(value) => Self::NatBig(value.clone()),
161            Value::Ulid(value) => Self::Ulid(*value),
162            Value::Unit => Self::Unit,
163            Value::U256(value) => Self::U256(*value),
164        })
165    }
166}
167
168/// Enum metadata shared by public input and output values.
169#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
170pub struct PublicEnumValue {
171    variant: String,
172    path: Option<String>,
173    payload: Option<Box<PublicValue>>,
174}
175
176impl PublicEnumValue {
177    /// Build enum metadata for caller-authored input.
178    #[must_use]
179    pub fn new(variant: &str, path: Option<&str>) -> Self {
180        Self {
181            variant: variant.to_string(),
182            path: path.map(ToString::to_string),
183            payload: None,
184        }
185    }
186
187    /// Build enum metadata whose type is resolved from its expected contract.
188    #[must_use]
189    pub fn loose(variant: impl Into<String>) -> Self {
190        Self {
191            variant: variant.into(),
192            path: None,
193            payload: None,
194        }
195    }
196
197    /// Attach one unresolved public payload value.
198    #[must_use]
199    pub fn with_payload(mut self, payload: PublicValue) -> Self {
200        self.payload = Some(Box::new(payload));
201        self
202    }
203
204    /// Return the enum variant name.
205    #[must_use]
206    pub const fn variant(&self) -> &str {
207        self.variant.as_str()
208    }
209
210    /// Return the optional schema-visible type path.
211    #[must_use]
212    pub fn path(&self) -> Option<&str> {
213        self.path.as_deref()
214    }
215
216    /// Return the optional recursive payload.
217    #[must_use]
218    pub fn payload(&self) -> Option<&PublicValue> {
219        self.payload.as_deref()
220    }
221
222    pub(crate) fn from_catalog_parts(
223        variant: &str,
224        path: &str,
225        payload: Option<PublicValue>,
226    ) -> Self {
227        Self {
228            variant: variant.to_string(),
229            path: Some(path.to_string()),
230            payload: payload.map(Box::new),
231        }
232    }
233
234    /// Consume enum metadata and its payload without copying.
235    #[must_use]
236    pub fn into_parts(self) -> (String, Option<String>, Option<PublicValue>) {
237        (
238            self.variant,
239            self.path,
240            self.payload.map(|payload| *payload),
241        )
242    }
243}
244
245fn render_blob_value(bytes: &[u8]) -> String {
246    let mut rendered = String::from("0x");
247    rendered.push_str(encode_hex_lower(bytes).as_str());
248    rendered
249}
250
251fn encode_hex_lower(bytes: &[u8]) -> String {
252    const HEX: &[u8; 16] = b"0123456789abcdef";
253
254    let mut rendered = String::with_capacity(bytes.len().saturating_mul(2));
255    for byte in bytes {
256        rendered.push(char::from(HEX[usize::from(byte >> 4)]));
257        rendered.push(char::from(HEX[usize::from(byte & 0x0f)]));
258    }
259    rendered
260}
261
262fn render_duration_value(millis: u64) -> String {
263    let mut rendered = millis.to_string();
264    rendered.push_str("ms");
265    rendered
266}
267
268fn render_list_value(items: &[PublicValue]) -> String {
269    let mut rendered = String::from("[");
270    for (index, item) in items.iter().enumerate() {
271        if index != 0 {
272            rendered.push_str(", ");
273        }
274        rendered.push_str(item.render_text().as_str());
275    }
276    rendered.push(']');
277    rendered
278}
279
280fn render_map_value(entries: &[(PublicValue, PublicValue)]) -> String {
281    let mut rendered = String::from("{");
282    for (index, (key, value)) in entries.iter().enumerate() {
283        if index != 0 {
284            rendered.push_str(", ");
285        }
286        rendered.push_str(key.render_text().as_str());
287        rendered.push_str(": ");
288        rendered.push_str(value.render_text().as_str());
289    }
290    rendered.push('}');
291    rendered
292}
293
294fn render_enum(value: &PublicEnumValue) -> String {
295    let mut rendered = String::new();
296    if let Some(path) = value.path() {
297        rendered.push_str(path);
298        rendered.push_str("::");
299    }
300    rendered.push_str(value.variant());
301    if let Some(payload) = value.payload() {
302        rendered.push('(');
303        rendered.push_str(payload.render_text().as_str());
304        rendered.push(')');
305    }
306    rendered
307}
icydb_core/value/public.rs

icydb_core/value/
public.rs
