Merge pull request #9 from midassystems/c_bindings

C bindings

Author: anthonyb8

.gitignore

@@ -7,6 +7,7 @@ __pycache__/
 
 # C extensions
 *.so
+*.bin
 
 # Distribution / packaging
 .Python

Cargo.toml

@@ -2,7 +2,7 @@
 members = [
   "rust", 
   "python",
-  # "mbn_c",
+  "c",
 ]
 resolver = "2"
 

c/CMakeLists.txt

@@ -0,0 +1,69 @@
+cmake_minimum_required(VERSION 3.14)
+project(mbn_c VERSION 1.0 LANGUAGES CXX)
+
+# Path to vcpkg toolchain
+set(CMAKE_TOOLCHAIN_FILE "${CMAKE_SOURCE_DIR}/vcpkg_installed/scripts/buildsystems/vcpkg.cmake")
+
+# Use modern C++ standards
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_OSX_DEPLOYMENT_TARGET "13.3")
+
+
+enable_testing()
+find_package(GTest CONFIG REQUIRED)
+
+# Path to the cbindgen-generated header
+set(CBINDGEN_HEADER_DIR "${CMAKE_SOURCE_DIR}/../target")
+
+# Rust binary
+set(RUST_PROJECT_DIR "${CMAKE_SOURCE_DIR}/..")
+set(RUST_LIB_DIR "${RUST_PROJECT_DIR}/target/debug") 
+set(RUST_LIB "${RUST_LIB_DIR}/libmbn_c.a")
+
+# Add a custom command to build Rust library using Cargo
+add_custom_command(
+    OUTPUT "${RUST_LIB}"
+    COMMAND cargo build --manifest-path "${RUST_PROJECT_DIR}/Cargo.toml"
+    WORKING_DIRECTORY "${RUST_PROJECT_DIR}"
+    COMMENT "Building Rust library with Cargo"
+    VERBATIM
+)
+
+# Add a custom target to ensure Rust builds before the C++ tests
+add_custom_target(build_rust ALL DEPENDS "${RUST_LIB}")
+
+
+# Test executable
+add_executable(MbnTests 
+    tests/test_decode_c.cpp 
+    tests/test_encode_c.cpp
+    tests/test_records.cpp
+)
+
+# Include the cbindgen header directory
+target_include_directories(MbnTests PRIVATE 
+    "${CBINDGEN_HEADER_DIR}" # Include the directory containing mbn.h
+    "${RUST_LIB_DIR}"
+)
+
+# Link the Rust library
+target_link_libraries(MbnTests PRIVATE "${RUST_LIB}")
+
+# Link Google Test to the tests
+target_link_libraries(MbnTests PRIVATE 
+    GTest::gtest 
+    GTest::gtest_main 
+)
+
+# Add tests to CTest
+add_test(NAME MbnTests COMMAND MbnTests)
+
+# Link macOS frameworks (CoreFoundation and Security)
+if (APPLE)
+    target_link_libraries(MbnTests PRIVATE 
+        "-framework CoreFoundation"
+        "-framework Security"
+        "-framework SystemConfiguration"
+    )
+endif()

c/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "mbn_c"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["staticlib"] # for .a static lib
+
+
+[dependencies]
+mbinary = {path = "../rust"}
+libc ="0.2.168"
+cbindgen = { version = "0.27.0" }
+
+[build-dependencies]
+cbindgen = { version = "0.27.0", default-features = false }

c/build.rs

@@ -0,0 +1,13 @@
+use std::env;
+
+fn main() {
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let config: cbindgen::Config = cbindgen::Config::from_file("cbindgen.toml").unwrap();
+
+    cbindgen::Builder::new()
+        .with_crate(crate_dir)
+        .with_config(config)
+        .generate()
+        .expect("Unable to generate bindings")
+        .write_to_file("../target/mbinary.h");
+}

c/build.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+options() {
+	echo "1 - Build"
+	echo "2 - Run"
+	echo "3 - Build & Test"
+	echo "4 - Build & Run"
+}
+
+build() {
+	# cd ../
+	cargo build
+
+	# cd mbn_c
+	# Build artifacts
+	cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -B build
+
+	# Build
+	cmake --build ./build
+
+}
+
+run() {
+	# Run binary
+	./bin/mbn
+}
+
+tester() {
+	if cd build; then
+		ctest --verbose
+	fi
+}
+
+# Main
+while true; do
+	options
+	read -r option
+
+	case $option in
+	1)
+		build
+		break
+		;;
+	2)
+		run
+		break
+		;;
+	3)
+		build
+		tester
+		break
+		;;
+	4)
+		build
+		run
+		break
+		;;
+	*) echo "Choose a different one." ;;
+	esac
+done

