include/servicepoint.h

@@ -675,6 +675,8 @@ void sp_bitmap_free(struct Bitmap */*notnull*/ instance);
  * The provided BitVec gets consumed.
  *
  * Returns NULL in case of error.
+ *
+ * This function is part of the sp_bitmap module.
  */
 struct Bitmap *sp_bitmap_from_bitvec(size_t width, BitVec */*notnull*/ bitvec);
 
@@ -702,6 +704,8 @@ size_t sp_bitmap_height(struct Bitmap */*notnull*/ instance);
 
 /**
  * Consumes the Bitmap and returns the contained BitVec.
+ *
+ * This function is part of the sp_bitmap module.
  */
 BitVec */*notnull*/ sp_bitmap_into_bitvec(struct Bitmap */*notnull*/ bitmap);
 
@@ -711,6 +715,8 @@ BitVec */*notnull*/ sp_bitmap_into_bitvec(struct Bitmap */*notnull*/ bitmap);
  * The provided [Bitmap] gets consumed.
  *
  * Returns NULL in case of an error.
+ *
+ * This function is part of the sp_bitmap module.
  */
 struct Packet *sp_bitmap_into_packet(struct Bitmap */*notnull*/ bitmap,
                                      size_t x,
@@ -726,6 +732,8 @@ struct Packet *sp_bitmap_into_packet(struct Bitmap */*notnull*/ bitmap,
  * - `height`: size in pixels in y-direction
  *
  * returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
+ *
+ * This function is part of the sp_bitmap module.
  */
 struct Bitmap *sp_bitmap_load(size_t width,
                               size_t height,
@@ -755,6 +763,8 @@ struct Bitmap *sp_bitmap_load(size_t width,
  * sp_bitmap_set(grid, 0, 0, false);
  * sp_bitmap_free(grid);
  * ```
+ *
+ * This function is part of the sp_bitmap module.
  */
 struct Bitmap *sp_bitmap_new(size_t width, size_t height);
 
@@ -762,6 +772,8 @@ struct Bitmap *sp_bitmap_new(size_t width, size_t height);
  * Creates a new [Bitmap] with a size matching the screen.
  *
  * returns: [Bitmap] initialized to all pixels off.
+ *
+ * This function is part of the sp_bitmap module.
  */
 struct Bitmap */*notnull*/ sp_bitmap_new_max_sized(void);
 
@@ -845,6 +857,8 @@ bool sp_bitvec_get(BitVec */*notnull*/ instance, size_t index);
  * The provided [DisplayBitVec] gets consumed.
  *
  * Returns NULL in case of an error.
+ *
+ * This function is part of the sp_bitvec module.
  */
 struct Packet *sp_bitvec_into_packet(BitVec */*notnull*/ bitvec,
                                      size_t offset,
@@ -869,6 +883,8 @@ size_t sp_bitvec_len(BitVec */*notnull*/ instance);
  * Interpret the data as a series of bits and load then into a new [DisplayBitVec] instance.
  *
  * returns: [DisplayBitVec] instance containing data.
+ *
+ * This function is part of the sp_bitvec module.
  */
 BitVec */*notnull*/ sp_bitvec_load(struct ByteSlice data);
 
@@ -884,6 +900,8 @@ BitVec */*notnull*/ sp_bitvec_load(struct ByteSlice data);
  * # Panics
  *
  * - when `size` is not divisible by 8.
+ *
+ * This function is part of the sp_bitvec module.
  */
 BitVec */*notnull*/ sp_bitvec_new(size_t size);
 
@@ -965,6 +983,8 @@ size_t sp_brightness_grid_height(BrightnessGrid */*notnull*/ instance);
  * The provided [BrightnessGrid] gets consumed.
  *
  * Returns NULL in case of an error.
+ *
+ * This function is part of the sp_brightness_grid module.
  */
 struct Packet *sp_brightness_grid_into_packet(BrightnessGrid */*notnull*/ grid,
                                               size_t x,
@@ -976,6 +996,8 @@ struct Packet *sp_brightness_grid_into_packet(BrightnessGrid */*notnull*/ grid,
  * Any out of range values will be set to [Brightness::MAX] or [Brightness::MIN].
  *
  * returns: new [BrightnessGrid] instance, or NULL in case of an error.
+ *
+ * This function is part of the sp_brightness_grid module.
  */
 BrightnessGrid *sp_brightness_grid_load(size_t width,
                                         size_t height,
@@ -999,6 +1021,8 @@ BrightnessGrid *sp_brightness_grid_load(size_t width,
  * TypedCommand *command = sp_command_char_brightness(grid);
  * sp_udp_free(connection);
  * ```
+ *
+ * This function is part of the sp_brightness_grid module.
  */
 BrightnessGrid */*notnull*/ sp_brightness_grid_new(size_t width, size_t height);
 
@@ -1080,6 +1104,8 @@ size_t sp_char_grid_height(CharGrid */*notnull*/ instance);
  * The provided [CharGrid] gets consumed.
  *
  * Returns NULL in case of an error.
+ *
+ * This function is part of the sp_char_grid module.
  */
 struct Packet *sp_char_grid_into_packet(CharGrid */*notnull*/ grid,
                                         size_t x,
@@ -1089,6 +1115,8 @@ struct Packet *sp_char_grid_into_packet(CharGrid */*notnull*/ grid,
  * Loads a [CharGrid] with the specified dimensions from the provided data.
  *
  * returns: new CharGrid or NULL in case of an error
+ *
+ * This function is part of the sp_char_grid module.
  */
 CharGrid *sp_char_grid_load(size_t width, size_t height, struct ByteSlice data);
 
@@ -1105,6 +1133,8 @@ CharGrid *sp_char_grid_load(size_t width, size_t height, struct ByteSlice data);
  * sp_char_grid_set(grid, 0, 0, '!');
  * sp_char_grid_free(grid);
  * ```
+ *
+ * This function is part of the sp_char_grid module.
  */
 CharGrid */*notnull*/ sp_char_grid_new(size_t width, size_t height);
 
@@ -1152,6 +1182,8 @@ void sp_cmd_bitmap_free(struct BitmapCommand */*notnull*/ instance);
  * leaving other fields as their default values.
  *
  * Rust equivalent: `BitmapCommand::from(bitmap)`
+ *
+ * This function is part of the sp_cmd_bitmap module.
  */
 struct BitmapCommand */*notnull*/ sp_cmd_bitmap_from_bitmap(struct Bitmap */*notnull*/ bitmap);
 
@@ -1183,6 +1215,8 @@ void sp_cmd_bitmap_get_origin(struct BitmapCommand */*notnull*/ command,
  * The passed [Bitmap] gets consumed.
  *
  * Returns: a new [BitmapCommand] instance.
+ *
+ * This function is part of the sp_cmd_bitmap module.
  */
 struct BitmapCommand */*notnull*/ sp_cmd_bitmap_new(struct Bitmap */*notnull*/ bitmap,
                                                     size_t origin_x,
@@ -1212,6 +1246,8 @@ void sp_cmd_bitmap_set_origin(struct BitmapCommand */*notnull*/ command,
  * Tries to turn a [BitmapCommand] into a [Packet].
  *
  * Returns: NULL or a [Packet] containing the command.
+ *
+ * This function is part of the sp_cmd_bitmap module.
  */
 struct Packet *sp_cmd_bitmap_try_into_packet(struct BitmapCommand */*notnull*/ command);
 
@@ -1258,6 +1294,8 @@ BinaryOperation sp_cmd_bitvec_get_operation(struct BitVecCommand */*notnull*/ in
  * For example, [`BinaryOperation::Or`] can be used to turn on some pixels without affecting other pixels.
  *
  * The contained [`DisplayBitVec`] is always uncompressed.
+ *
+ * This function is part of the sp_cmd_bitvec module.
  */
 struct BitVecCommand */*notnull*/ sp_cmd_bitvec_new(BitVec */*notnull*/ bitvec,
                                                     size_t offset,
@@ -1292,6 +1330,8 @@ void sp_cmd_bitvec_set_operation(struct BitVecCommand */*notnull*/ instance,
  * Tries to turn a [BitVecCommand] into a [Packet].
  *
  * Returns: NULL or a [Packet] containing the command.
+ *
+ * This function is part of the sp_cmd_bitvec module.
  */
 struct Packet *sp_cmd_bitvec_try_into_packet(struct BitVecCommand */*notnull*/ command);
 
@@ -1310,12 +1350,19 @@ void sp_cmd_brightness_global_free(struct GlobalBrightnessCommand */*notnull*/ i
  */
 Brightness sp_cmd_brightness_global_get_brightness(struct GlobalBrightnessCommand */*notnull*/ instance);
 
+/**
+ * Turns the command into a packet
+ *
+ * This function is part of the sp_cmd_brightness_global module.
+ */
 struct Packet */*notnull*/ sp_cmd_brightness_global_into_packet(struct GlobalBrightnessCommand */*notnull*/ command);
 
 /**
  * Set the brightness of all tiles to the same value.
  *
  * Returns: a new [GlobalBrightnessCommand] instance.
+ *
+ * This function is part of the sp_cmd_brightness_global module.
  */
 struct GlobalBrightnessCommand */*notnull*/ sp_cmd_brightness_global_new(Brightness brightness);
 
@@ -1338,6 +1385,8 @@ void sp_cmd_brightness_grid_free(struct BrightnessGridCommand */*notnull*/ insta
 /**
  * Moves the provided [BrightnessGrid] into a new [BrightnessGridCommand],
  * leaving other fields as their default values.
+ *
+ * This function is part of the sp_cmd_brightness_grid module.
  */
 struct BrightnessGridCommand */*notnull*/ sp_cmd_brightness_grid_from_grid(BrightnessGrid */*notnull*/ grid);
 
@@ -1357,6 +1406,8 @@ void sp_cmd_brightness_grid_get_origin(struct BrightnessGridCommand */*notnull*/
  * Tries to turn a [BrightnessGridCommand] into a [Packet].
  *
  * Returns: NULL or a [Packet] containing the command.
+ *
+ * This function is part of the sp_cmd_brightness_grid module.
  */
 struct Packet *sp_cmd_brightness_grid_into_packet(struct BrightnessGridCommand */*notnull*/ command);
 
@@ -1366,6 +1417,8 @@ struct Packet *sp_cmd_brightness_grid_into_packet(struct BrightnessGridCommand *
  * The passed [BrightnessGrid] gets consumed.
  *
  * Returns: a new [BrightnessGridCommand] instance.
+ *
+ * This function is part of the sp_cmd_brightness_grid module.
  */
 struct BrightnessGridCommand */*notnull*/ sp_cmd_brightness_grid_new(BrightnessGrid */*notnull*/ grid,
                                                                      size_t origin_x,
@@ -1397,13 +1450,15 @@ void sp_cmd_char_grid_free(struct CharGridCommand */*notnull*/ instance);
 /**
  * Moves the provided [CharGrid] into a new [CharGridCommand],
  * leaving other fields as their default values.
+ *
+ * This function is part of the sp_cmd_char_grid module.
  */
 struct CharGridCommand */*notnull*/ sp_cmd_char_grid_from_grid(CharGrid */*notnull*/ grid);
 
 /**
  * Returns a pointer to the [CharGrid] contained in the [CharGridCommand].
  */
-CharGrid *sp_cmd_char_grid_get(struct CharGridCommand */*notnull*/ command);
+CharGrid */*notnull*/ sp_cmd_char_grid_get(struct CharGridCommand */*notnull*/ command);
 
 /**
  * Reads the origin field of the [CharGridCommand].
@@ -1418,6 +1473,8 @@ void sp_cmd_char_grid_get_origin(struct CharGridCommand */*notnull*/ command,
  * The passed [CharGrid] gets consumed.
  *
  * Returns: a new [CharGridCommand] instance.
+ *
+ * This function is part of the sp_cmd_char_grid module.
  */
 struct CharGridCommand */*notnull*/ sp_cmd_char_grid_new(CharGrid */*notnull*/ grid,
                                                          size_t origin_x,
@@ -1440,6 +1497,8 @@ void sp_cmd_char_grid_set_origin(struct CharGridCommand */*notnull*/ command,
  * Tries to turn a [CharGridCommand] into a [Packet].
  *
  * Returns: NULL or a [Packet] containing the command.
+ *
+ * This function is part of the sp_cmd_char_grid module.
  */
 struct Packet *sp_cmd_char_grid_try_into_packet(struct CharGridCommand */*notnull*/ command);
 
@@ -1454,6 +1513,8 @@ void sp_cmd_clear_free(struct ClearCommand */*notnull*/ instance);
  * Does not affect brightness.
  *
  * Returns: a new [ClearCommand] instance.
+ *
+ * This function is part of the sp_cmd_clear module.
  */
 struct ClearCommand */*notnull*/ sp_cmd_clear_new(void);
 
@@ -1470,6 +1531,8 @@ void sp_cmd_cp437_grid_free(struct Cp437GridCommand */*notnull*/ instance);
 /**
  * Moves the provided [Cp437Grid] into a new [Cp437GridCommand],
  * leaving other fields as their default values.
+ *
+ * This function is part of the sp_cmd_cp437_grid module.
  */
 struct Cp437GridCommand */*notnull*/ sp_cmd_cp437_grid_from_grid(Cp437Grid */*notnull*/ grid);
 
@@ -1498,6 +1561,8 @@ void sp_cmd_cp437_grid_get_origin(struct Cp437GridCommand */*notnull*/ command,
  * The text is sent in the form of a 2D grid of [CP-437] encoded characters.
  *
  * The origin is relative to the top-left of the display.
+ *
+ * This function is part of the sp_cmd_cp437_grid module.
  */
 struct Cp437GridCommand */*notnull*/ sp_cmd_cp437_grid_new(Cp437Grid */*notnull*/ grid,
                                                            size_t origin_x,
@@ -1524,6 +1589,8 @@ void sp_cmd_cp437_grid_set_origin(struct Cp437GridCommand */*notnull*/ command,
  * Tries to turn a [Cp437GridCommand] into a [Packet].
  *
  * Returns: NULL or a [Packet] containing the command.
+ *
+ * This function is part of the sp_cmd_cp437_grid module.
  */
 struct Packet *sp_cmd_cp437_grid_try_into_packet(struct Cp437GridCommand */*notnull*/ command);
 
@@ -1536,6 +1603,8 @@ void sp_cmd_fade_out_free(struct FadeOutCommand */*notnull*/ instance);
  * A yet-to-be-tested command.
  *
  * Returns: a new [FadeOutCommand] instance.
+ *
+ * This function is part of the sp_cmd_fade_out module.
  */
 struct FadeOutCommand */*notnull*/ sp_cmd_fade_out_new(void);
 
@@ -1588,6 +1657,8 @@ void sp_cmd_hard_reset_free(struct HardResetCommand */*notnull*/ instance);
  * Please do not send this in your normal program flow.
  *
  * Returns: a new [HardResetCommand] instance.
+ *
+ * This function is part of the sp_cmd_hard_reset module.
  */
 struct HardResetCommand */*notnull*/ sp_cmd_hard_reset_new(void);
 
@@ -1650,6 +1721,8 @@ size_t sp_cp437_grid_height(Cp437Grid */*notnull*/ instance);
  * The provided [Cp437Grid] gets consumed.
  *
  * Returns NULL in case of an error.
+ *
+ * This function is part of the sp_cp437_grid module.
  */
 struct Packet *sp_cp437_grid_into_packet(Cp437Grid */*notnull*/ grid,
                                          size_t x,
@@ -1657,6 +1730,8 @@ struct Packet *sp_cp437_grid_into_packet(Cp437Grid */*notnull*/ grid,
 
 /**
  * Loads a [Cp437Grid] with the specified dimensions from the provided data.
+ *
+ * This function is part of the sp_cp437_grid module.
  */
 Cp437Grid *sp_cp437_grid_load(size_t width,
                               size_t height,
@@ -1666,6 +1741,8 @@ Cp437Grid *sp_cp437_grid_load(size_t width,
  * Creates a new [Cp437Grid] with the specified dimensions.
  *
  * returns: [Cp437Grid] initialized to 0.
+ *
+ * This function is part of the sp_cp437_grid module.
  */
 Cp437Grid */*notnull*/ sp_cp437_grid_new(size_t width, size_t height);
 

src/commands/bitmap_command.rs

@@ -1,49 +1,50 @@
 use crate::{
-    macros::{wrap_clone, wrap_fields, wrap_free},
+    macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{Bitmap, BitmapCommand, CompressionCode, Origin, Packet};
 use std::ptr::NonNull;
 
-/// Sets a window of pixels to the specified values.
+wrap_functions!(sp_cmd_bitmap;
-///
-/// The passed [Bitmap] gets consumed.
-///
-/// Returns: a new [BitmapCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_bitmap_new(
-    bitmap: NonNull<Bitmap>,
-    origin_x: usize,
-    origin_y: usize,
-    compression: CompressionCode,
-) -> NonNull<BitmapCommand> {
-    heap_move_nonnull(BitmapCommand {
-        bitmap: unsafe { heap_remove(bitmap) },
-        origin: Origin::new(origin_x, origin_y),
-        compression,
-    })
-}
 
-/// Move the provided [Bitmap] into a new [BitmapCommand],
+    /// Sets a window of pixels to the specified values.
-/// leaving other fields as their default values.
+    ///
-///
+    /// The passed [Bitmap] gets consumed.
-/// Rust equivalent: `BitmapCommand::from(bitmap)`
+    ///
-#[no_mangle]
+    /// Returns: a new [BitmapCommand] instance.
-pub unsafe extern "C" fn sp_cmd_bitmap_from_bitmap(
+    fn new(
-    bitmap: NonNull<Bitmap>,
+        bitmap: NonNull<Bitmap>,
-) -> NonNull<BitmapCommand> {
+        origin_x: usize,
-    heap_move_nonnull(unsafe { heap_remove(bitmap) }.into())
+        origin_y: usize,
-}
+        compression: CompressionCode,
+    ) -> NonNull<BitmapCommand> {
+        heap_move_nonnull(BitmapCommand {
+            bitmap: unsafe { heap_remove(bitmap) },
+            origin: Origin::new(origin_x, origin_y),
+            compression,
+        })
+    }
 
-/// Tries to turn a [BitmapCommand] into a [Packet].
+    /// Move the provided [Bitmap] into a new [BitmapCommand],
-///
+    /// leaving other fields as their default values.
-/// Returns: NULL or a [Packet] containing the command.
+    ///
-#[no_mangle]
+    /// Rust equivalent: `BitmapCommand::from(bitmap)`
-pub unsafe extern "C" fn sp_cmd_bitmap_try_into_packet(
+    fn from_bitmap(
-    command: NonNull<BitmapCommand>,
+        bitmap: NonNull<Bitmap>,
-) -> *mut Packet {
+    ) -> NonNull<BitmapCommand> {
-    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+        heap_move_nonnull(unsafe { heap_remove(bitmap) }.into())
-}
+    }
+
+    /// Tries to turn a [BitmapCommand] into a [Packet].
+    ///
+    /// Returns: NULL or a [Packet] containing the command.
+    fn try_into_packet(
+        command: NonNull<BitmapCommand>,
+    ) -> *mut Packet {
+        heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_bitmap::BitmapCommand);
 wrap_free!(sp_cmd_bitmap::BitmapCommand);

src/commands/bitvec_command.rs

@@ -1,5 +1,5 @@
 use crate::{
-    macros::{wrap_clone, wrap_fields, wrap_free},
+    macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{
@@ -8,42 +8,44 @@ use servicepoint::{
 };
 use std::ptr::NonNull;
 
-/// Set pixel data starting at the pixel offset on screen.
+wrap_functions!(sp_cmd_bitvec;
-///
-/// The screen will continuously overwrite more pixel data without regarding the offset, meaning
-/// once the starting row is full, overwriting will continue on column 0.
-///
-/// The [`BinaryOperation`] will be applied on the display comparing old and sent bit.
-///
-/// `new_bit = old_bit op sent_bit`
-///
-/// For example, [`BinaryOperation::Or`] can be used to turn on some pixels without affecting other pixels.
-///
-/// The contained [`DisplayBitVec`] is always uncompressed.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_bitvec_new(
-    bitvec: NonNull<DisplayBitVec>,
-    offset: usize,
-    operation: BinaryOperation,
-    compression: CompressionCode,
-) -> NonNull<BitVecCommand> {
-    heap_move_nonnull(BitVecCommand {
-        bitvec: unsafe { heap_remove(bitvec) },
-        offset,
-        operation,
-        compression,
-    })
-}
 
-/// Tries to turn a [BitVecCommand] into a [Packet].
+    /// Set pixel data starting at the pixel offset on screen.
-///
+    ///
-/// Returns: NULL or a [Packet] containing the command.
+    /// The screen will continuously overwrite more pixel data without regarding the offset, meaning
-#[no_mangle]
+    /// once the starting row is full, overwriting will continue on column 0.
-pub unsafe extern "C" fn sp_cmd_bitvec_try_into_packet(
+    ///
-    command: NonNull<BitVecCommand>,
+    /// The [`BinaryOperation`] will be applied on the display comparing old and sent bit.
-) -> *mut Packet {
+    ///
-    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    /// `new_bit = old_bit op sent_bit`
-}
+    ///
+    /// For example, [`BinaryOperation::Or`] can be used to turn on some pixels without affecting other pixels.
+    ///
+    /// The contained [`DisplayBitVec`] is always uncompressed.
+    fn new(
+        bitvec: NonNull<DisplayBitVec>,
+        offset: usize,
+        operation: BinaryOperation,
+        compression: CompressionCode,
+    ) -> NonNull<BitVecCommand> {
+        heap_move_nonnull(BitVecCommand {
+            bitvec: unsafe { heap_remove(bitvec) },
+            offset,
+            operation,
+            compression,
+        })
+    }
+
+    /// Tries to turn a [BitVecCommand] into a [Packet].
+    ///
+    /// Returns: NULL or a [Packet] containing the command.
+    fn try_into_packet(
+        command: NonNull<BitVecCommand>,
+    ) -> *mut Packet {
+        heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_bitvec::BitVecCommand);
 wrap_free!(sp_cmd_bitvec::BitVecCommand);

src/commands/brightness_grid_command.rs

@@ -1,45 +1,46 @@
 use crate::{
-    macros::{wrap_clone, wrap_free},
+    macros::{wrap_clone, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{BrightnessGrid, BrightnessGridCommand, Origin, Packet};
 use std::ptr::NonNull;
 
-/// Set the brightness of individual tiles in a rectangular area of the display.
+wrap_functions!(sp_cmd_brightness_grid;
-///
-/// The passed [BrightnessGrid] gets consumed.
-///
-/// Returns: a new [BrightnessGridCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_brightness_grid_new(
-    grid: NonNull<BrightnessGrid>,
-    origin_x: usize,
-    origin_y: usize,
-) -> NonNull<BrightnessGridCommand> {
-    heap_move_nonnull(BrightnessGridCommand {
-        grid: unsafe { heap_remove(grid) },
-        origin: Origin::new(origin_x, origin_y),
-    })
-}
 
-/// Moves the provided [BrightnessGrid] into a new [BrightnessGridCommand],
+    /// Set the brightness of individual tiles in a rectangular area of the display.
-/// leaving other fields as their default values.
+    ///
-#[no_mangle]
+    /// The passed [BrightnessGrid] gets consumed.
-pub unsafe extern "C" fn sp_cmd_brightness_grid_from_grid(
+    ///
-    grid: NonNull<BrightnessGrid>,
+    /// Returns: a new [BrightnessGridCommand] instance.
-) -> NonNull<BrightnessGridCommand> {
+    fn new(
-    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+        grid: NonNull<BrightnessGrid>,
-}
+        origin_x: usize,
+        origin_y: usize,
+    ) -> NonNull<BrightnessGridCommand> {
+        heap_move_nonnull(BrightnessGridCommand {
+            grid: unsafe { heap_remove(grid) },
+            origin: Origin::new(origin_x, origin_y),
+        })
+    }
 
-/// Tries to turn a [BrightnessGridCommand] into a [Packet].
+    /// Moves the provided [BrightnessGrid] into a new [BrightnessGridCommand],
-///
+    /// leaving other fields as their default values.
-/// Returns: NULL or a [Packet] containing the command.
+    fn from_grid(
-#[no_mangle]
+        grid: NonNull<BrightnessGrid>,
-pub unsafe extern "C" fn sp_cmd_brightness_grid_into_packet(
+    ) -> NonNull<BrightnessGridCommand> {
-    command: NonNull<BrightnessGridCommand>,
+        heap_move_nonnull(unsafe { heap_remove(grid) }.into())
-) -> *mut Packet {
+    }
-    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+
-}
+    /// Tries to turn a [BrightnessGridCommand] into a [Packet].
+    ///
+    /// Returns: NULL or a [Packet] containing the command.
+    fn into_packet(
+        command: NonNull<BrightnessGridCommand>,
+    ) -> *mut Packet {
+        heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_brightness_grid::BrightnessGridCommand);
 wrap_free!(sp_cmd_brightness_grid::BrightnessGridCommand);

src/commands/cc_only_commands.rs

@@ -1,37 +1,43 @@
-use crate::{macros::wrap_free, mem::heap_move_nonnull};
+use crate::{
+    macros::{wrap_free, wrap_functions},
+    mem::heap_move_nonnull,
+};
 use servicepoint::{ClearCommand, FadeOutCommand, HardResetCommand};
 use std::ptr::NonNull;
 
-/// Set all pixels to the off state.
+wrap_functions!(sp_cmd_clear;
-///
+    /// Set all pixels to the off state.
-/// Does not affect brightness.
+    ///
-///
+    /// Does not affect brightness.
-/// Returns: a new [ClearCommand] instance.
+    ///
-#[no_mangle]
+    /// Returns: a new [ClearCommand] instance.
-pub unsafe extern "C" fn sp_cmd_clear_new() -> NonNull<ClearCommand> {
+    fn new() -> NonNull<ClearCommand> {
-    heap_move_nonnull(ClearCommand)
+        heap_move_nonnull(ClearCommand)
-}
+    }
+);
 
 wrap_free!(sp_cmd_clear::ClearCommand);
 
-/// Kills the udp daemon on the display, which usually results in a restart.
+wrap_functions!(sp_cmd_hard_reset;
-///
+    /// Kills the udp daemon on the display, which usually results in a restart.
-/// Please do not send this in your normal program flow.
+    ///
-///
+    /// Please do not send this in your normal program flow.
-/// Returns: a new [HardResetCommand] instance.
+    ///
-#[no_mangle]
+    /// Returns: a new [HardResetCommand] instance.
-pub unsafe extern "C" fn sp_cmd_hard_reset_new() -> NonNull<HardResetCommand> {
+    fn new() -> NonNull<HardResetCommand> {
-    heap_move_nonnull(HardResetCommand)
+        heap_move_nonnull(HardResetCommand)
-}
+    }
+);
 
 wrap_free!(sp_cmd_hard_reset::HardResetCommand);
 
-/// A yet-to-be-tested command.
+wrap_functions!(sp_cmd_fade_out;
-///
+    /// A yet-to-be-tested command.
-/// Returns: a new [FadeOutCommand] instance.
+    ///
-#[no_mangle]
+    /// Returns: a new [FadeOutCommand] instance.
-pub unsafe extern "C" fn sp_cmd_fade_out_new() -> NonNull<FadeOutCommand> {
+    fn new() -> NonNull<FadeOutCommand> {
-    heap_move_nonnull(FadeOutCommand)
+        heap_move_nonnull(FadeOutCommand)
-}
+    }
+);
 
 wrap_free!(sp_cmd_fade_out::FadeOutCommand);

src/commands/char_grid_command.rs

@@ -1,45 +1,46 @@
 use crate::{
-    macros::{wrap_clone, wrap_free},
+    macros::{wrap_clone, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{CharGrid, CharGridCommand, Origin, Packet};
 use std::ptr::NonNull;
 
-/// Show UTF-8 encoded text on the screen.
+wrap_functions!(sp_cmd_char_grid;
-///
-/// The passed [CharGrid] gets consumed.
-///
-/// Returns: a new [CharGridCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_char_grid_new(
-    grid: NonNull<CharGrid>,
-    origin_x: usize,
-    origin_y: usize,
-) -> NonNull<CharGridCommand> {
-    heap_move_nonnull(CharGridCommand {
-        grid: unsafe { heap_remove(grid) },
-        origin: Origin::new(origin_x, origin_y),
-    })
-}
 
-/// Moves the provided [CharGrid] into a new [CharGridCommand],
+    /// Show UTF-8 encoded text on the screen.
-/// leaving other fields as their default values.
+    ///
-#[no_mangle]
+    /// The passed [CharGrid] gets consumed.
-pub unsafe extern "C" fn sp_cmd_char_grid_from_grid(
+    ///
-    grid: NonNull<CharGrid>,
+    /// Returns: a new [CharGridCommand] instance.
-) -> NonNull<CharGridCommand> {
+    fn new(
-    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+        grid: NonNull<CharGrid>,
-}
+        origin_x: usize,
+        origin_y: usize,
+    ) -> NonNull<CharGridCommand> {
+        heap_move_nonnull(CharGridCommand {
+            grid: unsafe { heap_remove(grid) },
+            origin: Origin::new(origin_x, origin_y),
+        })
+    }
 
-/// Tries to turn a [CharGridCommand] into a [Packet].
+    /// Moves the provided [CharGrid] into a new [CharGridCommand],
-///
+    /// leaving other fields as their default values.
-/// Returns: NULL or a [Packet] containing the command.
+    fn from_grid(
-#[no_mangle]
+        grid: NonNull<CharGrid>,
-pub unsafe extern "C" fn sp_cmd_char_grid_try_into_packet(
+    ) -> NonNull<CharGridCommand> {
-    command: NonNull<CharGridCommand>,
+        heap_move_nonnull(unsafe { heap_remove(grid) }.into())
-) -> *mut Packet {
+    }
-    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+
-}
+    /// Tries to turn a [CharGridCommand] into a [Packet].
+    ///
+    /// Returns: NULL or a [Packet] containing the command.
+    fn try_into_packet(
+        command: NonNull<CharGridCommand>,
+    ) -> *mut Packet {
+        heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_char_grid::CharGridCommand);
 wrap_free!(sp_cmd_char_grid::CharGridCommand);
@@ -59,8 +60,8 @@ pub unsafe extern "C" fn sp_cmd_char_grid_set(
 #[no_mangle]
 pub unsafe extern "C" fn sp_cmd_char_grid_get(
     mut command: NonNull<CharGridCommand>,
-) -> *mut CharGrid {
+) -> NonNull<CharGrid> {
-    unsafe { &mut command.as_mut().grid }
+    unsafe { NonNull::from(&mut command.as_mut().grid) }
 }
 
 /// Reads the origin field of the [CharGridCommand].

src/commands/cp437_grid_command.rs

@@ -1,45 +1,46 @@
 use crate::{
-    macros::{wrap_clone, wrap_free},
+    macros::{wrap_clone, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{Cp437Grid, Cp437GridCommand, Origin, Packet};
 use std::ptr::NonNull;
 
-/// Show text on the screen.
+wrap_functions!(sp_cmd_cp437_grid;
-///
-/// The text is sent in the form of a 2D grid of [CP-437] encoded characters.
-///
-/// The origin is relative to the top-left of the display.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_cp437_grid_new(
-    grid: NonNull<Cp437Grid>,
-    origin_x: usize,
-    origin_y: usize,
-) -> NonNull<Cp437GridCommand> {
-    heap_move_nonnull(Cp437GridCommand {
-        grid: unsafe { heap_remove(grid) },
-        origin: Origin::new(origin_x, origin_y),
-    })
-}
 
-/// Moves the provided [Cp437Grid] into a new [Cp437GridCommand],
+    /// Show text on the screen.
-/// leaving other fields as their default values.
+    ///
-#[no_mangle]
+    /// The text is sent in the form of a 2D grid of [CP-437] encoded characters.
-pub unsafe extern "C" fn sp_cmd_cp437_grid_from_grid(
+    ///
-    grid: NonNull<Cp437Grid>,
+    /// The origin is relative to the top-left of the display.
-) -> NonNull<Cp437GridCommand> {
+    fn new(
-    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+        grid: NonNull<Cp437Grid>,
-}
+        origin_x: usize,
+        origin_y: usize,
+    ) -> NonNull<Cp437GridCommand> {
+        heap_move_nonnull(Cp437GridCommand {
+            grid: unsafe { heap_remove(grid) },
+            origin: Origin::new(origin_x, origin_y),
+        })
+    }
 
-/// Tries to turn a [Cp437GridCommand] into a [Packet].
+    /// Moves the provided [Cp437Grid] into a new [Cp437GridCommand],
-///
+    /// leaving other fields as their default values.
-/// Returns: NULL or a [Packet] containing the command.
+    fn from_grid(
-#[no_mangle]
+        grid: NonNull<Cp437Grid>,
-pub unsafe extern "C" fn sp_cmd_cp437_grid_try_into_packet(
+    ) -> NonNull<Cp437GridCommand> {
-    command: NonNull<Cp437GridCommand>,
+        heap_move_nonnull(unsafe { heap_remove(grid) }.into())
-) -> *mut Packet {
+    }
-    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+
-}
+    /// Tries to turn a [Cp437GridCommand] into a [Packet].
+    ///
+    /// Returns: NULL or a [Packet] containing the command.
+    fn try_into_packet(
+        command: NonNull<Cp437GridCommand>,
+    ) -> *mut Packet {
+        heap_move_ok(unsafe { heap_remove(command) }.try_into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_cp437_grid::Cp437GridCommand);
 wrap_free!(sp_cmd_cp437_grid::Cp437GridCommand);

src/commands/global_brightness_command.rs

@@ -1,26 +1,25 @@
 use crate::{
-    macros::{wrap_clone, wrap_fields, wrap_free},
+    macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
     mem::{heap_move_nonnull, heap_remove},
 };
 use servicepoint::{Brightness, GlobalBrightnessCommand, Packet};
 use std::ptr::NonNull;
 
-/// Set the brightness of all tiles to the same value.
+wrap_functions!(sp_cmd_brightness_global;
-///
-/// Returns: a new [GlobalBrightnessCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cmd_brightness_global_new(
-    brightness: Brightness,
-) -> NonNull<GlobalBrightnessCommand> {
-    heap_move_nonnull(GlobalBrightnessCommand::from(brightness))
-}
 
-#[no_mangle]
+    /// Set the brightness of all tiles to the same value.
-pub unsafe extern "C" fn sp_cmd_brightness_global_into_packet(
+    ///
-    command: NonNull<GlobalBrightnessCommand>,
+    /// Returns: a new [GlobalBrightnessCommand] instance.
-) -> NonNull<Packet> {
+    fn new(brightness: Brightness) -> NonNull<GlobalBrightnessCommand> {
-    heap_move_nonnull(unsafe { heap_remove(command) }.into())
+        heap_move_nonnull(GlobalBrightnessCommand::from(brightness))
-}
+    }
+
+    /// Turns the command into a packet
+    fn into_packet(command: NonNull<GlobalBrightnessCommand>) -> NonNull<Packet> {
+        heap_move_nonnull(unsafe { heap_remove(command) }.into())
+    }
+
+);
 
 wrap_clone!(sp_cmd_brightness_global::GlobalBrightnessCommand);
 wrap_free!(sp_cmd_brightness_global::GlobalBrightnessCommand);

src/containers/bitmap.rs

@@ -1,6 +1,6 @@
 use crate::{
     containers::ByteSlice,
-    macros::{wrap_clone, wrap_free, wrap_methods},
+    macros::{wrap_clone, wrap_free, wrap_functions, wrap_methods},
     mem::{heap_move_nonnull, heap_move_ok, heap_move_some, heap_remove},
 };
 use servicepoint::{
@@ -9,80 +9,102 @@ use servicepoint::{
 };
 use std::ptr::NonNull;
 
-/// Creates a new [Bitmap] with the specified dimensions.
-///
-/// # Arguments
-///
-/// - `width`: size in pixels in x-direction
-/// - `height`: size in pixels in y-direction
-///
-/// returns: [Bitmap] initialized to all pixels off, or NULL in case of an error.
-///
-/// # Errors
-///
-/// In the following cases, this function will return NULL:
-///
-/// - when the width is not dividable by 8
-///
-/// # Examples
-///
-/// ```C
-/// Cp437Grid grid = sp_bitmap_new(8, 3);
-/// sp_bitmap_fill(grid, true);
-/// sp_bitmap_set(grid, 0, 0, false);
-/// sp_bitmap_free(grid);
-/// ```
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_new(
-    width: usize,
-    height: usize,
-) -> *mut Bitmap {
-    heap_move_some(Bitmap::new(width, height))
-}
-
-/// Creates a new [Bitmap] with a size matching the screen.
-///
-/// returns: [Bitmap] initialized to all pixels off.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_new_max_sized() -> NonNull<Bitmap> {
-    heap_move_nonnull(Bitmap::max_sized())
-}
-
-/// Loads a [Bitmap] with the specified dimensions from the provided data.
-///
-/// # Arguments
-///
-/// - `width`: size in pixels in x-direction
-/// - `height`: size in pixels in y-direction
-///
-/// returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_load(
-    width: usize,
-    height: usize,
-    data: ByteSlice,
-) -> *mut Bitmap {
-    let data = unsafe { data.as_slice() };
-    heap_move_ok(Bitmap::load(width, height, data))
-}
-
-/// Tries to convert the BitVec to a Bitmap.
-///
-/// The provided BitVec gets consumed.
-///
-/// Returns NULL in case of error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_from_bitvec(
-    width: usize,
-    bitvec: NonNull<DisplayBitVec>,
-) -> *mut Bitmap {
-    let bitvec = unsafe { heap_remove(bitvec) };
-    heap_move_ok(Bitmap::from_bitvec(width, bitvec))
-}
-
 wrap_clone!(sp_bitmap::Bitmap);
 wrap_free!(sp_bitmap::Bitmap);
 
+wrap_functions!(sp_bitmap;
+
+    /// Creates a new [Bitmap] with the specified dimensions.
+    ///
+    /// # Arguments
+    ///
+    /// - `width`: size in pixels in x-direction
+    /// - `height`: size in pixels in y-direction
+    ///
+    /// returns: [Bitmap] initialized to all pixels off, or NULL in case of an error.
+    ///
+    /// # Errors
+    ///
+    /// In the following cases, this function will return NULL:
+    ///
+    /// - when the width is not dividable by 8
+    ///
+    /// # Examples
+    ///
+    /// ```C
+    /// Cp437Grid grid = sp_bitmap_new(8, 3);
+    /// sp_bitmap_fill(grid, true);
+    /// sp_bitmap_set(grid, 0, 0, false);
+    /// sp_bitmap_free(grid);
+    /// ```
+    fn new(width: usize, height: usize) -> *mut Bitmap {
+        heap_move_some(Bitmap::new(width, height))
+    }
+
+    /// Creates a new [Bitmap] with a size matching the screen.
+    ///
+    /// returns: [Bitmap] initialized to all pixels off.
+    fn new_max_sized() -> NonNull<Bitmap> {
+        heap_move_nonnull(Bitmap::max_sized())
+    }
+
+    /// Loads a [Bitmap] with the specified dimensions from the provided data.
+    ///
+    /// # Arguments
+    ///
+    /// - `width`: size in pixels in x-direction
+    /// - `height`: size in pixels in y-direction
+    ///
+    /// returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
+    fn load(
+        width: usize,
+        height: usize,
+        data: ByteSlice,
+    ) -> *mut Bitmap {
+        let data = unsafe { data.as_slice() };
+        heap_move_ok(Bitmap::load(width, height, data))
+    }
+
+    /// Tries to convert the BitVec to a Bitmap.
+    ///
+    /// The provided BitVec gets consumed.
+    ///
+    /// Returns NULL in case of error.
+    fn from_bitvec(
+        width: usize,
+        bitvec: NonNull<DisplayBitVec>,
+    ) -> *mut Bitmap {
+        let bitvec = unsafe { heap_remove(bitvec) };
+        heap_move_ok(Bitmap::from_bitvec(width, bitvec))
+    }
+    /// Consumes the Bitmap and returns the contained BitVec.
+    fn into_bitvec(
+        bitmap: NonNull<Bitmap>
+    ) -> NonNull<DisplayBitVec> {
+        let bitmap = unsafe { heap_remove(bitmap) };
+        heap_move_nonnull(bitmap.into())
+    }
+
+    /// Creates a [BitmapCommand] and immediately turns that into a [Packet].
+    ///
+    /// The provided [Bitmap] gets consumed.
+    ///
+    /// Returns NULL in case of an error.
+    fn into_packet(
+        bitmap: NonNull<Bitmap>,
+        x: usize,
+        y: usize,
+        compression: CompressionCode,
+    ) -> *mut Packet {
+        let bitmap = unsafe { heap_remove(bitmap) };
+        heap_move_ok(Packet::try_from(BitmapCommand {
+            bitmap,
+            origin: Origin::new(x, y),
+            compression,
+        }))
+    }
+);
+
 wrap_methods!(
     sp_bitmap::Bitmap;
 
@@ -130,32 +152,3 @@ wrap_methods!(
         return(slice) { unsafe { ByteSlice::from_slice(slice) } };
     };
 );
-
-/// Consumes the Bitmap and returns the contained BitVec.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_into_bitvec(
-    bitmap: NonNull<Bitmap>,
-) -> NonNull<DisplayBitVec> {
-    let bitmap = unsafe { heap_remove(bitmap) };
-    heap_move_nonnull(bitmap.into())
-}
-
-/// Creates a [BitmapCommand] and immediately turns that into a [Packet].
-///
-/// The provided [Bitmap] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitmap_into_packet(
-    bitmap: NonNull<Bitmap>,
-    x: usize,
-    y: usize,
-    compression: CompressionCode,
-) -> *mut Packet {
-    let bitmap = unsafe { heap_remove(bitmap) };
-    heap_move_ok(Packet::try_from(BitmapCommand {
-        bitmap,
-        origin: Origin::new(x, y),
-        compression,
-    }))
-}

src/containers/bitvec.rs

@@ -1,6 +1,6 @@
 use crate::{
     containers::ByteSlice,
-    macros::{wrap_clone, wrap_free, wrap_methods},
+    macros::{wrap_clone, wrap_free, wrap_functions, wrap_methods},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{
@@ -8,32 +8,52 @@ use servicepoint::{
 };
 use std::ptr::NonNull;
 
-/// Creates a new [DisplayBitVec] instance.
+wrap_functions!(sp_bitvec;
-///
-/// # Arguments
-///
-/// - `size`: size in bits.
-///
-/// returns: [DisplayBitVec] with all bits set to false.
-///
-/// # Panics
-///
-/// - when `size` is not divisible by 8.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitvec_new(size: usize) -> NonNull<DisplayBitVec> {
-    heap_move_nonnull(DisplayBitVec::repeat(false, size))
-}
 
-/// Interpret the data as a series of bits and load then into a new [DisplayBitVec] instance.
+    /// Creates a new [DisplayBitVec] instance.
-///
+    ///
-/// returns: [DisplayBitVec] instance containing data.
+    /// # Arguments
-#[no_mangle]
+    ///
-pub unsafe extern "C" fn sp_bitvec_load(
+    /// - `size`: size in bits.
-    data: ByteSlice,
+    ///
-) -> NonNull<DisplayBitVec> {
+    /// returns: [DisplayBitVec] with all bits set to false.
-    let data = unsafe { data.as_slice() };
+    ///
-    heap_move_nonnull(DisplayBitVec::from_slice(data))
+    /// # Panics
-}
+    ///
+    /// - when `size` is not divisible by 8.
+    fn new(size: usize) -> NonNull<DisplayBitVec> {
+        heap_move_nonnull(DisplayBitVec::repeat(false, size))
+    }
+
+    /// Interpret the data as a series of bits and load then into a new [DisplayBitVec] instance.
+    ///
+    /// returns: [DisplayBitVec] instance containing data.
+    fn load(data: ByteSlice) -> NonNull<DisplayBitVec> {
+        let data = unsafe { data.as_slice() };
+        heap_move_nonnull(DisplayBitVec::from_slice(data))
+    }
+
+    /// Creates a [BitVecCommand] and immediately turns that into a [Packet].
+    ///
+    /// The provided [DisplayBitVec] gets consumed.
+    ///
+    /// Returns NULL in case of an error.
+    fn into_packet(
+        bitvec: NonNull<DisplayBitVec>,
+        offset: usize,
+        operation: BinaryOperation,
+        compression: CompressionCode,
+    ) -> *mut Packet {
+        let bitvec = unsafe { heap_remove(bitvec) };
+        heap_move_ok(Packet::try_from(BitVecCommand {
+            bitvec,
+            offset,
+            operation,
+            compression,
+        }))
+    }
+
+);
 
 wrap_clone!(sp_bitvec::DisplayBitVec);
 wrap_free!(sp_bitvec::DisplayBitVec);
@@ -90,24 +110,3 @@ wrap_methods!(
         return(slice) { unsafe { ByteSlice::from_slice(slice) } };
     };
 );
-
-/// Creates a [BitVecCommand] and immediately turns that into a [Packet].
-///
-/// The provided [DisplayBitVec] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_bitvec_into_packet(
-    bitvec: NonNull<DisplayBitVec>,
-    offset: usize,
-    operation: BinaryOperation,
-    compression: CompressionCode,
-) -> *mut Packet {
-    let bitvec = unsafe { heap_remove(bitvec) };
-    heap_move_ok(Packet::try_from(BitVecCommand {
-        bitvec,
-        offset,
-        operation,
-        compression,
-    }))
-}

