UPD: Updated C bindings to stable working.

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"
 

mbn_c/CMakeLists.txt c/CMakeLists.txtmbn_c/CMakeLists.txt renamed to c/CMakeLists.txt

@@ -11,16 +11,14 @@ set(CMAKE_OSX_DEPLOYMENT_TARGET "13.3")
 
 
 enable_testing()
-
-# Find Google Test
 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")  # or target/release for release builds
+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
@@ -38,8 +36,9 @@ add_custom_target(build_rust ALL DEPENDS "${RUST_LIB}")
 
 # Test executable
 add_executable(MbnTests 
-    tests/test_decode_c.cpp # Add your test files here
+    tests/test_decode_c.cpp 
     tests/test_encode_c.cpp
+    tests/test_records.cpp
 )
 
 # Include the cbindgen header directory

mbn_c/Cargo.toml c/Cargo.tomlmbn_c/Cargo.toml renamed to c/Cargo.toml

@@ -8,7 +8,7 @@ crate-type = ["staticlib"] # for .a static lib
 
 
 [dependencies]
-mbn = {path = "../rust"}
+mbinary = {path = "../rust"}
 libc ="0.2.168"
 cbindgen = { version = "0.27.0" }
 

mbn_c/build.rs c/build.rsmbn_c/build.rs renamed to c/build.rs

@@ -9,5 +9,5 @@ fn main() {
         .with_config(config)
         .generate()
         .expect("Unable to generate bindings")
-        .write_to_file("../target/mbn_c.h");
+        .write_to_file("../target/mbinary.h");
 }

mbn_c/build.sh c/build.shmbn_c/build.sh renamed to c/build.sh

@@ -3,22 +3,23 @@ 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"]
+include =["RecordHeader","RType", "Mbp1Msg", "OhlcvMsg", "TradesMsg", "BboMsg", "TbboMsg", "BidAskPair", "RecordData","CRecordEnum" , "Side", "Action"]
 
 [export.rename]
 "FILE" = "FILE"
 
 [enum]
-prefix_with_name = true
+prefix_with_name = false
 
 [parse]
 parse_deps = true
-include = ["mbn"]
-extra_bindings = ["mbn"]
+include = ["mbinary"]
+extra_bindings = ["mbinary"]
 
 # [defines]
 # cbindgen = true

mbn_c/cbindgen.toml c/cbindgen.tomlmbn_c/cbindgen.toml renamed to c/cbindgen.toml

@@ -1,11 +1,11 @@
-use mbn::{decode::RecordDecoder, record_ref::RecordRef, records::RecordHeader};
+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::RecordData;
+use crate::records::CRecordEnum;
 
 /// C-compatible wrapper around RecordDecoder
 pub struct CRecordDecoder {
@@ -19,77 +19,72 @@ pub extern "C" fn create_buffer_decoder(
     source_size: usize,
 ) -> *mut CRecordDecoder {
     if source.is_null() || source_size == 0 {
-        return ptr::null_mut(); // Return null pointer for invalid input
+        return ptr::null_mut();
     }
 
-    // Safety: Convert the raw pointer and size to a Vec<u8>
+    // 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)) // Return a raw pointer for FFI
+    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(); // Return null pointer for invalid input
+        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(), // Invalid UTF-8
+        Err(_) => return ptr::null_mut(),
     };
 
     let decoder = match create_decoder_from_file(path) {
         Ok(f) => f,
-        Err(_) => return ptr::null_mut(), // Failed to open file
+        Err(_) => return ptr::null_mut(),
     };
 
     let c_decoder = CRecordDecoder { decoder };
 
-    Box::into_raw(Box::new(c_decoder)) // Return a raw pointer for FFI
+    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 decode_records(
-    decoder: *mut CRecordDecoder,
-    output_size: *mut usize,
-) -> *mut RecordData {
-    if decoder.is_null() || output_size.is_null() {
-        return std::ptr::null_mut(); // Invalid pointers
+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 };
-
-    // Decode records into a Vec<TestRecord>
-    let records = match decoder.decoder.decode_to_owned() {
-        Ok(records) => records,
-        Err(_) => return std::ptr::null_mut(), // Decoding error
-    };
-
-    // Map RecordEnum to RecordData
-    let records_data: Vec<RecordData> = records
-        .into_iter()
-        .map(|record_enum| record_enum.into())
-        .collect();
-
-    // println!("{:?}", &records);
-
-    // Return the number of records
-    unsafe {
-        *output_size = records_data.len();
+    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,
     }
-
-    // Allocate memory for the records on the heap and pass ownership to the caller
-    let records_box = records_data.into_boxed_slice();
-    Box::into_raw(records_box) as *mut RecordData
 }
 
 /// Destroy the `CRecordDecoder`
@@ -100,15 +95,6 @@ pub extern "C" fn destroy_record_decoder(decoder: *mut CRecordDecoder) {
     }
 
     unsafe {
-        let _ = Box::from_raw(decoder); // Drop the decoder
+        let _ = Box::from_raw(decoder);
     }
 }
