yad_core 2.0.0

YAD-Core manages the lowest level of YAD, its primitive values.
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
142
143
144

use float16::f16;
use crate::Value;

/// Creates a new [`Value`] containing an unsigned 16-bit integer (`u16`)
/// and returns a raw pointer suitable for FFI.
///
/// # Parameters
/// - `val`: The `u16` value to wrap.
///
/// # Returns
/// A raw pointer to a heap-allocated [`Value`] containing `val`.
/// The caller is responsible for freeing this pointer to prevent memory leaks.
///
/// # Safety
/// - The pointer is allocated on the heap and must be manually deallocated.
/// - Must not be dereferenced after being freed.
#[unsafe(no_mangle)]
pub extern "C" fn value_from_uint_16(val: u16) -> *mut Value {
    Box::into_raw(Box::new(Value::from(val)))
}

/// Creates a new [`Value`] containing a signed 16-bit integer (`i16`)
/// and returns a raw pointer suitable for FFI.
///
/// # Parameters
/// - `val`: The `i16` value to wrap.
///
/// # Returns
/// A raw pointer to a heap-allocated [`Value`] containing `val`.
/// The caller is responsible for freeing this pointer to prevent memory leaks.
///
/// # Safety
/// - The pointer must be properly deallocated.
/// - Must not be dereferenced after being freed.
#[unsafe(no_mangle)]
pub extern "C" fn value_from_int_16(val: i16) -> *mut Value {
    Box::into_raw(Box::new(Value::from(val)))
}

/// Creates a new [`Value`] representing a 16-bit floating point (`f16`)
/// by converting a 32-bit float (`f32`) to `f16`.
///
/// # Parameters
/// - `val`: The `f32` value to convert.
///
/// # Returns
/// A raw pointer to a heap-allocated [`Value`] containing the `f16`.
/// The caller is responsible for freeing this pointer.
///
/// # Safety
/// - The pointer must be manually deallocated.
/// - Must not be dereferenced after being freed.
/// - Precision loss may occur during the conversion from `f32` to `f16`.
#[unsafe(no_mangle)]
pub extern "C" fn value_as_f16_from_float(val: f32) -> *mut Value {
    Box::into_raw(Box::new(Value::from(f16::from_f32(val))))
}

/// Extracts a 16-bit floating point value (`f16`) from a [`Value`] and
/// writes it as a 32-bit float (`f32`) into the provided pointer.
///
/// # Parameters
/// - `value`: Pointer to a [`Value`] expected to contain an `f16`.
/// - `out`: Pointer to a `f32` where the result will be stored.
///
/// # Returns
/// - `true` if extraction and conversion succeed.
/// - `false` if `value` is null or does not contain a valid `f16`.
///
/// # Safety
/// - Both `value` and `out` must be valid, non-null pointers.
/// - `out` must point to a valid writable memory location.
#[unsafe(no_mangle)]
pub extern "C" fn float_from_f16_value(value: *mut Value, out: *mut f32) -> bool {
    if value.is_null() {
        return false;
    }
    unsafe {
        if let Ok(num) = <Value as TryInto<f16>>::try_into((&*value).to_owned()) {
            *out = num.to_f32();
            true
        } else {
            false
        }
    }
}

/// Extracts an unsigned 16-bit integer (`u16`) from a [`Value`] and writes
/// it into the provided pointer.
///
/// # Parameters
/// - `value`: Pointer to a [`Value`] expected to contain a `u16`.
/// - `out`: Pointer to a `u16` where the result will be stored.
///
/// # Returns
/// - `true` if extraction succeeds.
/// - `false` if `value` is null or does not contain a valid `u16`.
///
/// # Safety
/// - Both `value` and `out` must be valid, non-null pointers.
/// - `out` must point to a valid writable memory location.
#[unsafe(no_mangle)]
pub extern "C" fn uint16_from_value(value: *mut Value, out: *mut u16) -> bool {
    if value.is_null() {
        return false;
    }
    unsafe {
        if let Ok(num) = (&*value).try_into() {
            *out = num;
            true
        } else {
            false
        }
    }
}

/// Extracts a signed 16-bit integer (`i16`) from a [`Value`] and writes
/// it into the provided pointer.
///
/// # Parameters
/// - `value`: Pointer to a [`Value`] expected to contain an `i16`.
/// - `out`: Pointer to an `i16` where the result will be stored.
///
/// # Returns
/// - `true` if extraction succeeds.
/// - `false` if `value` is null or does not contain a valid `i16`.
///
/// # Safety
/// - Both `value` and `out` must be valid, non-null pointers.
/// - `out` must point to a valid writable memory location.
#[unsafe(no_mangle)]
pub extern "C" fn int16_from_value(value: *mut Value, out: *mut i16) -> bool {
    if value.is_null() {
        return false;
    }
    unsafe {
        if let Ok(num) = (&*value).try_into() {
            *out = num;
            true
        } else {
            false
        }
    }
}