type_enum 0.1.6

Create tagged unions consisting of different types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::*;
use serde::*;

impl<D: TypeEnumDescriptor + SerializeCastable> Serialize for TypeEnum<D> {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::*;

        unsafe {
            let mut seq = serializer.serialize_seq(Some(2))?;
            seq.serialize_element(&self.variant)?;
            let virtual_pointer =
                *<D::AsSerialize<S> as AllCoercible<dyn SerializeInto<S>>>::COERCION_POINTERS
                    .get_unchecked(self.variant as usize);
            let res = (self.value.as_ptr() as *const (), virtual_pointer);
            let r = (&res as *const (*const (), *const ()))
                .cast::<&dyn SerializeInto<S>>()
                .read();
            r.serialize_into(&mut seq)?;
            seq.end()
        }
    }
}

impl<'a, Q: TypeEnumDescriptor + DeserializeCastable<'a, Q>> Deserialize<'a> for TypeEnum<Q> {
    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
        use serde::de::*;

        /// Manages the deserialization process for a type enum.
        struct DeserializeEnumVisitor<'a, L: TypeEnumDescriptor + DeserializeCastable<'a, L>>(
            PhantomData<&'a L>,
        );

        impl<'a, L: TypeEnumDescriptor + DeserializeCastable<'a, L>> Visitor<'a>
            for DeserializeEnumVisitor<'a, L>
        {
            type Value = TypeEnum<L>;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("Type sequence variant.")
            }

            fn visit_seq<A: SeqAccess<'a>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
                unsafe {
                    let variant = seq.next_element::<u8>().and_then(|x| {
                        x.ok_or_else(|| <A::Error as Error>::custom("Expected variant value."))
                    })?;

                    let virtual_pointer = *<L::AsDeserialize<A> as AllCoercible<
                        dyn DeserializeInto<A, L>,
                    >>::COERCION_POINTERS
                        .get(variant as usize)
                        .ok_or_else(|| <A::Error as Error>::custom("Variant out-of-range."))?;

                    let res = (std::ptr::null(), virtual_pointer);
                    let r = (&res as *const (*const (), *const ()))
                        .cast::<*const dyn DeserializeInto<A, L>>()
                        .read();
                    <dyn DeserializeInto<A, L>>::deserialize_into(r, &mut seq)
                }
            }
        }

        deserializer.deserialize_seq(DeserializeEnumVisitor(PhantomData))
    }
}

/// Marks a type that may be serialized.
trait SerializeInto<S: Serializer> {
    /// Serializes the type into the given sequence.
    fn serialize_into(&self, serializer: &mut S::SerializeSeq) -> Result<(), S::Error>;
}

impl<S: Serializer, T: 'static + Serialize> SerializeInto<S> for T {
    fn serialize_into(&self, serializer: &mut S::SerializeSeq) -> Result<(), S::Error> {
        use serde::ser::*;
        serializer.serialize_element(self)
    }
}

/// Marks a type list for which all elements are serializable.
trait SerializeCastable: TypeEnumDescriptor {
    /// The type to use during serialization.
    type AsSerialize<S: Serializer>: Castable<dyn SerializeInto<S>> + TypeEnumDescriptor;
}

impl SerializeCastable for EmptyDescriptor {
    type AsSerialize<S: Serializer> = Self;
}

impl<T: 'static + Serialize, R: SerializeCastable> SerializeCastable for ConsDescriptor<T, R> {
    type AsSerialize<S: Serializer> = ConsDescriptor<T, R::AsSerialize<S>>;
}

/// Marks a type that may be deserialized.
trait DeserializeInto<'a, D: serde::de::SeqAccess<'a>, L: TypeEnumDescriptor> {
    /// Deserializes the type from the given sequence.
    fn deserialize_into(self: *const Self, deserializer: &mut D) -> Result<TypeEnum<L>, D::Error>;
}

impl<'a, D: serde::de::SeqAccess<'a>, T: 'static + Deserialize<'a>, L: TypeEnumDescriptor>
    DeserializeInto<'a, D, L> for T
{
    fn deserialize_into(self: *const Self, deserializer: &mut D) -> Result<TypeEnum<L>, D::Error> {
        Ok(TypeEnum::new(deserializer.next_element::<T>().and_then(
            |x| x.ok_or_else(|| <D::Error as serde::de::Error>::custom("Expected variant value.")),
        )?))
    }
}

/// Marks a type list for which all elements are deserializable.
trait DeserializeCastable<'a, L: TypeEnumDescriptor>: TypeEnumDescriptor {
    /// The type to use during deserialization.
    type AsDeserialize<D: serde::de::SeqAccess<'a>>: Castable<dyn DeserializeInto<'a, D, L>>
        + TypeEnumDescriptor;
}

impl<'a, L: TypeEnumDescriptor> DeserializeCastable<'a, L> for EmptyDescriptor {
    type AsDeserialize<S: serde::de::SeqAccess<'a>> = Self;
}

impl<'a, T: 'static + Deserialize<'a>, R: DeserializeCastable<'a, L>, L: TypeEnumDescriptor>
    DeserializeCastable<'a, L> for ConsDescriptor<T, R>
{
    type AsDeserialize<S: serde::de::SeqAccess<'a>> = ConsDescriptor<T, R::AsDeserialize<S>>;
}