-
-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))
-}

mbn_c/src/decode.rs c/src/decode.rsmbn_c/src/decode.rs renamed to c/src/decode.rs

@@ -0,0 +1,113 @@
+use mbinary::encode::RecordEncoder;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+use std::path::Path;
+
+use crate::records::RecordData;
+
+/// C-compatible wrapper around RecordEncoder
+pub struct CRecordEncoder {
+    buffer: Vec<u8>,
+}
+
+/// Create a new 'CRecordEncoder', encoding to a buffer.
+#[no_mangle]
+pub extern "C" fn create_record_encoder() -> *mut CRecordEncoder {
+    let c_encoder = CRecordEncoder { buffer: Vec::new() };
+    Box::into_raw(Box::new(c_encoder))
+}
+
+#[no_mangle]
+pub extern "C" fn encode_records(
+    encoder: *mut CRecordEncoder,
+    records: *const RecordData,
+    record_count: usize,
+) -> i32 {
+    if encoder.is_null() || records.is_null() {
+        return -1;
+    }
+
+    let encoder = unsafe { &mut *encoder };
+    encoder.buffer.clear(); // Clear previous data
+    let mut record_encoder = RecordEncoder::new(&mut encoder.buffer);
+
+    for i in 0..record_count {
+        // records is pointer to first RecordData, this iterated the pointer to i-th RecordData
+        let record = unsafe { &*records.add(i) };
+        let record_ref = record.to_record_ref();
+
+        // Attempt to encode the record
+        if let Err(_) = record_encoder.encode_record(&record_ref) {
+            return -2;
+        }
+    }
+
+    0
+}
+
+#[no_mangle]
+pub extern "C" fn get_encoded_data(
+    encoder: *const CRecordEncoder,
+    output: *mut u8,
+    output_size: *mut usize,
+) -> i32 {
+    if encoder.is_null() || output_size.is_null() {
+        return -1;
+    }
+
+    let encoder = unsafe { &*encoder };
+    let buffer = &encoder.buffer;
+
+    if !output.is_null() {
+        let output_slice = unsafe { std::slice::from_raw_parts_mut(output, buffer.len()) };
+        output_slice.copy_from_slice(buffer);
+    }
+
+    // Return the size of the buffer
+    unsafe {
+        *output_size = buffer.len();
+    }
+
+    0
+}
+
+#[no_mangle]
+pub extern "C" fn write_buffer_to_file(
+    encoder: *mut CRecordEncoder,
+    file_path: *const c_char,
+    append: bool,
+) -> i32 {
+    if encoder.is_null() || file_path.is_null() {
+        return -1;
+    }
+
+    // Convert the C string file path to a Rust Path
+    let c_str = unsafe { CStr::from_ptr(file_path) };
+    let path = match c_str.to_str() {
+        Ok(s) => Path::new(s),
+        Err(_) => return -2,
+    };
+
+    let encoder = unsafe { &mut *encoder };
+    let record_encoder = RecordEncoder::new(&mut encoder.buffer);
+
+    // Write the buffer to the file
+    if let Err(_) = record_encoder.write_to_file(path, append) {
+        return -4;
+    }
+
+    0
+}
+
+/// Destroy the `CRecordEncoder`
+#[no_mangle]
+pub extern "C" fn destroy_record_encoder(encoder: *mut CRecordEncoder) {
+    if encoder.is_null() {
+        return;
+    }
+
+    // Convert the raw pointer back to a Box and drop it
+    unsafe {
+        let _ = Box::from_raw(encoder);
+    }
+}