1use std::ffi::{c_char, c_void};
11
12use std::sync::Arc;
13
14use rustorb_cdr::ValueHeader;
15use rustorb_core::TypeCode;
16
17use crate::host::{Host, Owned, Written, host_of};
18use crate::str_arg;
19use crate::stream::{RorbIn, RorbOut};
20
21pub const VALUE_NULL: i32 = 0;
23pub const VALUE_INDIRECTION: i32 = 1;
24pub const VALUE_NEW: i32 = 2;
25
26pub type ReleaseFn = Option<unsafe extern "C" fn(*mut c_void)>;
28
29#[derive(Debug)]
31pub struct Held {
32 ptr: *mut c_void,
33 release: ReleaseFn,
34 pub(crate) key: Option<u64>,
36 _host: Option<Arc<Host>>,
38}
39
40impl Held {
41 pub(crate) fn take(&mut self) -> (*mut c_void, ReleaseFn) {
43 (self.ptr, self.release.take())
44 }
45}
46
47impl Drop for Held {
48 fn drop(&mut self) {
49 if let Some(release) = self.release {
50 unsafe { release(self.ptr) };
51 }
52 }
53}
54
55#[unsafe(no_mangle)]
58pub unsafe extern "C" fn rorb_out_write_null_value(out: *mut RorbOut) {
59 unsafe { &mut *out }.with(|s| {
60 s.write_null_value();
61 Ok(())
62 });
63}
64
65#[unsafe(no_mangle)]
69pub unsafe extern "C" fn rorb_out_begin_value(
70 out: *mut RorbOut,
71 key: u64,
72 count: usize,
73 ids: *const *const c_char,
74 id_lens: *const usize,
75 chunked: i32,
76) -> i32 {
77 unsafe { begin_value(&mut *out, key, None, count, ids, id_lens, chunked) }
78}
79
80#[unsafe(no_mangle)]
83pub unsafe extern "C" fn rorb_out_keeps_hosts(out: *mut RorbOut) -> i32 {
84 i32::from(unsafe { &*out }.written.is_some())
85}
86
87#[unsafe(no_mangle)]
93pub unsafe extern "C" fn rorb_out_begin_host_value(
94 out: *mut RorbOut,
95 key: u64,
96 host: *mut c_void,
97 release: ReleaseFn,
98 count: usize,
99 ids: *const *const c_char,
100 id_lens: *const usize,
101 chunked: i32,
102) -> i32 {
103 let host = Owned::new(host, release);
104 unsafe { begin_value(&mut *out, key, Some(host), count, ids, id_lens, chunked) }
105}
106
107unsafe fn begin_value(
108 out: &mut RorbOut,
109 key: u64,
110 host: Option<Owned>,
111 count: usize,
112 ids: *const *const c_char,
113 id_lens: *const usize,
114 chunked: i32,
115) -> i32 {
116 let mut state = false;
117 let mut slot = 0;
118 out.with(|s| {
119 let mut list = Vec::with_capacity(count);
120 for i in 0..count {
121 list.push(unsafe { str_arg(*ids.add(i), *id_lens.add(i)) }?);
122 }
123 slot = s.value_count();
124 state = s.begin_value(key, &list, chunked != 0)?;
125 Ok(())
126 });
127 let state = state && out.error.is_none();
128 if state {
129 if let Some(written) = &mut out.written {
130 written.push(Written { slot, key, host });
131 }
132 }
133 i32::from(state)
134}
135
136#[unsafe(no_mangle)]
137pub unsafe extern "C" fn rorb_out_end_value(out: *mut RorbOut) {
138 unsafe { &mut *out }.with(|s| Ok(s.end_value()?));
139}
140
141#[unsafe(no_mangle)]
148pub unsafe extern "C" fn rorb_in_read_value_header(
149 input: *mut RorbIn,
150 slot: *mut usize,
151 id_count: *mut usize,
152) -> i32 {
153 let input = unsafe { &mut *input };
154 let e = input.marshal();
155 let header = input.read(|s| s.read_value_header().map(Some).map_err(|_| e));
156 unsafe {
157 *slot = 0;
158 *id_count = 0;
159 }
160 match header {
161 None | Some(ValueHeader::Null) => VALUE_NULL,
162 Some(ValueHeader::Indirection(n)) => {
163 input.hold_host(n);
165 unsafe { *slot = n };
166 VALUE_INDIRECTION
167 }
168 Some(ValueHeader::Value { slot: n, ids, .. }) => {
169 unsafe { *slot = n };
170 if input.hold_host(n) {
171 let e = input.marshal();
174 input.read(|s| s.end_value().map_err(|_| e));
175 return VALUE_INDIRECTION;
176 }
177 unsafe { *id_count = ids.len() };
178 input.value_ids = ids;
179 VALUE_NEW
180 }
181 }
182}
183
184impl RorbIn {
185 fn hold_host(&mut self, slot: usize) -> bool {
189 if matches!(self.values.get(slot), Some(Some(_))) {
190 return false;
191 }
192 let Some(host) = self
193 .bound
194 .as_ref()
195 .and_then(|b| b.get(slot))
196 .and_then(host_of)
197 else {
198 return false;
199 };
200 if self.values.len() <= slot {
201 self.values.resize_with(slot + 1, || None);
202 }
203 self.values[slot] = Some(Held {
204 ptr: host.ptr,
205 release: None,
206 key: None,
207 _host: Some(host),
208 });
209 true
210 }
211}
212
213#[unsafe(no_mangle)]
216pub unsafe extern "C" fn rorb_in_value_id(
217 input: *mut RorbIn,
218 index: usize,
219 len: *mut usize,
220) -> *const c_char {
221 let input = unsafe { &*input };
222 match input.value_ids.get(index) {
223 Some(id) => {
224 unsafe { *len = id.len() };
225 id.as_ptr().cast()
226 }
227 None => {
228 unsafe { *len = 0 };
229 c"".as_ptr()
230 }
231 }
232}
233
234#[unsafe(no_mangle)]
237pub unsafe extern "C" fn rorb_in_end_value(input: *mut RorbIn) {
238 let input = unsafe { &mut *input };
239 let e = input.marshal();
240 input.read(|s| s.end_value().map_err(|_| e));
241}
242
243#[unsafe(no_mangle)]
246pub unsafe extern "C" fn rorb_in_set_value(
247 input: *mut RorbIn,
248 slot: usize,
249 ptr: *mut c_void,
250 release: ReleaseFn,
251) {
252 unsafe { set_value(&mut *input, slot, None, ptr, release) }
253}
254
255#[unsafe(no_mangle)]
260pub unsafe extern "C" fn rorb_in_set_host_value(
261 input: *mut RorbIn,
262 slot: usize,
263 key: u64,
264 ptr: *mut c_void,
265 release: ReleaseFn,
266) {
267 unsafe { set_value(&mut *input, slot, Some(key), ptr, release) }
268}
269
270#[unsafe(no_mangle)]
273pub unsafe extern "C" fn rorb_in_keeps_hosts(input: *mut RorbIn) -> i32 {
274 i32::from(unsafe { &*input }.bound.is_some())
275}
276
277unsafe fn set_value(
278 input: &mut RorbIn,
279 slot: usize,
280 key: Option<u64>,
281 ptr: *mut c_void,
282 release: ReleaseFn,
283) {
284 if input.values.len() <= slot {
285 input.values.resize_with(slot + 1, || None);
286 }
287 input.values[slot] = Some(Held {
288 ptr,
289 release,
290 key,
291 _host: None,
292 });
293}
294
295#[unsafe(no_mangle)]
298pub unsafe extern "C" fn rorb_in_get_value(input: *mut RorbIn, slot: usize) -> *mut c_void {
299 match unsafe { &*input }.values.get(slot) {
300 Some(Some(held)) => held.ptr,
301 _ => std::ptr::null_mut(),
302 }
303}
304
305#[unsafe(no_mangle)]
310pub unsafe extern "C" fn rorb_register_value_type(tc: *const TypeCode) {
311 if let Some(tc) = unsafe { tc.as_ref() } {
312 rustorb_core::register_value_type(tc);
313 }
314}
315
316pub type ResolveFn =
319 Option<unsafe extern "C" fn(*mut c_void, *const c_char, usize) -> *mut TypeCode>;
320
321struct Resolver {
322 resolve: unsafe extern "C" fn(*mut c_void, *const c_char, usize) -> *mut TypeCode,
323 context: *mut c_void,
324}
325
326unsafe impl Send for Resolver {}
328unsafe impl Sync for Resolver {}
329
330impl Resolver {
331 fn find(&self, id: &str) -> Option<TypeCode> {
332 let tc = unsafe { (self.resolve)(self.context, id.as_ptr().cast(), id.len()) };
333 if tc.is_null() {
334 None
335 } else {
336 Some(*unsafe { Box::from_raw(tc) })
337 }
338 }
339}
340
341#[unsafe(no_mangle)]
344pub unsafe extern "C" fn rorb_set_value_type_resolver(resolve: ResolveFn, context: *mut c_void) {
345 let resolver = resolve.map(|resolve| {
346 let r = Resolver { resolve, context };
347 std::sync::Arc::new(move |id: &str| r.find(id))
348 as std::sync::Arc<rustorb_core::ValueTypeResolver>
349 });
350 rustorb_core::set_value_type_resolver(resolver);
351}