Proper implementation of get_cell_value_by_index.

Author: havarnov

bindings/dotnet/build.rs

@@ -4,7 +4,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     csbindgen::Builder::default()
         .input_extern_file("src/lib.rs")
         .csharp_class_name("NativeMethods")
-        .csharp_namespace("IronCalc")
+        .csharp_namespace("IronCalc.Native")
         .csharp_dll_name("libironcalc_dotnet")
         .csharp_use_function_pointer(true)
         .csharp_generate_const_filter(|_| true)

bindings/dotnet/ironcalc-dotnet/IronCalc.Tests/EvaluateTests.cs

@@ -21,13 +21,15 @@ public void Sum()
         using var model = Model.LoadFromXlsxBytes(bytes, "en",  "Europe/Oslo");
 
         var value = model.GetValue(0, 3, 1);
-        Assert.Equal(2, value);
+        var number = Assert.IsType<CellValue.Number>(value);
+        Assert.Equal(2, number.Value);
 
         model.SetUserInput(0, 1, 1, "4");
         model.SetUserInput(0, 2, 1, "6");
         model.Evaluate();
 
         var updated= model.GetValue(0, 3, 1);
-        Assert.Equal(10, updated);
+        var updatedNumber = Assert.IsType<CellValue.Number>(updated);
+        Assert.Equal(10, updatedNumber.Value);
     }
 }

bindings/dotnet/ironcalc-dotnet/IronCalc/CellValue.cs

@@ -0,0 +1,25 @@
+namespace IronCalc;
+
+public abstract class CellValue
+{
+    private CellValue()
+    {
+    }
+
+    public class None : CellValue;
+
+    public class Number : CellValue
+    {
+        public required double Value { get; init; }
+    }
+
+    public class Bool : CellValue
+    {
+        public required bool Value { get; init; }
+    }
+
+    public class String : CellValue
+    {
+        public required string Value { get; init; }
+    }
+}

bindings/dotnet/ironcalc-dotnet/IronCalc/IronCalc.g.cs

@@ -8,7 +8,7 @@
 using System.Runtime.InteropServices;
 
 
