gesha_rust_types/
imports.rs

1use Cow::{Borrowed, Owned};
2use indexmap::IndexSet;
3use std::borrow::Cow;
4use std::fmt::{Display, Formatter};
5
6#[derive(Clone, Debug, PartialEq, Default)]
7pub struct Imports(IndexSet<Package>);
8
9impl Imports {
10    pub fn new() -> Self {
11        Self(IndexSet::new())
12    }
13    pub fn set<A: Into<Vec<Package>>>(&mut self, xs: A) {
14        xs.into().into_iter().for_each(|x| {
15            let _ = self.0.insert(x);
16        })
17    }
18    pub fn iter(&self) -> impl Iterator<Item = &Package> {
19        self.0.iter()
20    }
21}
22
23impl IntoIterator for Imports {
24    type Item = <IndexSet<Package> as IntoIterator>::Item;
25    type IntoIter = <IndexSet<Package> as IntoIterator>::IntoIter;
26
27    fn into_iter(self) -> Self::IntoIter {
28        IntoIterator::into_iter(self.0)
29    }
30}
31
32impl From<Vec<Package>> for Imports {
33    fn from(this: Vec<Package>) -> Self {
34        let mut xs = Self::new();
35        xs.set(this);
36        xs
37    }
38}
39
40#[derive(Clone, Debug, Hash, Eq, PartialEq)]
41pub enum Package {
42    Deserialize,
43    Deserializer,
44    Serialize,
45    Serializer,
46    Display,
47    Formatter,
48    Patch { depth: usize },
49}
50
51impl Display for Package {
52    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
53        let x = match self {
54            Self::Deserialize => Borrowed("serde::Deserialize"),
55            Self::Deserializer => Borrowed("serde::Deserializer"),
56            Self::Serialize => Borrowed("serde::Serialize"),
57            Self::Serializer => Borrowed("serde::Serializer"),
58            Self::Display => Borrowed("std::fmt::Display"),
59            Self::Formatter => Borrowed("std::fmt::Formatter"),
60            Self::Patch { depth } => Owned("super::".repeat(*depth) + "core::Patch"),
61        };
62        Display::fmt(&x, f)
63    }
64}
65
66impl From<Package> for Vec<Package> {
67    fn from(x: Package) -> Self {
68        vec![x]
69    }
70}