#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(clippy::all)]
use std::ffi::c_void;
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
include!(concat!(env!("OUT_DIR"), "/msg_bindings.rs"));
include!(concat!(env!("OUT_DIR"), "/generate_types.rs"));
pub trait RawMessageBridge: Sized {
type CStruct;
fn descriptor() -> *const dds_topic_descriptor_t;
fn to_raw(self) -> Self::CStruct;
fn from_raw(raw: Self::CStruct) -> Self;
fn free_contents(&mut self);
}
#[derive(Debug, Clone)]
pub struct SampleInfo {
pub was_read: bool,
pub is_new_view: bool,
pub is_alive: bool,
pub valid_data: bool,
pub source_timestamp: dds_time_t,
pub instance_handle: dds_instance_handle_t,
pub publication_handle: dds_instance_handle_t,
}
impl From<dds_sample_info_t> for SampleInfo {
fn from(raw: dds_sample_info_t) -> Self {
Self {
was_read: raw.sample_state == dds_sample_state_DDS_SST_READ,
is_new_view: raw.view_state == dds_view_state_DDS_VST_NEW,
is_alive: raw.instance_state == dds_instance_state_DDS_IST_ALIVE,
valid_data: raw.valid_data,
source_timestamp: raw.source_timestamp,
instance_handle: raw.instance_handle,
publication_handle: raw.publication_handle,
}
}
}
pub struct Sample<T: RawMessageBridge> {
pub inner: T,
pub info: SampleInfo,
}
impl<T: RawMessageBridge> Sample<T> {
pub fn into_parts(self) -> (T, SampleInfo) {
let info = self.info.clone();
let inner = unsafe { std::ptr::read(&self.inner as *const T) };
std::mem::forget(self);
(inner, info)
}
}
impl<T: RawMessageBridge> std::ops::Deref for Sample<T> {
type Target = T;
fn deref(&self) -> &T {
&self.inner
}
}
impl<T: RawMessageBridge> std::ops::DerefMut for Sample<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.inner
}
}
impl<T: RawMessageBridge> Drop for Sample<T> {
fn drop(&mut self) {
self.inner.free_contents();
}
}
pub struct LoanedSample<T: RawMessageBridge> {
reader: dds_entity_t,
ptr: *mut c_void,
pub info: SampleInfo,
_phantom: std::marker::PhantomData<T>,
}
impl<T: RawMessageBridge> LoanedSample<T> {
pub fn new(reader: dds_entity_t, ptr: *mut c_void, info: SampleInfo) -> Self {
Self {
reader,
ptr,
info,
_phantom: std::marker::PhantomData,
}
}
pub fn get(&self) -> Option<&T::CStruct> {
if self.ptr.is_null() {
None
} else {
Some(unsafe { &*(self.ptr as *const T::CStruct) })
}
}
}
impl<T: RawMessageBridge> Drop for LoanedSample<T> {
fn drop(&mut self) {
if !self.ptr.is_null() {
unsafe {
dds_return_loan(self.reader, &mut self.ptr, 1);
}
}
}
}
unsafe impl<T: RawMessageBridge> Send for LoanedSample<T> {}
unsafe impl<T: RawMessageBridge> Sync for LoanedSample<T> {}
#[derive(Debug)]
pub struct CdrSample {
serdata: *mut ddsi_serdata,
pub info: SampleInfo,
}
impl CdrSample {
pub fn new(serdata: *mut ddsi_serdata, info: SampleInfo) -> Self {
Self { serdata, info }
}
pub fn as_ptr(&mut self) -> *mut ddsi_serdata {
self.serdata
}
}
unsafe impl Send for CdrSample {}
unsafe impl Sync for CdrSample {}