debuggingsplit-into-workspace

1 files changed, 786 insertions, 0 deletions

diff --git a/crates/atom/src/lib.rs b/crates/atom/src/lib.rs
new file mode 100644
index 0000000..39e32af
--- /dev/null
+++ b/crates/atom/src/lib.rs
@@ -0,0 +1,786 @@
+#![deny(clippy::pedantic, unused_imports)]
+#![allow(
+    dead_code,
+    unstable_name_collisions,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc
+)]
+#![feature(impl_trait_in_assoc_type)]
+
+use core::{
+    fmt::{self},
+    option::Option,
+};
+
+use std::cmp::Ordering;
+
+// TODO: wtf?
+#[allow(unused_imports)]
+use parseable::Parseable;
+
+use useflag::UseFlag;
+
+use get::Get;
+
+use itertools::Itertools;
+
+mod parsers;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Blocker {
+    Weak,
+    Strong,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum VersionOperator {
+    Lt,
+    Gt,
+    Eq,
+    LtEq,
+    GtEq,
+    Roughly,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct Category(#[get(method = "get", kind = "deref")] String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct Name(#[get(method = "get", kind = "deref")] String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct VersionNumber(#[get(method = "get", kind = "deref")] String);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Get)]
+struct VersionNumbers(#[get(method = "get", kind = "deref")] Vec<VersionNumber>);
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum VersionSuffixKind {
+    Alpha,
+    Beta,
+    Pre,
+    Rc,
+    P,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq, Get)]
+pub struct VersionSuffix {
+    kind: VersionSuffixKind,
+    number: Option<VersionNumber>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Get)]
+pub struct VersionSuffixes(#[get(method = "get", kind = "deref")] Vec<VersionSuffix>);
+
+#[derive(Debug, Clone, Get, PartialEq, Eq, Hash)]
+pub struct BuildId(#[get(method = "get", kind = "deref")] String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct Version {
+    numbers: VersionNumbers,
+    letter: Option<char>,
+    suffixes: VersionSuffixes,
+    rev: Option<VersionNumber>,
+    build_id: Option<BuildId>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct Wildcard;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum SlotOperator {
+    Eq,
+    Star,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct SlotName(#[get(method = "name", kind = "deref")] String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Slot {
+    Wildcard,
+    Equal,
+    NameEqual {
+        primary: SlotName,
+        sub: Option<SlotName>,
+    },
+    Name {
+        primary: SlotName,
+        sub: Option<SlotName>,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum UseDepNegate {
+    Minus,
+    Exclamation,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum UseDepSign {
+    Enabled,
+    Disabled,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum UseDepCondition {
+    Eq,
+    Question,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Repo(String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct UseDep {
+    negate: Option<UseDepNegate>,
+    flag: UseFlag,
+    sign: Option<UseDepSign>,
+    condition: Option<UseDepCondition>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct Cp {
+    category: Category,
+    name: Name,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Get)]
+pub struct Cpv {
+    category: Category,
+    name: Name,
+    version: Version,
+    slot: Option<Slot>,
+}
+
+#[derive(Clone, Debug, Get, PartialEq, Eq, Hash)]
+pub struct Atom {
+    blocker: Option<Blocker>,
+    category: Category,
+    name: Name,
+    version: Option<(VersionOperator, Version, Option<Wildcard>)>,
+    slot: Option<Slot>,
+    repo: Option<Repo>,
+    #[get(kind = "deref")]
+    usedeps: Vec<UseDep>,
+}
+
+impl Cpv {
+    #[must_use]
+    pub fn into_cp(self) -> Cp {
+        Cp {
+            name: self.name,
+            category: self.category,
+        }
+    }
+}
+
+impl Atom {
+    #[must_use]
+    pub fn version_operator(&self) -> Option<VersionOperator> {
+        self.version.clone().map(|(oper, _, _)| oper)
+    }
+
+    #[must_use]
+    pub fn into_cp(self) -> Cp {
+        Cp {
+            category: self.category,
+            name: self.name,
+        }
+    }
+
+    #[must_use]
+    pub fn into_cpv(self) -> Option<Cpv> {
+        match self.version {
+            Some((_, version, _)) => Some(Cpv {
+                category: self.category,
+                name: self.name,
+                version,
+                slot: self.slot,
+            }),
+            None => None,
+        }
+    }
+}
+
+impl VersionNumber {
+    #[must_use]
+    pub fn cmp_as_ints(&self, other: &Self) -> Ordering {
+        let a = self.get().trim_start_matches('0');
+        let b = other.get().trim_start_matches('0');
+
+        a.len().cmp(&b.len()).then_with(|| a.cmp(b))
+    }
+
+    #[must_use]
+    pub fn cmp_as_str(&self, other: &Self) -> Ordering {
+        if self.get().starts_with('0') || other.get().starts_with('0') {
+            let a = self.get().trim_end_matches('0');
+            let b = other.get().trim_end_matches('0');
+
+            a.cmp(b)
+        } else {
+            self.cmp_as_ints(other)
+        }
+    }
+}
+
+impl PartialOrd for BuildId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for BuildId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // build-id may not start with a zero so we dont need to strip them
+        self.get()
+            .len()
+            .cmp(&other.get().len())
+            .then_with(|| self.get().cmp(other.get()))
+    }
+}
+
+impl PartialOrd for VersionSuffix {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VersionSuffix {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match &self.kind.cmp(&other.kind) {
+            Ordering::Less => Ordering::Less,
+            Ordering::Greater => Ordering::Greater,
+            Ordering::Equal => match (&self.number, &other.number) {
+                (Some(a), Some(b)) => a.cmp_as_ints(b),
+                (Some(a), None) if a.get().chars().all(|c| c == '0') => Ordering::Equal,
+                (None, Some(b)) if b.get().chars().all(|c| c == '0') => Ordering::Equal,
+                (Some(_), None) => Ordering::Greater,
+                (None, Some(_)) => Ordering::Less,
+                (None, None) => Ordering::Equal,
+            },
+        }
+    }
+}
+
+impl PartialOrd for VersionSuffixes {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VersionSuffixes {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let mut a = self.get().iter();
+        let mut b = other.get().iter();
+
+        loop {
+            match (a.next(), b.next()) {
+                (Some(a), Some(b)) => match a.cmp(b) {
+                    Ordering::Less => break Ordering::Less,
+                    Ordering::Greater => break Ordering::Greater,
+                    Ordering::Equal => (),
+                },
+                (Some(a), None) if matches!(a.kind, VersionSuffixKind::P) => {
+                    break Ordering::Greater;
+                }
+                (Some(_), None) => break Ordering::Less,
+                (None, Some(b)) if matches!(b.kind, VersionSuffixKind::P) => break Ordering::Less,
+                (None, Some(_)) => break Ordering::Greater,
+                (None, None) => break Ordering::Equal,
+            }
+        }
+    }
+}
+
+impl PartialOrd for VersionNumbers {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VersionNumbers {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self
+            .get()
+            .first()
+            .unwrap()
+            .cmp_as_ints(other.get().first().unwrap())
+        {
+            Ordering::Less => Ordering::Less,
+            Ordering::Greater => Ordering::Greater,
+            Ordering::Equal => {
+                let mut a = self.get().iter().skip(1);
+                let mut b = other.get().iter().skip(1);
+
+                loop {
+                    match (a.next(), b.next()) {
+                        (Some(a), Some(b)) => match a.cmp_as_str(b) {
+                            Ordering::Less => break Ordering::Less,
+                            Ordering::Greater => break Ordering::Greater,
+                            Ordering::Equal => (),
+                        },
+
+                        (Some(_), None) => break Ordering::Greater,
+                        (None, Some(_)) => break Ordering::Less,
+                        (None, None) => break Ordering::Equal,
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl PartialOrd for Version {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Version {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.numbers.cmp(&other.numbers) {
+            Ordering::Less => return Ordering::Less,
+            Ordering::Greater => return Ordering::Greater,
+            Ordering::Equal => (),
+        }
+
+        match (self.letter, other.letter) {
+            (Some(a), Some(b)) if a < b => return Ordering::Less,
+            (Some(a), Some(b)) if a > b => return Ordering::Greater,
+            (Some(a), Some(b)) if a == b => (),
+            (Some(_), None) => return Ordering::Greater,
+            (None, Some(_)) => return Ordering::Less,
+            (None, None) => (),
+            _ => unreachable!(),
+        }
+
+        match self.suffixes.cmp(&other.suffixes) {
+            Ordering::Less => return Ordering::Less,
+            Ordering::Greater => return Ordering::Greater,
+            Ordering::Equal => (),
+        }
+
+        match (&self.rev, &other.rev) {
+            (Some(a), Some(b)) => match a.cmp_as_ints(b) {
+                Ordering::Less => return Ordering::Less,
+                Ordering::Greater => return Ordering::Greater,
+                Ordering::Equal => (),
+            },
+            (Some(a), None) if a.get().chars().all(|c| c == '0') => (),
+            (Some(_), None) => return Ordering::Greater,
+            (None, Some(b)) if b.get().chars().all(|c| c == '0') => (),
+            (None, Some(_)) => return Ordering::Less,
+            (None, None) => (),
+        }
+
+        match (&self.build_id, &other.build_id) {
+            (Some(a), Some(b)) => a.cmp(b),
+            (Some(_), None) => Ordering::Greater,
+            (None, Some(_)) => Ordering::Less,
+            (None, None) => Ordering::Equal,
+        }
+    }
+}
+
+impl PartialOrd for Cpv {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        if self.category == other.category && self.name == other.name {
+            Some(self.version.cmp(&other.version))
+        } else {
+            None
+        }
+    }
+}
+
+impl fmt::Display for Blocker {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Weak => write!(f, "!"),
+            Self::Strong => write!(f, "!!"),
+        }
+    }
+}
+
+impl fmt::Display for VersionOperator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Lt => write!(f, "<"),
+            Self::Gt => write!(f, ">"),
+            Self::Eq => write!(f, "="),
+            Self::LtEq => write!(f, "<="),
+            Self::GtEq => write!(f, ">="),
+            Self::Roughly => write!(f, "~"),
+        }
+    }
+}
+
+impl fmt::Display for Category {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl fmt::Display for VersionNumber {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl fmt::Display for BuildId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.get())
+    }
+}
+
+impl fmt::Display for VersionSuffixKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Alpha => write!(f, "alpha"),
+            Self::Beta => write!(f, "beta"),
+            Self::Pre => write!(f, "pre"),
+            Self::Rc => write!(f, "rc"),
+            Self::P => write!(f, "p"),
+        }
+    }
+}
+
+impl fmt::Display for VersionSuffix {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.kind)?;
+
+        if let Some(number) = self.number.as_ref() {
+            write!(f, "{number}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let numbers = self
+            .numbers
+            .get()
+            .iter()
+            .map(VersionNumber::get)
+            .intersperse(".")
+            .collect::<String>();
+
+        let suffixes = self
+            .suffixes
+            .get()
+            .iter()
+            .map(VersionSuffix::to_string)
+            .intersperse("_".to_string())
+            .collect::<String>();
+
+        write!(f, "{numbers}")?;
+
+        if let Some(letter) = self.letter {
+            write!(f, "{letter}")?;
+        }
+
+        if !suffixes.is_empty() {
+            write!(f, "_{suffixes}")?;
+        }
+
+        if let Some(rev) = self.rev.as_ref() {
+            write!(f, "-r{rev}")?;
+        }
+
+        if let Some(build_id) = self.build_id.as_ref() {
+            write!(f, "-{build_id}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for SlotOperator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Eq => write!(f, "="),
+            Self::Star => write!(f, "*"),
+        }
+    }
+}
+
+impl fmt::Display for SlotName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl fmt::Display for Slot {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Wildcard => write!(f, "*"),
+            Self::Equal => {
+                write!(f, "=")
+            }
+            Self::NameEqual { primary, sub } => {
+                write!(f, "{primary}")?;
+
+                if let Some(sub) = sub {
+                    write!(f, "/{sub}")?;
+                }
+
+                write!(f, "=")
+            }
+            Self::Name { primary, sub } => {
+                write!(f, "{primary}")?;
+
+                if let Some(sub) = sub {
+                    write!(f, "/{sub}")?;
+                }
+
+                Ok(())
+            }
+        }
+    }
+}
+
+impl fmt::Display for UseDepNegate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Minus => write!(f, "-"),
+            Self::Exclamation => write!(f, "!"),
+        }
+    }
+}
+
+impl fmt::Display for UseDepSign {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Enabled => write!(f, "(+)"),
+            Self::Disabled => write!(f, "(-)"),
+        }
+    }
+}
+
+impl fmt::Display for UseDepCondition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Eq => write!(f, "="),
+            Self::Question => write!(f, "?"),
+        }
+    }
+}
+
+impl fmt::Display for UseDep {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(negate) = self.negate.as_ref() {
+            write!(f, "{negate}")?;
+        }
+
+        write!(f, "{}", self.flag)?;
+
+        if let Some(sign) = self.sign.as_ref() {
+            write!(f, "{sign}")?;
+        }
+
+        if let Some(condition) = self.condition.as_ref() {
+            write!(f, "{condition}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for Cp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/{}", &self.category, &self.name)
+    }
+}
+
+impl fmt::Display for Cpv {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/{}-{}", &self.category, &self.name, &self.version)?;
+
+        if let Some(slot) = self.slot.as_ref() {
+            write!(f, ":{slot}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for Atom {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(blocker) = self.blocker.as_ref() {
+            write!(f, "{blocker}")?;
+        }
+
+        if let Some(version_operator) = self.version_operator().as_ref() {
+            write!(f, "{version_operator}")?;
+        }
+
+        write!(f, "{}", self.category)?;
+        write!(f, "/")?;
+        write!(f, "{}", self.name)?;
+
+        if let Some((_, version, None)) = self.version() {
+            write!(f, "-{version}")?;
+        } else if let Some((_, version, Some(_))) = self.version() {
+            write!(f, "-{version}*")?;
+        }
+
+        if let Some(slot) = self.slot.as_ref() {
+            write!(f, ":{slot}")?;
+        }
+
+        let usedeps = self
+            .usedeps
+            .iter()
+            .map(UseDep::to_string)
+            .intersperse(",".to_string())
+            .collect::<String>();
+
+        if !usedeps.is_empty() {
+            write!(f, "[{usedeps}]")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use mon::{Parser, input::InputIter};
+
+    use super::*;
+
+    use crate::Parseable;
+
+    macro_rules! assert_cmp_display {
+        ($a:expr, $b:expr, $ordering:expr) => {
+            if $a.cmp(&$b) != $ordering {
+                panic!("{} ~ {} != {:?}", $a, $b, $ordering)
+            }
+        };
+    }
+
+    macro_rules! assert_partial_cmp_display {
+        ($a:expr, $b:expr, $ordering:expr) => {
+            if $a.partial_cmp(&$b) != $ordering {
+                panic!("{} ~ {} != {:?}", $a, $b, $ordering)
+            }
+        };
+    }
+
+    #[test]
+    fn test_version_display() {
+        let s = "1.0.0_alpha1_beta1-r1";
+        let version = Version::parser().parse_finished(InputIter::new(s)).unwrap();
+
+        assert_eq!(version.to_string().as_str(), s);
+    }
+
+    #[test]
+    fn test_display_atom() {
+        let s = "!!>=foo/bar-1.0.0v_alpha1_beta1-r1:slot/sub=[a,b,c]";
+        let atom = Atom::parser().parse_finished(InputIter::new(s)).unwrap();
+
+        assert_eq!(atom.to_string().as_str(), s);
+    }
+
+    #[test]
+    fn test_version_cmp() {
+        let versions = [
+            ("1.0.1", "1.0", Ordering::Greater),
+            ("1.0.0", "1.0.0_alpha", Ordering::Greater),
+            ("1.0.0_alpha", "1.0.0_alpha_p", Ordering::Less),
+            ("1.0.0-r0", "1.0.0", Ordering::Equal),
+            ("1.0.0-r0000", "1.0.0", Ordering::Equal),
+            ("1.0.0-r1-1", "1.0.0-r1-2", Ordering::Less),
+        ];
+
+        for (a, b, ordering) in versions.iter().map(|(a, b, ordering)| {
+            (
+                Version::parser().parse_finished(InputIter::new(a)).unwrap(),
+                Version::parser().parse_finished(InputIter::new(b)).unwrap(),
+                ordering,
+            )
+        }) {
+            assert_cmp_display!(a, b, *ordering);
+        }
+    }
+
+    #[test]
+    fn test_cpv_eq() {
+        let cpvs = [
+            ("foo/bar-1", "foo/bar-1", Some(Ordering::Equal)),
+            ("foo/baz-1", "foo/bar-1", None),
+        ];
+
+        for (a, b, ordering) in cpvs.iter().copied().map(|(a, b, ordering)| {
+            (
+                Cpv::parser().parse_finished(InputIter::new(a)).unwrap(),
+                Cpv::parser().parse_finished(InputIter::new(b)).unwrap(),
+                ordering,
+            )
+        }) {
+            assert_partial_cmp_display!(a, b, ordering);
+        }
+    }
+
+    #[test]
+    fn test_version_cmp_letter() {
+        let a = Version::parser()
+            .parse_finished(InputIter::new("1.0.0"))
+            .unwrap();
+        let b = Version::parser()
+            .parse_finished(InputIter::new("1.0.0a"))
+            .unwrap();
+
+        assert_cmp_display!(a, b, Ordering::Less);
+    }
+
+    #[test]
+    fn test_version_cmp_where_b_has_leading_zeros() {
+        let a = Version::parser()
+            .parse_finished(InputIter::new("1.2"))
+            .unwrap();
+        let b = Version::parser()
+            .parse_finished(InputIter::new("1.054"))
+            .unwrap();
+
+        assert_cmp_display!(a, b, Ordering::Greater);
+    }
+
+    #[test]
+    fn test_version_has_more_zeros() {
+        let a = Version::parser()
+            .parse_finished(InputIter::new("1.0.0"))
+            .unwrap();
+        let b = Version::parser()
+            .parse_finished(InputIter::new("1.0"))
+            .unwrap();
+
+        assert_cmp_display!(a, b, Ordering::Greater);
+    }
+
+    #[test]
+    fn test_fuzzer_cases() {
+        let control = Version::parser()
+            .parse_finished(InputIter::new("1.2.0a_alpha1_beta2-r1-8"))
+            .unwrap();
+
+        #[allow(clippy::single_element_loop)]
+        for (version_str, expected) in [("1.2.0", Ordering::Greater)] {
+            let version = Version::parser()
+                .parse_finished(InputIter::new(version_str))
+                .unwrap();
+
+            assert_cmp_display!(control, version, expected);
+        }
+    }
+}