anyslot 0.1.1

global bridge c-bindings of any type slot for Rust
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

//! global bridge c-bindings of any type slot for Rust
//! anyslot integrates bindings to cppbridge
//!
//! - cc-rs https://crates.io/crates/cc
//! - bindgen https://crates.io/crates/bindgen
//!
//! # cc-rs
//!
//! - include/bridge.hpp
//! - src/bridge.cpp
//!
//! # bindgen
//!
//! from
//!
//!  - include/bridge.hpp
//!
//! to
//!
//!  - include/bridge_bindings.rs
//!

pub mod cppbridge;
pub use cppbridge::*;

pub use std::pin::Pin;
pub use std::sync::Arc;
pub use std::cell::RefCell;
pub use std::borrow::BorrowMut;

/// trait TBridgeGlobal
pub trait TBridgeGlobal {
  /// constructor
  fn void() -> Self;
}

/// TBridgeGlobal for bridge_global
impl TBridgeGlobal for bridge_global {
  /// constructor
  fn void() -> Self {
    bridge_global{num: 0, buf: [0; 8]}
  }
}

/// fake for any pinned type
#[macro_export]
macro_rules! any_pinned_init_slots {
  ($n: expr) => {
    unsafe {
      let r = bridge_global_init_slots($n);
      if r == 0 {
        panic!("not allocated area: bridge_global_init_slots");
      }
      r
    }
  }
}
pub use any_pinned_init_slots;

/// fake for any pinned type
#[macro_export]
macro_rules! any_pinned_dispose_slots {
  () => {
    unsafe {
      let r = bridge_global_dispose_slots();
      if r == 0 {
        panic!("something wrong to free: bridge_global_dispose_slots");
      }
      r
    }
  }
}
pub use any_pinned_dispose_slots;

/// fake for any pinned type
#[macro_export]
macro_rules! any_pinned_set_bg_mut {
  ($i: ty, $n: expr) => {
    let mut abg = Arc::new(RefCell::new(<$i>::void()));
    let mut pbg = Pin::new(&mut abg); // to keep lifetime
    pbg.set_bg_mut($n);
  }
}
pub use any_pinned_set_bg_mut;

/// fake with_bg_mut for any pinned type
#[macro_export]
macro_rules! any_pinned_with_bg_mut {
  ($i: ty, $n: expr, $f: expr) => {
    Pin::<&mut Arc<RefCell<$i>>>::with_bg_mut($n, $f)
  }
}
pub use any_pinned_with_bg_mut;

/// trait TGlobalSetGet
pub trait TGlobalSetGet<T> {
  /// set bg
  fn set_bg_mut(&mut self, n: usize);
  /// with bg
  fn with_bg_mut<F>(n: usize, f: F) where F: FnMut(&mut T) -> ();
}

/// TGlobalSetGet for Pin<&mut Arc<RefCell<T>>>
impl<T> TGlobalSetGet<T> for Pin<&mut Arc<RefCell<T>>> {
  /// set bg
  fn set_bg_mut(&mut self, n: usize) {
    unsafe {
      match bridge_global_setter(n, self.borrow_mut().as_ptr()
        as *mut T as *mut bridge_global) {
        0 => panic!("not allocated area: bridge_global_setter"),
        _ => ()
      }
    }
  }
  /// with bg
  fn with_bg_mut<F>(n: usize, mut f: F) where F: FnMut(&mut T) -> () {
    f(unsafe {
      let p = bridge_global_getter(n);
      if p == 0 as *mut bridge_global {
        panic!("not allocated area: bridge_global_getter");
      }
      &mut std::slice::from_raw_parts_mut(p as *mut T, 1)[0] // fake
    })
  }
}