c/cbindgen.toml

@@ -0,0 +1,26 @@
+language = "C"
+pragma_once = true
+line_length = 100
+tab_width = 4
+sys_includes = ["stdio.h"]
+
+# Affects enum typedefs
+cpp_compat = true
+
+[export]
+include =["RecordHeader","RType", "Mbp1Msg", "OhlcvMsg", "TradesMsg", "BboMsg", "TbboMsg", "BidAskPair", "RecordData","CRecordEnum" , "Side", "Action"]
+
+[export.rename]
+"FILE" = "FILE"
+
+[enum]
+prefix_with_name = false
+
+[parse]
+parse_deps = true
+include = ["mbinary"]
+extra_bindings = ["mbinary"]
+
+# [defines]
+# cbindgen = true
+

c/src/decode.rs

@@ -0,0 +1,100 @@
+use mbinary::decode::RecordDecoder;
+use std::ffi::CStr;
+use std::fs::File;
+use std::io::{BufReader, Cursor, Read};
+use std::ptr;
+use std::slice;
+
+use crate::records::CRecordEnum;
+
+/// C-compatible wrapper around RecordDecoder
+pub struct CRecordDecoder {
+    decoder: RecordDecoder<Box<dyn Read>>,
+}
+
+/// Create a new `CRecordDecoder` with an in-memory buffer as the source.
+#[no_mangle]
+pub extern "C" fn create_buffer_decoder(
+    source: *const u8,
+    source_size: usize,
+) -> *mut CRecordDecoder {
+    if source.is_null() || source_size == 0 {
+        return ptr::null_mut();
+    }
+
+    // Convert the raw pointer and size to a Vec<u8>
+    let source_slice = unsafe { slice::from_raw_parts(source, source_size) };
+    let source_buffer = Cursor::new(source_slice.to_vec());
+
+    let decoder = CRecordDecoder {
+        decoder: RecordDecoder::new(Box::new(source_buffer)),
+    };
+
+    Box::into_raw(Box::new(decoder))
+}
+
+/// Create a new `CRecordDecoder` with a file as the source.
+#[no_mangle]
+pub extern "C" fn create_file_decoder(file_path: *const libc::c_char) -> *mut CRecordDecoder {
+    if file_path.is_null() {
+        return ptr::null_mut();
+    }
+
+    // Convert C string to Rust Path
+    let c_str = unsafe { CStr::from_ptr(file_path) };
+    let path = match c_str.to_str() {
+        Ok(path) => path,
+        Err(_) => return ptr::null_mut(),
+    };
+
+    let decoder = match create_decoder_from_file(path) {
+        Ok(f) => f,
+        Err(_) => return ptr::null_mut(),
+    };
+
+    let c_decoder = CRecordDecoder { decoder };
+
+    Box::into_raw(Box::new(c_decoder))
+}
+
+// Helper function, not exposed to C directly.
+fn create_decoder_from_file(
+    file_path: &str,
+) -> Result<RecordDecoder<Box<dyn Read>>, std::io::Error> {
+    let file = File::open(file_path)?;
+    let buf_reader = BufReader::new(file);
+    let boxed_reader: Box<dyn Read> = Box::new(buf_reader);
+    Ok(RecordDecoder::new(boxed_reader))
+}
+
+/// Iteratively decodes records, returning false when all records are decoded.
+#[no_mangle]
+pub extern "C" fn decoder_iter(decoder: *mut CRecordDecoder, output: *mut CRecordEnum) -> bool {
+    if decoder.is_null() || output.is_null() {
+        return false;
+    }
+
+    let decoder = unsafe { &mut *decoder };
+    let mut iterator = decoder.decoder.decode_iterator();
+
+    match iterator.next() {
+        Some(Ok(record_enum)) => {
+            let c_record: CRecordEnum = record_enum.into();
+            unsafe { ptr::write(output, c_record) };
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Destroy the `CRecordDecoder`
+#[no_mangle]
+pub extern "C" fn destroy_record_decoder(decoder: *mut CRecordDecoder) {
+    if decoder.is_null() {
+        return;
+    }
+
+    unsafe {
+        let _ = Box::from_raw(decoder);
+    }
+}