src/containers/brightness_grid.rs

@@ -1,3 +1,4 @@
+use crate::macros::wrap_functions;
 use crate::{
     containers::ByteSlice,
     macros::{wrap_clone, wrap_free, wrap_methods},
@@ -9,48 +10,67 @@ use servicepoint::{
 };
 use std::{mem::transmute, ptr::NonNull};
 
-/// Creates a new [BrightnessGrid] with the specified dimensions.
+wrap_functions!(sp_brightness_grid;
-///
-/// returns: [BrightnessGrid] initialized to 0.
-///
-/// # Examples
-/// ```C
-/// UdpSocket *connection = sp_udp_open("127.0.0.1:2342");
-/// if (connection == NULL)
-///     return 1;
-///
-/// BrightnessGrid *grid = sp_brightness_grid_new(2, 2);
-/// sp_brightness_grid_set(grid, 0, 0, 0);
-/// sp_brightness_grid_set(grid, 1, 1, 10);
-///
-/// TypedCommand *command = sp_command_char_brightness(grid);
-/// sp_udp_free(connection);
-/// ```
-#[no_mangle]
-pub unsafe extern "C" fn sp_brightness_grid_new(
-    width: usize,
-    height: usize,
-) -> NonNull<BrightnessGrid> {
-    heap_move_nonnull(BrightnessGrid::new(width, height))
-}
 
-/// Loads a [BrightnessGrid] with the specified dimensions from the provided data.
+    /// Creates a new [BrightnessGrid] with the specified dimensions.
-///
+    ///
-/// Any out of range values will be set to [Brightness::MAX] or [Brightness::MIN].
+    /// returns: [BrightnessGrid] initialized to 0.
-///
+    ///
-/// returns: new [BrightnessGrid] instance, or NULL in case of an error.
+    /// # Examples
-#[no_mangle]
+    /// ```C
-pub unsafe extern "C" fn sp_brightness_grid_load(
+    /// UdpSocket *connection = sp_udp_open("127.0.0.1:2342");
-    width: usize,
+    /// if (connection == NULL)
-    height: usize,
+    ///     return 1;
-    data: ByteSlice,
+    ///
-) -> *mut BrightnessGrid {
+    /// BrightnessGrid *grid = sp_brightness_grid_new(2, 2);
-    let data = unsafe { data.as_slice() };
+    /// sp_brightness_grid_set(grid, 0, 0, 0);
-    heap_move_some(
+    /// sp_brightness_grid_set(grid, 1, 1, 10);
-        ByteGrid::load(width, height, data)
+    ///
-            .map(move |grid| grid.map(Brightness::saturating_from)),
+    /// TypedCommand *command = sp_command_char_brightness(grid);
-    )
+    /// sp_udp_free(connection);
-}
+    /// ```
+    fn new(
+        width: usize,
+        height: usize,
+    ) -> NonNull<BrightnessGrid> {
+        heap_move_nonnull(BrightnessGrid::new(width, height))
+    }
+
+    /// Loads a [BrightnessGrid] with the specified dimensions from the provided data.
+    ///
+    /// Any out of range values will be set to [Brightness::MAX] or [Brightness::MIN].
+    ///
+    /// returns: new [BrightnessGrid] instance, or NULL in case of an error.
+    fn load(
+        width: usize,
+        height: usize,
+        data: ByteSlice,
+    ) -> *mut BrightnessGrid {
+        let data = unsafe { data.as_slice() };
+        heap_move_some(
+            ByteGrid::load(width, height, data)
+                .map(move |grid| grid.map(Brightness::saturating_from)),
+        )
+    }
+
+    /// Creates a [BrightnessGridCommand] and immediately turns that into a [Packet].
+    ///
+    /// The provided [BrightnessGrid] gets consumed.
+    ///
+    /// Returns NULL in case of an error.
+    fn into_packet(
+        grid: NonNull<BrightnessGrid>,
+        x: usize,
+        y: usize,
+    ) -> *mut Packet {
+        let grid = unsafe { heap_remove(grid) };
+        heap_move_ok(Packet::try_from(BrightnessGridCommand {
+            grid,
+            origin: Origin::new(x, y),
+        }))
+    }
+
+);
 
 wrap_clone!(sp_brightness_grid::BrightnessGrid);
 wrap_free!(sp_brightness_grid::BrightnessGrid);
@@ -109,21 +129,3 @@ wrap_methods!(
         }};
     };
 );
