oo_bindgen/model/
enum_type.rs

1use std::rc::Rc;
2
3use crate::model::*;
4
5#[derive(Debug, Clone)]
6pub(crate) struct EnumVariant<T>
7where
8    T: DocReference,
9{
10    pub(crate) name: Name,
11    pub(crate) value: i32,
12    pub(crate) doc: Doc<T>,
13}
14
15impl EnumVariant<Unvalidated> {
16    pub(crate) fn validate(&self, lib: &LibraryFields) -> BindResult<EnumVariant<Validated>> {
17        Ok(EnumVariant {
18            name: self.name.clone(),
19            value: self.value,
20            doc: self.doc.validate(&self.name, lib)?,
21        })
22    }
23}
24
25pub type EnumHandle = Handle<Enum<Unvalidated>>;
26
27impl Handle<Enum<Unvalidated>> {
28    pub fn value(&self, name: &'static str) -> BindResult<EnumValue> {
29        EnumValue::new(self.clone(), name)
30    }
31}
32
33#[derive(Debug)]
34pub struct Enum<T>
35where
36    T: DocReference,
37{
38    pub(crate) name: Name,
39    pub(crate) settings: Rc<LibrarySettings>,
40    pub(crate) variants: Vec<EnumVariant<T>>,
41    pub(crate) doc: Doc<T>,
42}
43
44impl Enum<Unvalidated> {
45    pub(crate) fn validate(&self, lib: &LibraryFields) -> BindResult<Handle<Enum<Validated>>> {
46        let variants: BindResult<Vec<EnumVariant<Validated>>> =
47            self.variants.iter().map(|x| x.validate(lib)).collect();
48
49        Ok(Handle::new(Enum {
50            name: self.name.clone(),
51            settings: self.settings.clone(),
52            variants: variants?,
53            doc: self.doc.validate(&self.name, lib)?,
54        }))
55    }
56}
57
58impl<T> Enum<T>
59where
60    T: DocReference,
61{
62    pub(crate) fn find_variant_by_name<S: AsRef<str>>(
63        &self,
64        variant_name: S,
65    ) -> Option<&EnumVariant<T>> {
66        self.variants
67            .iter()
68            .find(|variant| variant.name.as_ref() == variant_name.as_ref())
69    }
70
71    pub(crate) fn validate_contains_variant_name(
72        &self,
73        variant_name: &str,
74    ) -> BindResult<&EnumVariant<T>> {
75        match self.find_variant_by_name(variant_name) {
76            None => Err(BindingErrorVariant::UnknownEnumVariant {
77                name: self.name.clone(),
78                variant_name: variant_name.to_string(),
79            }
80            .into()),
81            Some(x) => Ok(x),
82        }
83    }
84}
85
86impl From<EnumHandle> for BasicType {
87    fn from(x: EnumHandle) -> Self {
88        BasicType::Enum(x)
89    }
90}