wasmer_types/entity/
packed_option.rs

1// This file contains code from external sources.
2// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
3
4//! Compact representation of `Option<T>` for types with a reserved value.
5//!
6//! Small types are often used in tables and linked lists where an
7//! `Option<T>` is needed. Unfortunately, that would double the size of the tables
8//! because `Option<T>` is twice as big as `T`.
9//!
10//! This module provides a `PackedOption<T>` for types that have a reserved value that can be used
11//! to represent `None`.
12
13use crate::lib::std::fmt;
14use crate::lib::std::mem;
15
16/// Types that have a reserved value which can't be created any other way.
17pub trait ReservedValue {
18    /// Create an instance of the reserved value.
19    fn reserved_value() -> Self;
20    /// Checks whether value is the reserved one.
21    fn is_reserved_value(&self) -> bool;
22}
23
24/// Packed representation of `Option<T>`.
25#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
26pub struct PackedOption<T: ReservedValue>(T);
27
28impl<T: ReservedValue> PackedOption<T> {
29    /// Returns `true` if the packed option is a `None` value.
30    pub fn is_none(&self) -> bool {
31        self.0.is_reserved_value()
32    }
33
34    /// Returns `true` if the packed option is a `Some` value.
35    pub fn is_some(&self) -> bool {
36        !self.0.is_reserved_value()
37    }
38
39    /// Expand the packed option into a normal `Option`.
40    pub fn expand(self) -> Option<T> {
41        if self.is_none() {
42            None
43        } else {
44            Some(self.0)
45        }
46    }
47
48    /// Maps a `PackedOption<T>` to `Option<U>` by applying a function to a contained value.
49    pub fn map<U, F>(self, f: F) -> Option<U>
50    where
51        F: FnOnce(T) -> U,
52    {
53        self.expand().map(f)
54    }
55
56    /// Unwrap a packed `Some` value or panic.
57    pub fn unwrap(self) -> T {
58        self.expand().unwrap()
59    }
60
61    /// Unwrap a packed `Some` value or panic.
62    pub fn expect(self, msg: &str) -> T {
63        self.expand().expect(msg)
64    }
65
66    /// Takes the value out of the packed option, leaving a `None` in its place.
67    pub fn take(&mut self) -> Option<T> {
68        mem::replace(self, None.into()).expand()
69    }
70}
71
72impl<T: ReservedValue> Default for PackedOption<T> {
73    /// Create a default packed option representing `None`.
74    fn default() -> Self {
75        Self(T::reserved_value())
76    }
77}
78
79impl<T: ReservedValue> From<T> for PackedOption<T> {
80    /// Convert `t` into a packed `Some(x)`.
81    fn from(t: T) -> Self {
82        debug_assert!(
83            !t.is_reserved_value(),
84            "Can't make a PackedOption from the reserved value."
85        );
86        Self(t)
87    }
88}
89
90impl<T: ReservedValue> From<Option<T>> for PackedOption<T> {
91    /// Convert an option into its packed equivalent.
92    fn from(opt: Option<T>) -> Self {
93        match opt {
94            None => Self::default(),
95            Some(t) => t.into(),
96        }
97    }
98}
99
100impl<T: ReservedValue> Into<Option<T>> for PackedOption<T> {
101    fn into(self) -> Option<T> {
102        self.expand()
103    }
104}
105
106impl<T> fmt::Debug for PackedOption<T>
107where
108    T: ReservedValue + fmt::Debug,
109{
110    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
111        if self.is_none() {
112            write!(f, "None")
113        } else {
114            write!(f, "Some({:?})", self.0)
115        }
116    }
117}
118
119#[cfg(test)]
120mod tests {
121    use super::*;
122
123    // Dummy entity class, with no Copy or Clone.
124    #[derive(Debug, PartialEq, Eq)]
125    struct NoC(u32);
126
127    impl ReservedValue for NoC {
128        fn reserved_value() -> Self {
129            NoC(13)
130        }
131
132        fn is_reserved_value(&self) -> bool {
133            self.0 == 13
134        }
135    }
136
137    #[test]
138    fn moves() {
139        let x = NoC(3);
140        let somex: PackedOption<NoC> = x.into();
141        assert!(!somex.is_none());
142        assert_eq!(somex.expand(), Some(NoC(3)));
143
144        let none: PackedOption<NoC> = None.into();
145        assert!(none.is_none());
146        assert_eq!(none.expand(), None);
147    }
148
149    // Dummy entity class, with Copy.
150    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
151    struct Ent(u32);
152
153    impl ReservedValue for Ent {
154        fn reserved_value() -> Self {
155            Ent(13)
156        }
157
158        fn is_reserved_value(&self) -> bool {
159            self.0 == 13
160        }
161    }
162
163    #[test]
164    fn copies() {
165        let x = Ent(2);
166        let some: PackedOption<Ent> = x.into();
167        let some2: Option<Ent> = x.into();
168        assert_eq!(some.expand(), some2);
169        assert_eq!(some, x.into());
170    }
171}
wasmer_types/entity/packed_option.rs

wasmer_types/entity/
packed_option.rs
