annotate 1.2.3

Annotation framework for Rust functions and modules
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

pub(crate) mod environment;
pub(crate) mod function;
pub(crate) mod module;

pub(crate) const fn const_bytes_equal(lhs: &[u8], rhs: &[u8]) -> bool {
    if lhs.len() != rhs.len() {
        return false;
    }

    let mut index = 0;
    while index < lhs.len() {
        if lhs[index] != rhs[index] {
            return false;
        }
        index += 1;
    }

    true
}

pub(crate) const fn const_str_equal(lhs: &str, rhs: &str) -> bool {
    const_bytes_equal(lhs.as_bytes(), rhs.as_bytes())
}

#[doc(hidden)]
pub mod __private {
    pub use super::environment::ProtoEnvironment;
    pub use super::function::{AnyReturn, FunctionPointer, ProtoFunction};
    pub use super::module::ProtoModule;

    pub const fn path(segments: &'static [&'static str]) -> crate::Path {
        crate::Path(segments)
    }

    pub const fn attribute(name: &'static str, value: crate::Value) -> crate::Attribute {
        crate::Attribute { name, value }
    }

    pub const fn ty<T: 'static>() -> crate::Type {
        crate::Type {
            type_name_fn: core::any::type_name::<T>,
            type_id: core::any::TypeId::of::<T>(),
        }
    }

    pub const fn proto_environment(
        modules: &'static [ProtoModule],
        functions: &'static [ProtoFunction],
    ) -> ProtoEnvironment {
        ProtoEnvironment { modules, functions }
    }

    pub const fn proto_function(
        name: &'static str,
        path: crate::Path,
        module: Option<usize>,
        attributes: unsafe fn() -> &'static [crate::Attribute],
        function: unsafe fn() -> FunctionPointer,
    ) -> ProtoFunction {
        ProtoFunction {
            name,
            path,
            module,
            attributes,
            function,
        }
    }

    pub const fn proto_module(
        name: &'static str,
        path: crate::Path,
        submodules: &'static [usize],
        functions: &'static [usize],
        parent_module: Option<usize>,
        attributes: unsafe fn() -> &'static [crate::Attribute],
    ) -> ProtoModule {
        ProtoModule {
            name,
            path,
            submodules,
            functions,
            _parent_module: parent_module,
            attributes,
        }
    }

    pub const fn environment(
        modules: &'static [crate::Module],
        functions: &'static [crate::Function],
    ) -> crate::Environment {
        crate::Environment { modules, functions }
    }

    pub const fn function(
        environment: &'static ProtoEnvironment,
        proto_function: &'static ProtoFunction,
    ) -> crate::Function {
        crate::Function {
            environment,
            proto_function,
        }
    }

    pub const fn module(
        environment: &'static ProtoEnvironment,
        proto_module: &'static ProtoModule,
    ) -> crate::Module {
        crate::Module {
            environment,
            proto_module,
        }
    }

    pub fn function_pointer(
        raw: &'static dyn core::any::Any,
        any_return: Option<fn() -> AnyReturn>,
    ) -> FunctionPointer {
        FunctionPointer {
            raw,
            _any_return: any_return,
        }
    }

    pub fn any_return<T: Send + Sync + 'static>(value: T) -> AnyReturn {
        #[cfg(feature = "function-call")]
        {
            AnyReturn::Value(alloc::boxed::Box::new(value))
        }
        #[cfg(not(feature = "function-call"))]
        {
            let _ = value;
            AnyReturn::Unsupported
        }
    }
}