android_manifest/
attribute_list.rs

1use serde::{
2    de::{self, DeserializeOwned, Visitor},
3    ser::Error,
4    Deserialize, Deserializer, Serialize, Serializer,
5};
6use std::fmt;
7use std::io::{Read, Write};
8use std::marker::PhantomData;
9use yaserde::{YaDeserialize, YaSerialize};
10
11pub trait Delimiter {
12    fn delimiter_symbol() -> &'static str;
13}
14
15#[derive(Debug, PartialEq, Eq, Default, Clone)]
16pub struct Semicolon;
17
18impl Delimiter for Semicolon {
19    fn delimiter_symbol() -> &'static str {
20        ";"
21    }
22}
23
24#[derive(Debug, PartialEq, Eq, Default, Clone)]
25pub struct VerticalBar;
26
27impl Delimiter for VerticalBar {
28    fn delimiter_symbol() -> &'static str {
29        "|"
30    }
31}
32
33#[derive(Debug, PartialEq, Eq, Default, Clone)]
34pub struct AttributeList<D: Delimiter, T: Serialize + DeserializeOwned> {
35    vec: Vec<T>,
36    phantom: PhantomData<D>,
37}
38
39impl<D: Delimiter, T: Serialize + DeserializeOwned> AttributeList<D, T> {
40    pub fn new() -> Self {
41        AttributeList {
42            vec: Vec::new(),
43            phantom: PhantomData,
44        }
45    }
46
47    pub fn from_vec(vec: Vec<T>) -> Self {
48        AttributeList {
49            vec,
50            phantom: PhantomData,
51        }
52    }
53
54    pub fn vec(&self) -> &Vec<T> {
55        &self.vec
56    }
57
58    pub fn is_empty(&self) -> bool {
59        self.vec.is_empty()
60    }
61}
62
63impl<D: Delimiter, T: Serialize + DeserializeOwned> From<Vec<T>> for AttributeList<D, T> {
64    fn from(vec: Vec<T>) -> Self {
65        AttributeList {
66            vec,
67            phantom: PhantomData,
68        }
69    }
70}
71
72impl<D: Delimiter, T: Serialize + DeserializeOwned> Serialize for AttributeList<D, T> {
73    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
74    where
75        S: Serializer,
76    {
77        if self.is_empty() {
78            return Err(S::Error::custom("a value list can't be empty"));
79        };
80        serializer.serialize_str(
81            &self
82                .vec()
83                .iter()
84                .map(|v| serde_plain::to_string(v).unwrap())
85                .collect::<Vec<String>>()
86                .join(D::delimiter_symbol()),
87        )
88    }
89}
90
91impl<D: Delimiter, T: Serialize + DeserializeOwned> YaSerialize for AttributeList<D, T> {
92    fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
93        // if self.is_empty() {
94        //     println!("1");
95        //     return Err("a value list can't be empty".to_string());
96        // };
97        let _ret = writer.write(xml::writer::XmlEvent::characters(
98            &self
99                .vec()
100                .iter()
101                .map(|v| serde_plain::to_string(v).unwrap())
102                .collect::<Vec<String>>()
103                .join(D::delimiter_symbol()),
104        ));
105        Ok(())
106    }
107
108    fn serialize_attributes(
109        &self,
110        attributes: Vec<xml::attribute::OwnedAttribute>,
111        namespace: xml::namespace::Namespace,
112    ) -> Result<
113        (
114            Vec<xml::attribute::OwnedAttribute>,
115            xml::namespace::Namespace,
116        ),
117        String,
118    > {
119        Ok((attributes, namespace))
120    }
121}
122
123fn parse_list_with_delimiter<D: Delimiter, T: Serialize + DeserializeOwned>(
124    v: &str,
125) -> Result<AttributeList<D, T>, String> {
126    if v.is_empty() {
127        return Err(
128            "there is no default value list. at least one value must be specified".to_string(),
129        );
130    };
131    let values = v
132        .replace(' ', "")
133        .split(D::delimiter_symbol())
134        .map(|s| serde_plain::from_str(s).unwrap())
135        .collect();
136    Ok(AttributeList::from_vec(values))
137}
138
139struct ListVisitor<D: Delimiter, T: Serialize + DeserializeOwned> {
140    delimiter: PhantomData<D>,
141    value_type: PhantomData<T>,
142}
143
144impl<D: Delimiter, T: Serialize + DeserializeOwned> ListVisitor<D, T> {
145    pub fn new() -> Self {
146        ListVisitor {
147            delimiter: PhantomData,
148            value_type: PhantomData,
149        }
150    }
151}
152
153impl<'de, D: Delimiter, T: Serialize + DeserializeOwned> Visitor<'de> for ListVisitor<D, T> {
154    type Value = AttributeList<D, T>;
155
156    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
157        formatter.write_str(&format!(
158            "an value list in format 'value1' or 'value1{}value2{}value3'",
159            D::delimiter_symbol(),
160            D::delimiter_symbol()
161        ))
162    }
163
164    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
165    where
166        E: de::Error,
167    {
168        parse_list_with_delimiter(v).map_err(|e| E::custom(e))
169    }
170}
171
172impl<'de, D: Delimiter, T: Serialize + DeserializeOwned> Deserialize<'de> for AttributeList<D, T> {
173    fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
174    where
175        De: Deserializer<'de>,
176    {
177        deserializer.deserialize_string(ListVisitor::new())
178    }
179}
180
181impl<D: Delimiter, T: Serialize + DeserializeOwned> YaDeserialize for AttributeList<D, T> {
182    fn deserialize<R: Read>(reader: &mut yaserde::de::Deserializer<R>) -> Result<Self, String> {
183        loop {
184            match reader.next_event()? {
185                xml::reader::XmlEvent::StartElement { .. } => {}
186                xml::reader::XmlEvent::Characters(ref v) => {
187                    return parse_list_with_delimiter(v);
188                }
189                _ => {
190                    break;
191                }
192            }
193        }
194        Err("Unable to parse attribute".to_string())
195    }
196}
android_manifest/attribute_list.rs

android_manifest/
attribute_list.rs
