correct mistake when casting, pointer to pointer was unnecessary

Author: Buggaboo

examples/sum_int.rs

@@ -3,7 +3,7 @@
 
 use libsqlite3_sys::sqlite3_int64;
 use sqlite_loadable::prelude::*;
-use sqlite_loadable::window::{WindowFunctionCallbacks, define_window_function};
+use sqlite_loadable::window::define_window_function;
 use sqlite_loadable::{api, Result};
 
 /// Example inspired by sqlite3's sumint
@@ -41,8 +41,10 @@ pub fn x_inverse(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -
 #[sqlite_entrypoint]
 pub fn sqlite3_sumint_init(db: *mut sqlite3) -> Result<()> {
     let flags = FunctionFlags::UTF8 | FunctionFlags::DETERMINISTIC;
-    define_window_function(db, "sumint", -1, flags,
-    WindowFunctionCallbacks::new(x_step, x_final, x_value, x_inverse))?;
+    define_window_function(
+        db, "sumint", -1, flags,
+        x_step, x_final, Some(x_value), Some(x_inverse),
+    )?;
     Ok(())
 }
 

src/lib.rs

@@ -27,7 +27,7 @@ pub use bit_flags::FunctionFlags;
 pub use scalar::{define_scalar_function, define_scalar_function_with_aux};
 
 #[doc(inline)]
-pub use window::{WindowFunctionCallbacksWithAux, define_window_function_with_aux};
+pub use window::{WindowFunctionCallbacks, define_window_function};
 
 #[doc(inline)]
 pub use collation::define_collation;

src/window.rs

@@ -15,19 +15,17 @@ use crate::{
 };
 use sqlite3ext_sys::{sqlite3, sqlite3_context, sqlite3_user_data, sqlite3_value};
 
-// TODO typedef repeating parameter types, across multiple files
-
 fn create_window_function(
     db: *mut sqlite3,
     name: &str,
     num_args: c_int,
     func_flags: FunctionFlags,
     p_app: *mut c_void,
-    x_step: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
-    x_final: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
+    x_step: unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value),
+    x_final: unsafe extern "C" fn(*mut sqlite3_context),
     x_value: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
     x_inverse: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
-    destroy: Option<unsafe extern "C" fn(*mut c_void)>,
+    destroy: unsafe extern "C" fn(*mut c_void),
 ) -> Result<()> {
 
     let cname = CString::new(name)?;
@@ -38,11 +36,11 @@ fn create_window_function(
             num_args,
             func_flags.bits(),
             p_app,
-            x_step,
-            x_final,
+            Some(x_step),
+            Some(x_final),
             x_value,
             x_inverse,
-            destroy,
+            Some(destroy),
         )
     };
 
@@ -53,46 +51,25 @@ fn create_window_function(
     }
 }
 
