flutter_rust_bridge_codegen 2.14.0-beta.1

Flutter/Dart <-> Rust binding generator, feature-rich, but seamless and simple
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use crate::codegen::ir::hir::flat::component::HirFlatComponent;
use crate::codegen::ir::hir::flat::constant::HirFlatConstant;
use crate::codegen::ir::hir::flat::function::HirFlatFunction;
use crate::codegen::ir::hir::flat::struct_or_enum::{HirFlatEnum, HirFlatStruct};
use crate::codegen::ir::hir::flat::trait_impl::HirFlatTraitImpl;
use crate::codegen::ir::hir::flat::traits::HirFlatTrait;
use crate::codegen::ir::hir::flat::type_alias::HirFlatTypeAlias;
use crate::codegen::ir::misc::skip::IrSkip;
use crate::utils::basic_code::general_code::GeneralDartCode;
use crate::utils::namespace::NamespacedName;

#[derive(Debug, Clone, Default, serde::Serialize)]
pub(crate) struct HirFlatPack {
    pub functions: Vec<HirFlatFunction>,
    pub enums: Vec<HirFlatEnum>,
    pub structs: Vec<HirFlatStruct>,
    pub traits: Vec<HirFlatTrait>,
    pub trait_impls: Vec<HirFlatTraitImpl>,
    pub constants: Vec<HirFlatConstant>,
    pub types: Vec<HirFlatTypeAlias>,
    pub existing_handler: Option<NamespacedName>,
    pub extra_rust_output_code: String,
    pub extra_dart_output_code: GeneralDartCode,
    pub skips: Vec<IrSkip>,
}

impl HirFlatPack {
    pub(crate) fn visit_components_mut(&mut self, visitor: impl HirFlatPackComponentVisitor) {
        visitor.visit(&mut self.functions);
        visitor.visit(&mut self.enums);
        visitor.visit(&mut self.structs);
        visitor.visit(&mut self.traits);
        visitor.visit(&mut self.trait_impls);
        visitor.visit(&mut self.constants);
        visitor.visit(&mut self.types);
    }
}

pub(crate) trait HirFlatPackComponentVisitor {
    fn visit<SK: Ord, T: HirFlatComponent<SK>>(&self, items: &mut Vec<T>);
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;

    struct CountingVisitor(Arc<AtomicUsize>);

    impl HirFlatPackComponentVisitor for CountingVisitor {
        fn visit<SK: Ord, T: HirFlatComponent<SK>>(&self, _items: &mut Vec<T>) {
            self.0.fetch_add(1, Ordering::Relaxed);
        }
    }

    /// Visits every heterogeneous component collection exactly once.
    #[test]
    fn visits_all_component_collections() {
        let mut pack = HirFlatPack::default();
        let visits = Arc::new(AtomicUsize::new(0));
        let visitor = CountingVisitor(Arc::clone(&visits));

        pack.visit_components_mut(visitor);

        assert_eq!(visits.load(Ordering::Relaxed), 7);
    }
}