alox-48 0.7.1

ruby marshal data deserializer
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

// Copyright (c) 2024 Lily Lyons
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
#![allow(dead_code)]

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum Tag {
    Nil = b'0',

    True = b'T',

    False = b'F',

    Fixnum = b'i',

    Float = b'f',

    Bignum = b'l',

    String = b'\"',

    Array = b'[',

    Hash = b'{',

    HashDefault = b'}',

    Symbol = b':',

    Symlink = b';',

    Instance = b'I',

    RawRegexp = b'/',

    ClassRef = b'c',

    ModuleRef = b'm',

    Object = b'o',

    ObjectLink = b'@',

    UserDef = b'u',

    Struct = b'S',

    UserClass = b'C',

    Extended = b'e',

    UserMarshal = b'U',

    Data = b'd',
}

impl Tag {
    pub fn from_u8(value: u8) -> Option<Tag> {
        match value {
            b'0' => Some(Tag::Nil),
            b'T' => Some(Tag::True),
            b'F' => Some(Tag::False),
            b'i' => Some(Tag::Fixnum),
            b'f' => Some(Tag::Float),
            b'l' => Some(Tag::Bignum),
            b'\"' => Some(Tag::String),
            b'[' => Some(Tag::Array),
            b'{' => Some(Tag::Hash),
            b'}' => Some(Tag::HashDefault),
            b':' => Some(Tag::Symbol),
            b';' => Some(Tag::Symlink),
            b'I' => Some(Tag::Instance),
            b'/' => Some(Tag::RawRegexp),
            b'c' => Some(Tag::ClassRef),
            b'm' => Some(Tag::ModuleRef),
            b'o' => Some(Tag::Object),
            b'@' => Some(Tag::ObjectLink),
            b'u' => Some(Tag::UserDef),
            b'S' => Some(Tag::Struct),
            b'C' => Some(Tag::UserClass),
            b'e' => Some(Tag::Extended),
            b'U' => Some(Tag::UserMarshal),
            b'd' => Some(Tag::Data),
            _ => None,
        }
    }

    pub fn is_object_link_referenceable(self) -> bool {
        !matches!(
            self,
            Self::Nil
                | Self::True
                | Self::False
                | Self::Fixnum
                | Self::Symbol
                | Self::Symlink
                | Self::ObjectLink
        )
    }
}

impl From<Tag> for u8 {
    fn from(value: Tag) -> Self {
        value as _
    }
}