-
-/// Creates a [BrightnessGridCommand] and immediately turns that into a [Packet].
-///
-/// The provided [BrightnessGrid] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_brightness_grid_into_packet(
-    grid: NonNull<BrightnessGrid>,
-    x: usize,
-    y: usize,
-) -> *mut Packet {
-    let grid = unsafe { heap_remove(grid) };
-    heap_move_ok(Packet::try_from(BrightnessGridCommand {
-        grid,
-        origin: Origin::new(x, y),
-    }))
-}

src/containers/char_grid.rs

@@ -1,43 +1,62 @@
 use crate::{
     containers::ByteSlice,
-    macros::{wrap_clone, wrap_free, wrap_methods},
+    macros::{wrap_clone, wrap_free, wrap_functions, wrap_methods},
     mem::{heap_move_nonnull, heap_move_ok, heap_remove},
 };
 use servicepoint::{CharGrid, CharGridCommand, Grid, Origin, Packet};
 use std::ptr::NonNull;
 
-/// Creates a new [CharGrid] with the specified dimensions.
+wrap_functions!(sp_char_grid;
-///
-/// returns: [CharGrid] initialized to 0.
-///
-/// # Examples
-///
-/// ```C
-/// CharGrid grid = sp_char_grid_new(4, 3);
-/// sp_char_grid_fill(grid, '?');
-/// sp_char_grid_set(grid, 0, 0, '!');
-/// sp_char_grid_free(grid);
-/// ```
-#[no_mangle]
-pub unsafe extern "C" fn sp_char_grid_new(
-    width: usize,
-    height: usize,
-) -> NonNull<CharGrid> {
-    heap_move_nonnull(CharGrid::new(width, height))
-}
 
-/// Loads a [CharGrid] with the specified dimensions from the provided data.
+    /// Creates a new [CharGrid] with the specified dimensions.
-///
+    ///
-/// returns: new CharGrid or NULL in case of an error
+    /// returns: [CharGrid] initialized to 0.
-#[no_mangle]
+    ///
-pub unsafe extern "C" fn sp_char_grid_load(
+    /// # Examples
-    width: usize,
+    ///
-    height: usize,
+    /// ```C
-    data: ByteSlice,
+    /// CharGrid grid = sp_char_grid_new(4, 3);
-) -> *mut CharGrid {
+    /// sp_char_grid_fill(grid, '?');
-    let data = unsafe { data.as_slice() };
+    /// sp_char_grid_set(grid, 0, 0, '!');
-    heap_move_ok(CharGrid::load_utf8(width, height, data.to_vec()))
+    /// sp_char_grid_free(grid);
-}
+    /// ```
+    fn new(
+        width: usize,
+        height: usize,
+    ) -> NonNull<CharGrid> {
+        heap_move_nonnull(CharGrid::new(width, height))
+    }
+
+    /// Loads a [CharGrid] with the specified dimensions from the provided data.
+    ///
+    /// returns: new CharGrid or NULL in case of an error
+    fn load(
+        width: usize,
+        height: usize,
+        data: ByteSlice,
+    ) -> *mut CharGrid {
+        let data = unsafe { data.as_slice() };
+        heap_move_ok(CharGrid::load_utf8(width, height, data.to_vec()))
+    }
+
+    /// Creates a [CharGridCommand] and immediately turns that into a [Packet].
+    ///
+    /// The provided [CharGrid] gets consumed.
+    ///
+    /// Returns NULL in case of an error.
+    fn into_packet(
+        grid: NonNull<CharGrid>,
+        x: usize,
+        y: usize,
+    ) -> *mut Packet {
+        let grid = unsafe { heap_remove(grid) };
+        heap_move_ok(Packet::try_from(CharGridCommand {
+            grid,
+            origin: Origin::new(x, y),
+        }))
+    }
+
+);
 
 wrap_clone!(sp_char_grid::CharGrid);
 wrap_free!(sp_char_grid::CharGrid);
