jlrs 0.23.0

jlrs provides bindings to the Julia C API that enable Julia code to be called from Rust and more.
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
136
137
138
139
140
141

/// Use `num::Complex` as bindings for Julia's `Complex` types.
pub use num_complex::Complex;

use crate::{
    convert::{
        ccall_types::{CCallArg, CCallReturn},
        unbox::Unbox,
    },
    data::{
        layout::{
            is_bits::IsBits,
            valid_layout::{ValidField, ValidLayout},
        },
        managed::{Managed, datatype::DataType, union_all::UnionAll, value::Value},
        types::{construct_type::ConstructType, typecheck::Typecheck},
    },
    define_fast_key, define_static_ref,
    memory::{scope::LocalScopeExt, target::Target},
    static_ref,
};

define_fast_key!(
    /// A fast type constructor for `Complex<f32>`
    pub ComplexF32,
    Complex<f32>
);
define_fast_key!(
    /// A fast type constructor for `Complex<f64>`
    pub ComplexF64,
    Complex<f64>
);

define_static_ref!(COMPLEX_UNION_ALL, UnionAll, "Base.Complex");

unsafe impl<T: ValidField> ValidLayout for Complex<T> {
    fn valid_layout(ty: Value) -> bool {
        if !ty.is::<DataType>() {
            return false;
        }

        unsafe {
            let ty = ty.cast_unchecked::<DataType>();
            if ty.n_fields() != Some(2) {
                return false;
            }

            let field_tys = ty.field_types();
            let field_tys = field_tys.data();
            let field_tys = field_tys.as_atomic_slice().assume_immutable_non_null();

            if !T::valid_field(field_tys[0]) {
                return false;
            }

            if !T::valid_field(field_tys[1]) {
                return false;
            }
        }

        true
    }

    fn type_object<'target, Tgt: Target<'target>>(target: &Tgt) -> Value<'target, 'static> {
        static_ref!(COMPLEX_UNION_ALL, target).as_value()
    }
}

unsafe impl<T: ValidField> Typecheck for Complex<T> {
    fn typecheck(t: DataType) -> bool {
        Self::valid_layout(t.as_value())
    }
}

unsafe impl<T: Clone> Unbox for Complex<T> {
    type Output = Self;
}

unsafe impl<T: ValidField> ValidField for Complex<T> {
    fn valid_field(ty: Value) -> bool {
        Self::valid_layout(ty)
    }
}

unsafe impl<T: IsBits + ValidField> IsBits for Complex<T> {}

unsafe impl<T: ConstructType> ConstructType for Complex<T> {
    type Static = Complex<T::Static>;

    fn construct_type_uncached<'target, Tgt>(
        target: Tgt,
    ) -> crate::prelude::ValueData<'target, 'static, Tgt>
    where
        Tgt: Target<'target>,
    {
        target.with_local_scope::<_, 1>(|target, mut frame| {
            let t = T::construct_type(&mut frame);
            let complex_ua = static_ref!(COMPLEX_UNION_ALL, &frame);
            let complex_t = unsafe { complex_ua.apply_types_unchecked(target, [t]) };

            complex_t
        })
    }

    fn construct_type_with_env_uncached<'target, Tgt>(
        target: Tgt,
        env: &crate::data::types::construct_type::TypeVarEnv,
    ) -> crate::prelude::ValueData<'target, 'static, Tgt>
    where
        Tgt: Target<'target>,
    {
        target.with_local_scope::<_, 1>(|target, mut frame| {
            let t = T::construct_type_with_env(&mut frame, env);
            let complex_ua = static_ref!(COMPLEX_UNION_ALL, &frame);
            let complex_t = unsafe { complex_ua.apply_types_unchecked(target, [t, t]) };

            complex_t
        })
    }

    fn base_type<'target, Tgt>(target: &Tgt) -> Option<Value<'target, 'static>>
    where
        Tgt: Target<'target>,
    {
        Some(static_ref!(COMPLEX_UNION_ALL, target).as_value())
    }
}

unsafe impl<T: IsBits + ConstructType> CCallArg for Complex<T> {
    type CCallArgType = Self;
    type FunctionArgType = Self;
}

unsafe impl<T: IsBits + ConstructType> CCallReturn for Complex<T> {
    type FunctionReturnType = Self;
    type CCallReturnType = Self;
    type ReturnAs = Self;

    unsafe fn return_or_throw(self) -> Self::ReturnAs {
        self
    }
}