Rework ffi with new logging, error handling and some improvements in arch and safe

Cargo.toml

@@ -1,8 +1,9 @@
 [workspace]
 
 members = [
-    "doublets-ffi",
     "doublets",
+    "doublets-ffi",
+    "doublets-ffi/examples/rust",
 
     # dev
     "dev-deps/mem-rs",

doublets-ffi/Cargo.toml

@@ -4,17 +4,18 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib", "staticlib"]
+crate-type = ["cdylib", "staticlib", "lib"]
 
 [dependencies]
-log = "0.4.14"
-libc = "0.2.100"
-tracing-subscriber = "0.3.3"
-tracing-log = "0.1.2"
-tracing = "0.1.29"
 doublets = { path = "../doublets" }
 ffi-attributes = { path = "ffi-attributes" }
-env-decorators = { path = "env-decorators" }
+
+tap = { version = "1.0.1" }
+log-panics = { version = "2.1.0" }
+
+crossbeam-channel = { version = "0.5.6" }
+tracing = { version = "0.1.36" }
+tracing-subscriber = { version = "0.3.15", features = ["env-filter", "json"] }
 
 [package.log]
 features = ["release_max_level_error"]

doublets-ffi/examples/rust/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "doublets-ffi-examples"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+doublets-ffi = { path = "../../../doublets-ffi" }
+doublets = { path = "../../../doublets" }
+tracing = { version = "0.1.36" }

doublets-ffi/examples/rust/examples/all-logs.rs

@@ -0,0 +1,31 @@
+use doublets_ffi::{
+    export::{doublets_create_log_handle, doublets_free_log_handle},
+    FFICallbackContext,
+};
+use std::{
+    ffi::{c_char, CStr, CString},
+    ptr,
+};
+
+unsafe extern "C" fn callback(_: FFICallbackContext, ptr: *const c_char) {
+    let cstr = CStr::from_ptr(ptr);
+    print!("{}", cstr.to_str().unwrap());
+}
+
+fn main() {
+    let ctx = ptr::null_mut();
+    let level = CString::new("trace").unwrap();
+    let use_ansi = true;
+    let use_json = false;
+    unsafe {
+        let handle = doublets_create_log_handle(ctx, callback, level.as_ptr(), use_ansi, use_json);
+
+        tracing::error!("SOMETHING IS SERIOUSLY WRONG!!!");
+        tracing::warn!("important informational messages; might indicate an error");
+        tracing::info!("general informational messages relevant to users");
+        tracing::debug!("diagnostics used for internal debugging of a library or application");
+        tracing::trace!("very verbose diagnostic events");
+
+        doublets_free_log_handle(handle);
+    }
+}

doublets-ffi/examples/rust/examples/doublets-context.rs

@@ -0,0 +1,59 @@
+use doublets::{
+    data::{Flow, LinksConstants},
+    Link,
+};
+use doublets_ffi::{
+    constants::Constants,
+    errors::DoubletsErrorKind,
+    export::{doublets_create_log_handle, doublets_free_log_handle},
+    store::{create, doublets_constants_u64, doublets_create_united_store_u64},
+    FFICallbackContext,
+};
+use std::{
+    ffi::{c_char, c_void, CStr, CString},
+    fs,
+    ptr::{null, null_mut},
+};
+
+unsafe extern "C" fn callback(_: FFICallbackContext, ptr: *const c_char) {
+    print!("{}", CStr::from_ptr(ptr).to_str().unwrap());
+}
+
+extern "C" fn create_cb<F>(ctx: FFICallbackContext, before: Link<u64>, after: Link<u64>) -> Flow
+where
+    F: FnMut(Link<u64>, Link<u64>),
+{
+    unsafe {
+        let handler = &mut *(ctx as *mut F);
+        (*handler)(before, after);
+        Flow::Continue
+    }
+}
+
+unsafe fn magic_create<F>(ptr: *mut c_void, handler: F)
+where
+    F: FnMut(Link<u64>, Link<u64>),
+{
+    let ctx = &mut (ptr, handler);
+    let _ = create(ptr, null(), 0, ctx as *mut _ as *mut _, create_cb::<F>);
+}
+
+fn main() {
+    let level = CString::new("trace").unwrap();
+    unsafe {
+        let handle = doublets_create_log_handle(null_mut(), callback, level.as_ptr(), true, false);
+
+        let path = CString::new("doublets.links").unwrap();
+        let mut store = doublets_create_united_store_u64(
+            path.as_ptr(),
+            Constants::from(LinksConstants::external()),
+        );
+
+        magic_create(store.assume() as *mut _ as *mut _, |before, after| {
+            print!("{before:?}\n{after:?}\n");
+        });
+
+        doublets_free_log_handle(handle);
+    }
+    let _ = fs::remove_file("doublets.links");
+}

doublets-ffi/examples/rust/examples/error-handling.rs

@@ -0,0 +1,72 @@
+use doublets::{
+    data::{Flow, LinksConstants},
+    Link,
+};
+use doublets_ffi::{
+    constants::Constants,
+    errors::{
+        doublets_read_error, doublets_read_error_as_not_found, doublets_read_error_message,
+        DoubletsErrorKind,
+    },
+    export::{doublets_create_log_handle, doublets_free_log_handle},
+    store::{constants_for_store, create_unit_store, delete, free_store},
+    FFICallbackContext,
+};
+use std::{
+    ffi::{c_char, CStr, CString},
+    fs,
+    ptr::{null, null_mut},
+};
+
+unsafe extern "C" fn callback(_: FFICallbackContext, ptr: *const c_char) {
+    print!("{}", CStr::from_ptr(ptr).to_str().unwrap());
+}
+
+extern "C" fn create_cb(_: FFICallbackContext, _: Link<u64>, _: Link<u64>) -> Flow {
+    Flow::Continue
+}
+
+fn main() {
+    let level = CString::new("trace").unwrap();
+    unsafe {
+        let handle = doublets_create_log_handle(null_mut(), callback, level.as_ptr(), true, false);
+
+        let path = CString::new("doublets.links").unwrap();
+        let mut store =
+            create_unit_store::<u64>(path.as_ptr(), Constants::from(LinksConstants::external()));
+
+        let ptr = store.assume() as *mut _ as *mut _;
+
+        let any = constants_for_store::<u64>(ptr).any;
+
+        let query = [1 /* not exists index */, any, any];
+        let result = delete::<u64>(ptr, query.as_ptr(), 3, null_mut(), create_cb);
+
+        if result as u8 != DoubletsErrorKind::None as u8 {
+            let memchr = |buf: &[u8]| buf.iter().position(|x| *x == 0).unwrap();
+
+            // last error - DON'T USE PTR AFTER NEW DOUBLETS OPERATION
+            let err = doublets_read_error();
+            let mut msg_buf = vec![0u8; 256];
+
+            doublets_read_error_message(msg_buf.as_mut_ptr().cast(), 256, err);
+
+            msg_buf.drain(memchr(&msg_buf) + 1..);
+
+            let cstring = CString::from_vec_with_nul(msg_buf).unwrap();
+            let str = cstring.to_str().unwrap();
+            tracing::error!("{}", str);
+
+            // forget `err` ptr - we not in manage it deallocation
+            let not_exists = doublets_read_error_as_not_found(err);
+            tracing::error!("duplication: link {} does not exists", not_exists);
+
+            // forget `err` ptr - we not in manage it deallocation
+        }
+
+        free_store::<u64>(ptr);
+
+        doublets_free_log_handle(handle);
+    }
+    let _ = fs::remove_file("doublets.links");
+}

doublets-ffi/examples/rust/examples/log-context.rs

@@ -0,0 +1,33 @@
+use doublets_ffi::{
+    export::{doublets_create_log_handle, doublets_free_log_handle},
+    FFICallbackContext,
+};
+use std::ffi::{c_char, CStr, CString};
+
+unsafe extern "C" fn callback(ctx: FFICallbackContext, ptr: *const c_char) {
+    let str = CStr::from_ptr(ptr).to_str().unwrap();
+    let ctx = &mut *(ctx as *mut usize);
+    *ctx += 1;
+
+    if *ctx % 2 == 0 {
+        print!("{str}");
+    } else {
+        eprint!("{str}");
+    }
+}
+
+fn main() {
+    let ctx = &mut 0usize as *mut usize;
+    let level = CString::new("trace").unwrap();
+    unsafe {
+        let handle = doublets_create_log_handle(ctx.cast(), callback, level.as_ptr(), true, false);
+
+        tracing::error!("SOMETHING IS SERIOUSLY WRONG!!!");
+        tracing::warn!("important informational messages; might indicate an error");
+        tracing::info!("general informational messages relevant to users");
+        tracing::debug!("diagnostics used for internal debugging of a library or application");
+        tracing::trace!("very verbose diagnostic events");
+
+        doublets_free_log_handle(handle);
+    }
+}

doublets-ffi/ffi-attributes/src/lib.rs

@@ -29,10 +29,28 @@ fn csharp_convention(s: String) -> String {
     .to_string()
 }
 
+fn rust_convention(s: String) -> String {
+    match s.as_str() {
+        "i8" => "i8",
+        "u8" => "u8",
+        "i16" => "i16",
+        "u16" => "u16",
+        "i32" => "i32",
+        "u32" => "u32",
+        "i64" => "i64",
+        "u64" => "u64",
+        s => {
+            panic!("{} is incompatible with doublets-ffi type", s)
+        }
+    }
+    .to_string()
+}
+
 #[derive(FromMeta, PartialEq, Eq, Debug)]
 #[allow(non_camel_case_types)]
 enum Conventions {
     csharp,
+    rust,
 }
 
 #[derive(FromMeta)]
@@ -136,6 +154,7 @@ pub fn specialize_for(args: TokenStream, input: TokenStream) -> TokenStream {
                 '*',
                 match &args.convention {
                     Conventions::csharp => csharp_convention(ty.clone()),
+                    Conventions::rust => rust_convention(ty.clone()),
                     _ => {
                         panic!("unknown convention")
                     }