@@ -91,21 +110,3 @@ wrap_methods!(
     /// Gets the height of the grid.
     ref fn height() -> usize;
 );
-
-/// Creates a [CharGridCommand] and immediately turns that into a [Packet].
-///
-/// The provided [CharGrid] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_char_grid_into_packet(
-    grid: NonNull<CharGrid>,
-    x: usize,
-    y: usize,
-) -> *mut Packet {
-    let grid = unsafe { heap_remove(grid) };
-    heap_move_ok(Packet::try_from(CharGridCommand {
-        grid,
-        origin: Origin::new(x, y),
-    }))
-}

src/containers/cp437_grid.rs

@@ -1,3 +1,4 @@
+use crate::macros::wrap_functions;
 use crate::{
     containers::ByteSlice,
     macros::{wrap_clone, wrap_free, wrap_methods},
@@ -8,27 +9,46 @@ use servicepoint::{
 };
 use std::ptr::NonNull;
 
-/// Creates a new [Cp437Grid] with the specified dimensions.
+wrap_functions!(sp_cp437_grid;
-///
-/// returns: [Cp437Grid] initialized to 0.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cp437_grid_new(
-    width: usize,
-    height: usize,
-) -> NonNull<Cp437Grid> {
-    heap_move_nonnull(Cp437Grid::new(width, height))
-}
 
-/// Loads a [Cp437Grid] with the specified dimensions from the provided data.
+    /// Creates a new [Cp437Grid] with the specified dimensions.
-#[no_mangle]
+    ///
-pub unsafe extern "C" fn sp_cp437_grid_load(
+    /// returns: [Cp437Grid] initialized to 0.
-    width: usize,
+    fn new(
-    height: usize,
+        width: usize,
-    data: ByteSlice,
+        height: usize,
-) -> *mut Cp437Grid {
+    ) -> NonNull<Cp437Grid> {
-    let data = unsafe { data.as_slice() };
+        heap_move_nonnull(Cp437Grid::new(width, height))
-    heap_move_some(Cp437Grid::load(width, height, data))
+    }
-}
+
+    /// Loads a [Cp437Grid] with the specified dimensions from the provided data.
+    fn load(
+        width: usize,
+        height: usize,
+        data: ByteSlice,
+    ) -> *mut Cp437Grid {
+        let data = unsafe { data.as_slice() };
+        heap_move_some(Cp437Grid::load(width, height, data))
+    }
+
+    /// Creates a [Cp437GridCommand] and immediately turns that into a [Packet].
+    ///
+    /// The provided [Cp437Grid] gets consumed.
+    ///
+    /// Returns NULL in case of an error.
+    fn into_packet(
+        grid: NonNull<Cp437Grid>,
+        x: usize,
+        y: usize,
+    ) -> *mut Packet {
+        let grid = unsafe { heap_remove(grid) };
+        heap_move_ok(Packet::try_from(Cp437GridCommand {
+            grid,
+            origin: Origin::new(x, y),
+        }))
+    }
+
+);
 
 wrap_clone!(sp_cp437_grid::Cp437Grid);
 wrap_free!(sp_cp437_grid::Cp437Grid);
