looking_glass/
owned.rs

1use crate::typed::Typed;
2use crate::*;
3pub use bytes::Bytes;
4pub use smol_str::SmolStr;
5
6/// An enum containing an owned copy of a [`Value`]
7#[derive(Clone, Debug)]
8pub enum OwnedValue<'ty> {
9    U64(u64),
10    U32(u32),
11    U16(u16),
12    U8(u8),
13    I64(i64),
14    I32(i32),
15    I16(i16),
16    I8(i8),
17    F32(f32),
18    F64(f64),
19    Bool(bool),
20    String(String),
21    Vec(Box<dyn VecInstance<'ty> + 'ty>),
22    Struct(Box<dyn StructInstance<'ty> + 'ty>),
23    Enum(Box<dyn EnumInstance<'ty> + 'ty>),
24    Bytes(Bytes),
25    Option(Box<dyn OptionInstance<'ty> + 'ty>),
26}
27
28impl<'ty> PartialEq for OwnedValue<'ty> {
29    fn eq(&self, other: &Self) -> bool {
30        use OwnedValue::*;
31        match (self, other) {
32            (U64(l), U64(r)) => l == r,
33            (U32(l), U32(r)) => l == r,
34            (U16(l), U16(r)) => l == r,
35            (U8(l), U8(r)) => l == r,
36            (I64(l), I64(r)) => l == r,
37            (I32(l), I32(r)) => l == r,
38            (I16(l), I16(r)) => l == r,
39            (I8(l), I8(r)) => l == r,
40            (F32(l), F32(r)) => l == r,
41            (F64(l), F64(r)) => l == r,
42            (Bool(l), Bool(r)) => l == r,
43            (String(l), String(r)) => l == r,
44            (Vec(l), Vec(r)) => l == r,
45            (Struct(l), Struct(r)) => l == r,
46            (Enum(l), Enum(r)) => l == r,
47            (Bytes(l), Bytes(r)) => l == r,
48            _ => false,
49        }
50    }
51}
52
53impl<'v> OwnedValue<'v> {
54    /// Returns a [`Value`] as a reference to the [`OwnedValue`]
55    pub fn as_ref<'val>(&'val self) -> Value<'val, 'v>
56    where
57        'v: 'val,
58    {
59        match self {
60            OwnedValue::U64(a) => a.as_value(),
61            OwnedValue::U32(a) => a.as_value(),
62            OwnedValue::U16(a) => a.as_value(),
63            OwnedValue::U8(a) => a.as_value(),
64            OwnedValue::I64(a) => a.as_value(),
65            OwnedValue::I32(a) => a.as_value(),
66            OwnedValue::I16(a) => a.as_value(),
67            OwnedValue::I8(a) => a.as_value(),
68            OwnedValue::F32(a) => a.as_value(),
69            OwnedValue::F64(a) => a.as_value(),
70            OwnedValue::Bool(a) => a.as_value(),
71            OwnedValue::String(a) => a.as_value(),
72            OwnedValue::Vec(a) => Value::from_vec(a.as_ref()),
73            OwnedValue::Struct(a) => Value::from_struct(a.as_ref()),
74            OwnedValue::Enum(a) => Value::from_enum(a.as_ref()),
75            OwnedValue::Bytes(b) => b.as_value(),
76            OwnedValue::Option(o) => Value::from_option(o.as_ref()),
77        }
78    }
79}
80
81impl<'ty> From<String> for OwnedValue<'ty> {
82    fn from(val: String) -> OwnedValue<'ty> {
83        OwnedValue::String(val)
84    }
85}
86
87#[derive(Clone)]
88pub enum CowValue<'val, 'ty> {
89    Owned(OwnedValue<'ty>),
90    Ref(Value<'val, 'ty>),
91}
92
93impl<'val, 'ty> From<Value<'val, 'ty>> for CowValue<'val, 'ty> {
94    fn from(v: Value<'val, 'ty>) -> Self {
95        Self::Ref(v)
96    }
97}
98
99impl<'val, 'ty> From<OwnedValue<'ty>> for CowValue<'val, 'ty> {
100    fn from(v: OwnedValue<'ty>) -> Self {
101        Self::Owned(v)
102    }
103}
104
105impl<'val, 'ty> CowValue<'val, 'ty> {
106    pub fn slow_eq<'c, 'd>(&self, other: &CowValue<'c, 'd>) -> bool {
107        self.as_ref().slow_eq(&other.as_ref())
108    }
109}
110
111impl std::fmt::Debug for CowValue<'_, '_> {
112    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
113        match self {
114            CowValue::Owned(o) => std::fmt::Debug::fmt(&o, f),
115            CowValue::Ref(r) => std::fmt::Debug::fmt(&r, f),
116        }
117    }
118}
119
120impl PartialEq for CowValue<'_, '_> {
121    fn eq(&self, other: &Self) -> bool {
122        self.as_ref() == other.as_ref()
123    }
124}
125
126impl<'val, 'ty> CowValue<'val, 'ty> {
127    pub fn as_ref(&'val self) -> Value<'val, 'ty> {
128        match self {
129            CowValue::Owned(owned) => owned.as_ref(),
130            CowValue::Ref(r) => r.clone(),
131        }
132    }
133
134    pub fn to_owned(&self) -> OwnedValue<'ty> {
135        match self {
136            CowValue::Owned(owned) => owned.clone(),
137            CowValue::Ref(r) => r.to_owned(),
138        }
139    }
140}
looking_glass/owned.rs

looking_glass/
owned.rs