-namespace IronCalc
+namespace IronCalc.Native
 {
     internal static unsafe partial class NativeMethods
     {
@@ -27,12 +27,15 @@ internal static unsafe partial class NativeMethods
         [DllImport(__DllName, EntryPoint = "evaluate", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern void evaluate(ModelContext* context);
 
-        [DllImport(__DllName, EntryPoint = "get_value", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        internal static extern int get_value(ModelContext* context, int sheet, int row, int col);
+        [DllImport(__DllName, EntryPoint = "get_cell_value_by_index", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern GetValueResult get_cell_value_by_index(ModelContext* context, uint sheet, int row, int col);
 
         [DllImport(__DllName, EntryPoint = "set_user_input", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern ModelContextError* set_user_input(ModelContext* context, uint sheet, int row, int col, byte* value);
 
+        [DllImport(__DllName, EntryPoint = "dispose_cell_value", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        internal static extern void dispose_cell_value(CellValue* value);
+
         [DllImport(__DllName, EntryPoint = "dispose_error", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         internal static extern void dispose_error(ModelContextError* error);
 
@@ -63,12 +66,38 @@ internal unsafe partial struct CreateModelContextResult
         [MarshalAs(UnmanagedType.U1)] public bool is_ok;
     }
 
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe partial struct CellValue
+    {
+        public CellValueTag tag;
+        public byte* string_value;
+        public double number_value;
+        [MarshalAs(UnmanagedType.U1)] public bool boolean_value;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe partial struct GetValueResult
+    {
+        public CellValue* value;
+        public ModelContextError* error;
+        [MarshalAs(UnmanagedType.U1)] public bool is_ok;
+    }
+
 
     internal enum ModelContextErrorTag : uint
     {
         XlsxError = 1,
         WorkbookError = 2,
         SetUserInputError = 3,
+        GetUserInputError = 4,
+    }
+
+    internal enum CellValueTag : uint
+    {
+        None = 0,
+        String = 1,
+        Number = 2,
+        Boolean = 3,
     }
 
 

bindings/dotnet/ironcalc-dotnet/IronCalc/Model.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using System.Text;
+using IronCalc.Native;
 
 namespace IronCalc;
 
@@ -22,6 +23,7 @@ internal IronCalcException(string message, ModelContextErrorTag? tag)
             ModelContextErrorTag.XlsxError => ErrorCode.XslxError,
             ModelContextErrorTag.WorkbookError => ErrorCode.WorkbookError,
             ModelContextErrorTag.SetUserInputError => ErrorCode.SetUserInputError,
+            ModelContextErrorTag.GetUserInputError => ErrorCode.GetUserInputError,
             _ => throw new ArgumentOutOfRangeException(nameof(tag), tag, null)
         };
     }
@@ -33,6 +35,7 @@ public enum ErrorCode
     XslxError = 2,
     WorkbookError = 3,
     SetUserInputError = 4,
+    GetUserInputError = 5,
 }
 
 public class Model : IDisposable
@@ -97,11 +100,46 @@ public void Evaluate()
         }
     }
 
-    public int GetValue(int sheet, int row, int column)
+    public CellValue GetValue(uint sheet, int row, int column)
     {
         unsafe
         {
-            return NativeMethods.get_value(ctx, sheet, row, column);
+            var result = NativeMethods.get_cell_value_by_index(ctx, sheet, row, column);
+            if (!result.is_ok)
+            {
+                throw CreateExceptionFromError(result.error);
+            }
+
+            try
+            {
+                switch (result.value->tag)
+                {
+                    case CellValueTag.None:
+                        return new CellValue.None();
+                    case CellValueTag.String:
+                        var value = new String((sbyte*)result.value->string_value);
+                        return new CellValue.String()
+                        {
+                            Value = value,
+                        };
+                    case CellValueTag.Number:
+                        return new CellValue.Number()
+                        {
+                            Value = result.value->number_value,
+                        };
+                    case CellValueTag.Boolean:
+                        return new CellValue.Bool()
+                        {
+                            Value = result.value->boolean_value,
+                        };
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+            finally
+            {
+                NativeMethods.dispose_cell_value(result.value);
+            }
         }
     }
 

bindings/dotnet/src/lib.rs

@@ -1,4 +1,4 @@
-use ironcalc::base::cell::CellValue;
+use ironcalc::base::cell;
 use ironcalc::base::Model;
 use std::ffi::{c_char, CString};
 
@@ -10,6 +10,7 @@ pub enum ModelContextErrorTag {
     XlsxError = 1,
     WorkbookError = 2,
     SetUserInputError = 3,
+    GetUserInputError = 4,
 }
 
 #[repr(C)]
@@ -26,21 +27,23 @@ pub struct CreateModelContextResult {
     is_ok: bool,
 }
 
-impl CreateModelContextResult {
-    fn create_error(message: String, tag: ModelContextErrorTag) -> CreateModelContextResult {
-        let message_ptr = CString::new(message)
-            .expect("Couldn't create CString")
-            .into_raw();
+fn create_error(message: String, tag: ModelContextErrorTag) -> *mut ModelContextError {
+    let message_ptr = CString::new(message)
+        .expect("Couldn't create CString")
+        .into_raw();
 
-        let error = Box::into_raw(Box::new(ModelContextError {
-            tag,
-            has_message: true,
-            message: message_ptr,
-        }));
+    Box::into_raw(Box::new(ModelContextError {
+        tag,
+        has_message: true,
+        message: message_ptr,
+    }))
+}
 
+impl CreateModelContextResult {
+    fn create_error(message: String, tag: ModelContextErrorTag) -> CreateModelContextResult {
         CreateModelContextResult {
             model: std::ptr::null_mut(),
-            error,
+            error: create_error(message, tag),
             is_ok: false,
         }
     }
@@ -141,27 +144,93 @@ pub unsafe extern "C" fn evaluate(context: *mut ModelContext) {
     Box::into_raw(ctx) as *mut ModelContext;
 }
 
+#[repr(C)]
+#[derive(PartialEq)]
+pub enum CellValueTag {
+    None = 0,
+    String = 1,
+    Number = 2,
+    Boolean = 3,
+}
+
+#[repr(C)]
+pub struct CellValue {
+    tag: CellValueTag,
+    string_value: *const c_char,
+    number_value: f64,
+    boolean_value: bool,
+}
+
+#[repr(C)]
+pub struct GetValueResult {
+    value: *mut CellValue,
+    error: *mut ModelContextError,
+    is_ok: bool,
+}
+
 #[no_mangle]
-pub unsafe extern "C" fn get_value(
+pub unsafe extern "C" fn get_cell_value_by_index(
     context: *mut ModelContext,
-    sheet: i32,
+    sheet: u32,
     row: i32,
     col: i32,
-) -> i32 {
+) -> GetValueResult {
     let ctx = Box::from_raw(context as *mut InternalModelContext);
 
-    let value = ctx
-        .model
-        .get_cell_value_by_index(sheet as u32, row, col)
-        .expect("couldn't get sheet");
-    let return_value = match value {
-        CellValue::Number(x) => x as i32,
-        _ => 0,
+    let value = match ctx.model.get_cell_value_by_index(sheet, row, col) {
+        Ok(value) => value,
+        Err(message) => {
+            let error = create_error(message, ModelContextErrorTag::GetUserInputError);
+            Box::into_raw(ctx) as *mut ModelContext;
+            return GetValueResult {
+                value: std::ptr::null_mut(),
+                error,
+                is_ok: false,
+            };
+        }
+    };
+
+    let cell_value = match value {
+        cell::CellValue::Number(value) => CellValue {
+            tag: CellValueTag::Number,
+            string_value: Default::default(),
+            number_value: value,
+            boolean_value: Default::default(),
+        },
+        cell::CellValue::None => CellValue {
+            tag: CellValueTag::None,
+            string_value: Default::default(),
+            number_value: Default::default(),
+            boolean_value: Default::default(),
+        },
+        cell::CellValue::Boolean(value) => CellValue {
+            tag: CellValueTag::Boolean,
+            string_value: Default::default(),
+            number_value: Default::default(),
+            boolean_value: value,
+        },
+        cell::CellValue::String(value) => {
+            let value_ptr = CString::new(value)
+                .expect("Couldn't create CString")
+                .into_raw();
+            CellValue {
+                tag: CellValueTag::String,
+                string_value: value_ptr,
+                number_value: Default::default(),
+                boolean_value: Default::default(),
+            }
+        }
     };
 
+    let cell_value = Box::into_raw(Box::new(cell_value));
+
     Box::into_raw(ctx) as *mut ModelContext;
 
-    return_value
+    GetValueResult {
+        value: cell_value,
+        error: std::ptr::null_mut(),
+        is_ok: true,
+    }
 }
 
 #[no_mangle]
@@ -173,21 +242,13 @@ pub unsafe extern "C" fn set_user_input(
     value: *const c_char,
 ) -> *mut ModelContextError {
     let mut ctx = Box::from_raw(context as *mut InternalModelContext);
-    let value = std::ffi::CStr::from_ptr(value).to_string_lossy().to_string();
+    let value = std::ffi::CStr::from_ptr(value)
+        .to_string_lossy()
+        .to_string();
 
     if let Err(message) = ctx.model.set_user_input(sheet, row, col, value) {
-        let message_ptr = CString::new(message)
-            .expect("Couldn't create CString")
-            .into_raw();
-
-        let error = Box::into_raw(Box::new(ModelContextError {
-            tag: ModelContextErrorTag::SetUserInputError,
-            has_message: true,
-            message: message_ptr,
-        }));
-
+        let error = create_error(message, ModelContextErrorTag::SetUserInputError);
         Box::into_raw(ctx) as *mut ModelContext;
-
         return error;
     }
 
@@ -196,6 +257,15 @@ pub unsafe extern "C" fn set_user_input(
     std::ptr::null_mut()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dispose_cell_value(value: *mut CellValue) {
+    let value = Box::from_raw(value);
+    if value.tag == CellValueTag::String {
+        let str = value.string_value as *mut c_char;
+        _ = CString::from_raw(str)
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dispose_error(error: *mut ModelContextError) {
     let error = Box::from_raw(error);