veriform 0.2.0

Cryptographically verifiable data serialization format inspired by Protocol Buffers
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

//! Field headers

use super::{Tag, WireType};
use vint64::VInt64;

/// Field headers
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct Header {
    /// Tag which identifies the field
    pub tag: Tag,

    /// Indicates a field containing critical information which
    /// shouldn't be ignored if the field is unknown
    pub critical: bool,

    /// Encoded value type for the field
    pub wire_type: WireType,
}

impl Header {
    /// Create a new header
    pub fn new(tag: Tag, critical: bool, wire_type: WireType) -> Self {
        Header {
            tag,
            critical,
            wire_type,
        }
    }

    /// Encode this header value as a `vint64`
    pub fn encode(self) -> VInt64 {
        vint64::encode(self.into())
    }

    /// Get the length of this header when encoded as `vint64`
    pub fn encoded_len(self) -> usize {
        vint64::encoded_len(self.into())
    }
}

impl From<u64> for Header {
    fn from(encoded: u64) -> Self {
        Header {
            tag: encoded >> 4,
            critical: encoded >> 3 & 1 == 1,
            wire_type: WireType::from_unmasked(encoded),
        }
    }
}

impl From<Header> for u64 {
    fn from(header: Header) -> u64 {
        header.tag << 4 | (header.critical as u64) << 3 | header.wire_type as u64
    }
}