@@ -81,21 +101,3 @@ wrap_methods!(
         return(slice) { unsafe { ByteSlice::from_slice(slice) } };
     };
 );
-
-/// Creates a [Cp437GridCommand] and immediately turns that into a [Packet].
-///
-/// The provided [Cp437Grid] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_cp437_grid_into_packet(
-    grid: NonNull<Cp437Grid>,
-    x: usize,
-    y: usize,
-) -> *mut Packet {
-    let grid = unsafe { heap_remove(grid) };
-    heap_move_ok(Packet::try_from(Cp437GridCommand {
-        grid,
-        origin: Origin::new(x, y),
-    }))
-}

src/macros.rs

@@ -47,7 +47,7 @@ macro_rules! wrap_methods {
                 $(return($it:ident) $return_expr:block;)?
             })?
             ;
-        )*
+        )+
     ) => {
         paste::paste! {
             $(
@@ -76,7 +76,7 @@ macro_rules! wrap_methods {
                 )?
                 return result;
             }
-            )*
+            )+
         }
     };
 }
@@ -149,7 +149,33 @@ macro_rules! wrap_fields {
     };
 }
 
+macro_rules! wrap_functions {
+    (
+        $prefix:ident;
+        $(
+            $(#[$meta:meta])+
+            fn $function:ident($($param_name:ident: $param_type:ty),*$(,)?)
+            $(-> $return_type:ty)?
+            $block:block
+        )+
+    ) => {
+        ::paste::paste! {
+        $(
+            $(#[$meta])*
+            #[doc = ""]
+            #[doc = concat!(" This function is part of the ", stringify!($prefix), " module.")]
+            #[no_mangle]
+            pub unsafe extern "C" fn [<$prefix _ $function>](
+                $($param_name: $param_type),*
+            ) $(-> $return_type)?
+            $block
+
+        )+
+        }
+    };
+}
+
 pub(crate) use {
     nonnull_as_mut, nonnull_as_ref, wrap_clone, wrap_fields, wrap_free,
-    wrap_methods,
+    wrap_functions, wrap_methods,
 };