+type ValueCallback = fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()>;
+type ContextCallback = fn(context: *mut sqlite3_context) -> Result<()>;
+
 pub struct WindowFunctionCallbacks
 {
-    x_step: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()>,
-    x_final: fn(context: *mut sqlite3_context) -> Result<()>,
-    x_value: fn(context: *mut sqlite3_context) -> Result<()>,
-    x_inverse: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()>,
+    x_step: ValueCallback,
+    x_final: ContextCallback,
+    x_value: Option<ContextCallback>,
+    x_inverse: Option<ValueCallback>,
 }
 
 impl WindowFunctionCallbacks {
     pub fn new(
-        x_step: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()>,
-        x_final: fn(context: *mut sqlite3_context) -> Result<()>,
-        x_value: fn(context: *mut sqlite3_context) -> Result<()>,
-        x_inverse: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()>
+        x_step: ValueCallback,
+        x_final: ContextCallback,
+        x_value: Option<ContextCallback>,
+        x_inverse: Option<ValueCallback>
     ) -> Self {
-        WindowFunctionCallbacks {
-            x_step,
-            x_final,
-            x_value,
-            x_inverse,
-        }
-    }
-}
-
-pub struct WindowFunctionCallbacksWithAux<T>
-{
-    x_step: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value], aux: &T) -> Result<()>,
-    x_final: fn(context: *mut sqlite3_context, aux: &T) -> Result<()>,
-    x_value: fn(context: *mut sqlite3_context, aux: &T) -> Result<()>,
-    x_inverse: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value], aux: &T) -> Result<()>,
-}
-
-impl<T> WindowFunctionCallbacksWithAux<T> {
-    pub fn new(
-        x_step: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value], aux: &T) -> Result<()>,
-        x_final: fn(context: *mut sqlite3_context, aux: &T) -> Result<()>,
-        x_value: fn(context: *mut sqlite3_context, aux: &T) -> Result<()>,
-        x_inverse: fn(context: *mut sqlite3_context, values: &[*mut sqlite3_value], aux: &T) -> Result<()>
-    ) -> Self {
-        WindowFunctionCallbacksWithAux {
+        Self {
             x_step,
             x_final,
             x_value,
@@ -102,148 +79,33 @@ impl<T> WindowFunctionCallbacksWithAux<T> {
 }
 
 // TODO add documentation
-// TODO add new test with aux object
-// TODO parentheses matching
-/// The aux parameter can be used to pass another context object altogether
-pub fn define_window_function_with_aux<T>(
-    db: *mut sqlite3,
-    name: &str,
-    num_args: c_int,
-    func_flags: FunctionFlags,
-    callbacks: WindowFunctionCallbacksWithAux<T>,
-    aux: T,
-) -> Result<()>
-{
-    let callbacks_pointer = Box::into_raw(Box::new(callbacks));
-    let aux_pointer: *mut T = Box::into_raw(Box::new(aux));
-    let app_pointer = Box::into_raw(Box::new((callbacks_pointer, aux_pointer)));
-    
-    unsafe extern "C" fn x_step_wrapper<T>(
-        context: *mut sqlite3_context,
-        argc: c_int,
-        argv: *mut *mut sqlite3_value,
-    )
-    {
-        let x = sqlite3_user_data(context).cast::<(*mut WindowFunctionCallbacksWithAux<T>, *mut T)>();
-        let boxed_function = Box::from_raw((*x).0).as_ref().x_step;
-        let aux = (*x).1;
-        // .collect slows things waaaay down, so stick with slice for now
-        let args = slice::from_raw_parts(argv, argc as usize);
-        let b: Box<T> = Box::from_raw(aux);
-        match boxed_function(context, args, &*b) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
-                }
-            }
-        }
-        Box::into_raw(b);
-    }
-
-    unsafe extern "C" fn x_inverse_wrapper<T>(
-        context: *mut sqlite3_context,
-        argc: c_int,
-        argv: *mut *mut sqlite3_value,
-    )
-    {
-        let x = sqlite3_user_data(context).cast::<(*mut WindowFunctionCallbacksWithAux<T>, *mut T)>();
-        let boxed_function = Box::from_raw((*x).0).as_ref().x_inverse;
-        let aux = (*x).1;
-        // .collect slows things waaaay down, so stick with slice for now
-        let args = slice::from_raw_parts(argv, argc as usize);
-        let b = Box::from_raw(aux);
-        match boxed_function(context, args, &*b) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
-                }
-            }
-        }
-        Box::into_raw(b);
-    }
-
-    unsafe extern "C" fn x_final_wrapper<T>(
-        context: *mut sqlite3_context,
-    )
-    {
-        let x = sqlite3_user_data(context).cast::<(*mut WindowFunctionCallbacksWithAux<T>, *mut T)>();
-        let boxed_function = Box::from_raw((*x).0).as_ref().x_final;
-        let aux = (*x).1;
-        let b = Box::from_raw(aux);
-        match boxed_function(context, &*b) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
-                }
-            }
-        }
-        Box::into_raw(b);
-    }
-
-    unsafe extern "C" fn x_value_wrapper<T>(
-        context: *mut sqlite3_context,
-    )
-    {
-        let x = sqlite3_user_data(context).cast::<(*mut WindowFunctionCallbacksWithAux<T>, *mut T)>();
-        let boxed_function = Box::from_raw((*x).0).as_ref().x_value;
-        let aux = (*x).1;
-        let b = Box::from_raw(aux);
-        match boxed_function(context, &*b) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
-                }
-            }
-        }
-        Box::into_raw(b);
-    }
-
-    create_window_function(
-        db,
-        name,
-        num_args,
-        func_flags,
-        // app_pointer,
-        app_pointer.cast::<c_void>(),
-        Some(x_step_wrapper::<T>),
-        Some(x_final_wrapper::<T>),
-        Some(x_value_wrapper::<T>),
-        Some(x_inverse_wrapper::<T>),
-        None, // Note: release resources in x_final if necessary
-        )
-
-
-}
-
-// TODO add documentation
-// TODO parentheses matching
 /// The aux parameter can be used to pass another context object altogether
 pub fn define_window_function(
     db: *mut sqlite3,
     name: &str,
     num_args: c_int,
     func_flags: FunctionFlags,
-    callbacks: WindowFunctionCallbacks,
+    x_step: ValueCallback,
+    x_final: ContextCallback,
+    x_value: Option<ContextCallback>,
+    x_inverse: Option<ValueCallback>
 ) -> Result<()>
 {
-    let callbacks_pointer = Box::into_raw(Box::new(callbacks));
-    let app_pointer = Box::into_raw(Box::new(callbacks_pointer));
+    let app_pointer = Box::into_raw(
+        Box::new(
+            WindowFunctionCallbacks::new(x_step, x_final, x_value, x_inverse)
+        )
+    );
 
     unsafe extern "C" fn x_step_wrapper(
         context: *mut sqlite3_context,
         argc: c_int,
         argv: *mut *mut sqlite3_value,
     )
     {
-        let x = sqlite3_user_data(context).cast::<*mut WindowFunctionCallbacks>();
-        let boxed_function = Box::from_raw(*x).as_ref().x_step;
-        // .collect slows things waaaay down, so stick with slice for now
+        let x = sqlite3_user_data(context).cast::<WindowFunctionCallbacks>();
         let args = slice::from_raw_parts(argv, argc as usize);
-        match boxed_function(context, args) {
+        match ((*x).x_step)(context, args) {
             Ok(()) => (),
             Err(e) => {
                 if api::result_error(context, &e.result_error_message()).is_err() {
@@ -259,27 +121,26 @@ pub fn define_window_function(
         argv: *mut *mut sqlite3_value,
     )
     {
-        let x = sqlite3_user_data(context).cast::<*mut WindowFunctionCallbacks>();
-        let boxed_function = Box::from_raw(*x).as_ref().x_inverse;
-        // .collect slows things waaaay down, so stick with slice for now
-        let args = slice::from_raw_parts(argv, argc as usize);
-        match boxed_function(context, args) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
+        let x = sqlite3_user_data(context).cast::<WindowFunctionCallbacks>();
+        if let Some(x_inverse) = (*x).x_inverse {
+            let args = slice::from_raw_parts(argv, argc as usize);
+            match x_inverse(context, args) {
+                Ok(()) => (),
+                Err(e) => {
+                    if api::result_error(context, &e.result_error_message()).is_err() {
+                        api::result_error_code(context, SQLITE_INTERNAL);
+                    }
                 }
-            }
+            }    
         }
     }
 
     unsafe extern "C" fn x_final_wrapper(
         context: *mut sqlite3_context,
     )
     {
-        let x = sqlite3_user_data(context).cast::<*mut WindowFunctionCallbacks>();
-        let boxed_function = Box::from_raw(*x).as_ref().x_final;
-        match boxed_function(context) {
+        let x = sqlite3_user_data(context).cast::<WindowFunctionCallbacks>();
+        match ((*x).x_final)(context) {
             Ok(()) => (),
             Err(e) => {
                 if api::result_error(context, &e.result_error_message()).is_err() {
@@ -293,30 +154,38 @@ pub fn define_window_function(
         context: *mut sqlite3_context,
     )
     {
-        let x = sqlite3_user_data(context).cast::<*mut WindowFunctionCallbacks>();
-        let boxed_function = Box::from_raw(*x).as_ref().x_value;
-        match boxed_function(context) {
-            Ok(()) => (),
-            Err(e) => {
-                if api::result_error(context, &e.result_error_message()).is_err() {
-                    api::result_error_code(context, SQLITE_INTERNAL);
+        let x = sqlite3_user_data(context).cast::<WindowFunctionCallbacks>();
+        if let Some(x_value) = (*x).x_value {
+            match x_value(context) {
+                Ok(()) => (),
+                Err(e) => {
+                    if api::result_error(context, &e.result_error_message()).is_err() {
+                        api::result_error_code(context, SQLITE_INTERNAL);
+                    }
                 }
-            }
+            }    
         }
     }
 
+    unsafe extern "C" fn destroy(
+        p_app: *mut c_void,
+    )
+    {
+        let callbacks = p_app.cast::<WindowFunctionCallbacks>();
+        let _ = Box::from(callbacks); // drop
+    }
+
     create_window_function(
         db,
         name,
         num_args,
         func_flags,
-        // app_pointer,
         app_pointer.cast::<c_void>(),
-        Some(x_step_wrapper),
-        Some(x_final_wrapper),
+        x_step_wrapper,
+        x_final_wrapper,
         Some(x_value_wrapper),
         Some(x_inverse_wrapper),
-        None, // Note: release resources in x_final if necessary
+        destroy,
     )