Debian Codegraph @

.cargo/vendor/toml/src/spanned.rs

raw
1 use serde::{de, ser};
2 use std::borrow::Borrow;
3 use std::cmp::Ordering;
4 use std::fmt;
5 use std::hash::{Hash, Hasher};
6
7 pub(crate) const NAME: &str = "$__toml_private_Spanned";
8 pub(crate) const START: &str = "$__toml_private_start";
9 pub(crate) const END: &str = "$__toml_private_end";
10 pub(crate) const VALUE: &str = "$__toml_private_value";
11
12 /// A spanned value, indicating the range at which it is defined in the source.
13 ///
14 /// ```
15 /// use serde_derive::Deserialize;
16 /// use toml::Spanned;
17 ///
18 /// #[derive(Deserialize)]
19 /// struct Value {
20 /// s: Spanned<String>,
21 /// }
22 ///
23 /// let t = "s = \"value\"\n";
24 ///
25 /// let u: Value = toml::from_str(t).unwrap();
26 ///
27 /// assert_eq!(u.s.start(), 4);
28 /// assert_eq!(u.s.end(), 11);
29 /// assert_eq!(u.s.get_ref(), "value");
30 /// assert_eq!(u.s.into_inner(), String::from("value"));
31 /// ```
32 #[derive(Clone, Debug)]
33 pub struct Spanned<T> {
34 /// The start range.
35 start: usize,
36 /// The end range (exclusive).
37 end: usize,
38 /// The spanned value.
39 value: T,
40 }
41
42 impl<T> Spanned<T> {
43 /// Access the start of the span of the contained value.
44 pub fn start(&self) -> usize {
45 self.start
46 }
47
48 /// Access the end of the span of the contained value.
49 pub fn end(&self) -> usize {
50 self.end
51 }
52
53 /// Get the span of the contained value.
54 pub fn span(&self) -> (usize, usize) {
55 (self.start, self.end)
56 }
57
58 /// Consumes the spanned value and returns the contained value.
59 pub fn into_inner(self) -> T {
60 self.value
61 }
62
63 /// Returns a reference to the contained value.
64 pub fn get_ref(&self) -> &T {
65 &self.value
66 }
67
68 /// Returns a mutable reference to the contained value.
69 pub fn get_mut(&mut self) -> &mut T {
70 &mut self.value
71 }
72 }
73
74 impl Borrow<str> for Spanned<String> {
75 fn borrow(&self) -> &str {
76 self.get_ref()
77 }
78 }
79
80 impl<T: PartialEq> PartialEq for Spanned<T> {
81 fn eq(&self, other: &Self) -> bool {
82 self.value.eq(&other.value)
83 }
84 }
85
86 impl<T: Eq> Eq for Spanned<T> {}
87
88 impl<T: Hash> Hash for Spanned<T> {
89 fn hash<H: Hasher>(&self, state: &mut H) {
90 self.value.hash(state);
91 }
92 }
93
94 impl<T: PartialOrd> PartialOrd for Spanned<T> {
95 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
96 self.value.partial_cmp(&other.value)
97 }
98 }
99
100 impl<T: Ord> Ord for Spanned<T> {
101 fn cmp(&self, other: &Self) -> Ordering {
102 self.value.cmp(&other.value)
103 }
104 }
105
106 impl<'de, T> de::Deserialize<'de> for Spanned<T>
107 where
108 T: de::Deserialize<'de>,
109 {
110 fn deserialize<D>(deserializer: D) -> Result<Spanned<T>, D::Error>
111 where
112 D: de::Deserializer<'de>,
113 {
114 struct SpannedVisitor<T>(::std::marker::PhantomData<T>);
115
116 impl<'de, T> de::Visitor<'de> for SpannedVisitor<T>
117 where
118 T: de::Deserialize<'de>,
119 {
120 type Value = Spanned<T>;
121
122 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
123 formatter.write_str("a TOML spanned")
124 }
125
126 fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error>
127 where
128 V: de::MapAccess<'de>,
129 {
130 if visitor.next_key()? != Some(START) {
131 return Err(de::Error::custom("spanned start key not found"));
132 }
133
134 let start: usize = visitor.next_value()?;
135
136 if visitor.next_key()? != Some(END) {
137 return Err(de::Error::custom("spanned end key not found"));
138 }
139
140 let end: usize = visitor.next_value()?;
141
142 if visitor.next_key()? != Some(VALUE) {
143 return Err(de::Error::custom("spanned value key not found"));
144 }
145
146 let value: T = visitor.next_value()?;
147
148 Ok(Spanned { start, end, value })
149 }
150 }
151
152 let visitor = SpannedVisitor(::std::marker::PhantomData);
153
154 static FIELDS: [&str; 3] = [START, END, VALUE];
155 deserializer.deserialize_struct(NAME, &FIELDS, visitor)
156 }
157 }
158
159 impl<T: ser::Serialize> ser::Serialize for Spanned<T> {
160 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
161 where
162 S: ser::Serializer,
163 {
164 self.value.serialize(serializer)
165 }
166 }