marc 3.1.1

Reader and builder for MARC 21 Bibliographic format
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
126
127
128
129

use std::{fmt, str};

/// Tag of a field
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct Tag(pub [u8; 3]);

impl Tag {
    /// Creates a tag from the given slice.
    ///
    /// # Panic
    ///
    /// Will panic if `bytes.len() != 3`.
    pub fn from_slice(bytes: &[u8]) -> Self {
        let mut this = Tag([0; 3]);
        this.0.copy_from_slice(bytes);
        this
    }

    /// Returns tag as a `str`.
    ///
    /// # Panic
    ///
    /// Will panic in case of non-utf8 indicator.
    pub fn as_str(&self) -> &str {
        std::str::from_utf8(&self.0).expect("non-utf8 tag")
    }
}

impl PartialEq<[u8; 3]> for Tag {
    fn eq(&self, other: &[u8; 3]) -> bool {
        self.0 == *other
    }
}

impl PartialEq<&'_ [u8; 3]> for Tag {
    fn eq(&self, other: &&'_ [u8; 3]) -> bool {
        &self.0 == *other
    }
}

impl PartialEq<[u8]> for Tag {
    fn eq(&self, other: &[u8]) -> bool {
        &self.0[..] == other
    }
}

impl PartialEq<&'_ [u8]> for Tag {
    fn eq(&self, other: &&'_ [u8]) -> bool {
        &self.0[..] == *other
    }
}

impl PartialEq<str> for Tag {
    fn eq(&self, other: &str) -> bool {
        &self.0[..] == other.as_bytes()
    }
}

impl PartialEq<&'_ str> for Tag {
    fn eq(&self, other: &&'_ str) -> bool {
        &self.0[..] == other.as_bytes()
    }
}

impl PartialEq<Tag> for [u8; 3] {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl PartialEq<Tag> for &'_ [u8; 3] {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl PartialEq<Tag> for [u8] {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl PartialEq<Tag> for &'_ [u8] {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl PartialEq<Tag> for str {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl PartialEq<Tag> for &'_ str {
    fn eq(&self, other: &Tag) -> bool {
        *other == *self
    }
}

impl AsRef<[u8]> for Tag {
    fn as_ref(&self) -> &[u8] {
        &self.0[..]
    }
}

impl fmt::Debug for Tag {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl fmt::Display for Tag {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "={}", String::from_utf8_lossy(&self.0))
    }
}

impl From<[u8; 3]> for Tag {
    fn from(s: [u8; 3]) -> Tag {
        Tag(s)
    }
}

impl From<&'_ [u8; 3]> for Tag {
    fn from(s: &'_ [u8; 3]) -> Tag {
        Tag(*s)
    }
}