expose tagged union instead of TypedCommand to C

Reviewed-on: #1

README.md

@@ -1,9 +1,11 @@
 # servicepoint_binding_c
 
+[![Release](https://git.berlin.ccc.de/servicepoint/servicepoint_binding_c/badges/release.svg)](https://git.berlin.ccc.de/servicepoint/servicepoint_binding_c/releases)
 [![crates.io](https://img.shields.io/crates/v/servicepoint_binding_c.svg)](https://crates.io/crates/servicepoint)
 [![Crates.io Total Downloads](https://img.shields.io/crates/d/servicepoint_binding_c)](https://crates.io/crates/servicepoint)
 [![docs.rs](https://img.shields.io/docsrs/servicepoint_binding_c)](https://docs.rs/servicepoint/latest/servicepoint/)
 [![GPLv3 licensed](https://img.shields.io/crates/l/servicepoint_binding_c)](./LICENSE)
+[![CI](https://git.berlin.ccc.de/servicepoint/servicepoint_binding_c/badges/workflows/rust.yml/badge.svg)](https://git.berlin.ccc.de/servicepoint/servicepoint_binding_c)
 
 In [CCCB](https://berlin.ccc.de/), there is a big pixel matrix hanging on the wall.
 It is called  "Service Point Display" or "Airport Display".
@@ -12,7 +14,7 @@ This crate contains C bindings for the [servicepoint](https://git.berlin.ccc.de/
 
 ## Examples
 
-```c++
+```c
 #include <stdio.h>
 #include "servicepoint.h"
 

cbindgen.toml

@@ -32,11 +32,12 @@ features = ["full"]
 
 [export]
 include = []
-exclude = []
+exclude = ["BitVec"]
 
 [export.rename]
 "SpBitVec" = "BitVec"
 "SpByteSlice" = "ByteSlice"
+"SpCommand" = "Command"
 
 [enum]
 rename_variants = "QualifiedScreamingSnakeCase"

example/src/brightness_tester.c

@@ -1,30 +1,44 @@
 #include "servicepoint.h"
 
-int main(void) {
+static UdpSocket *connection = NULL;
-    UdpSocket *connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
-    //UdpSocket *connection = sp_udp_open_ipv4(127, 0, 0, 1, 2342);
-    if (connection == NULL)
-        return -1;
 
+void enable_all_pixels(void) {
     Bitmap *all_on = sp_bitmap_new_max_sized();
     sp_bitmap_fill(all_on, true);
 
-    Packet *packet = sp_bitmap_into_packet(all_on, 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
+    BitmapCommand *bitmapCommand = sp_cmd_bitmap_from_bitmap(all_on);
-    if (packet == NULL)
+    Packet *packet = sp_cmd_bitmap_into_packet(bitmapCommand);
-        return -1;
+    if (packet != NULL)
-
         sp_udp_send_packet(connection, packet);
+}
 
-    BrightnessGrid *grid = sp_brightness_grid_new(TILE_WIDTH, TILE_HEIGHT);
+void make_brightness_pattern(BrightnessGrid *grid) {
-
     ByteSlice slice = sp_brightness_grid_unsafe_data_ref(grid);
     for (size_t index = 0; index < slice.length; index++) {
         slice.start[index] = (uint8_t) (index % ((size_t) Brightness_MAX));
     }
+}
 
-    packet = sp_brightness_grid_into_packet(grid, 0, 0);
+void run_at_exit() {
-    sp_udp_send_packet(connection, packet);
-
     sp_udp_free(connection);
+}
+
+int main(void) {
+    //UdpSocket *connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
+    connection = sp_udp_open_ipv4(127, 0, 0, 1, 2342);
+    if (connection == NULL)
+        return -1;
+    atexit(run_at_exit);
+
+    enable_all_pixels();
+
+    BrightnessGrid *grid = sp_brightness_grid_new(TILE_WIDTH, TILE_HEIGHT);
+    make_brightness_pattern(grid);
+
+    Packet *packet = sp_cmd_brightness_grid_into_packet(sp_cmd_brightness_grid_from_grid(grid));
+    if (packet == NULL)
+      return -2;
+
+    sp_udp_send_packet(connection, packet);
     return 0;
 }

include/servicepoint.h

@@ -125,6 +125,27 @@ enum CommandCode
 typedef uint16_t CommandCode;
 #endif // __cplusplus
 
+enum CommandTag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+    COMMAND_TAG_INVALID = 0,
+    COMMAND_TAG_BITMAP,
+    COMMAND_TAG_BIT_VEC,
+    COMMAND_TAG_BRIGHTNESS_GRID,
+    COMMAND_TAG_CHAR_GRID,
+    COMMAND_TAG_CP437_GRID,
+    COMMAND_TAG_GLOBAL_BRIGHTNESS,
+    COMMAND_TAG_CLEAR,
+    COMMAND_TAG_HARD_RESET,
+    COMMAND_TAG_FADE_OUT,
+    COMMAND_TAG_BITMAP_LEGACY,
+};
+#ifndef __cplusplus
+typedef uint8_t CommandTag;
+#endif // __cplusplus
+
 /**
  * Specifies the kind of compression to use. Availability depends on features.
  *
@@ -179,6 +200,22 @@ enum CompressionCode
 typedef uint16_t CompressionCode;
 #endif // __cplusplus
 
+/**
+ * Set pixel data starting at the pixel offset on screen.
+ *
+ * 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.
+ */
+typedef struct BitVecCommand BitVecCommand;
+
 /**
  * A fixed-size 2D grid of booleans.
  *
@@ -196,6 +233,160 @@ typedef uint16_t CompressionCode;
  */
 typedef struct Bitmap Bitmap;
 
+/**
+ * Overwrites a rectangular region of pixels.
+ *
+ * Origin coordinates must be divisible by 8.
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * #
+ * let mut bitmap = Bitmap::max_sized();
+ * // draw something to the pixels here
+ * # bitmap.set(2, 5, true);
+ *
+ * // create command to send pixels
+ * let command = BitmapCommand {
+ *     bitmap,
+ *     origin: Origin::ZERO,
+ *     compression: CompressionCode::Uncompressed
+ * };
+ *
+ * connection.send_command(command).expect("send failed");
+ * ```
+ */
+typedef struct BitmapCommand BitmapCommand;
+
+/**
+ * Legacy command code, gets ignored by the real display.
+ *
+ * Might be useful as a noop package.
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * // this sends a packet that does nothing
+ * # #[allow(deprecated)]
+ * connection.send_command(BitmapLegacyCommand).unwrap();
+ * ```
+ */
+typedef struct BitmapLegacyCommand BitmapLegacyCommand;
+
+/**
+ * Set the brightness of individual tiles in a rectangular area of the display.
+ */
+typedef struct BrightnessGridCommand BrightnessGridCommand;
+
+/**
+ * Show text on the screen.
+ *
+ * The text is sent in the form of a 2D grid of UTF-8 encoded characters (the default encoding in rust).
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * let grid = CharGrid::from("Hello,\nWorld!");
+ * connection.send_command(CharGridCommand { origin: Origin::ZERO, grid }).expect("send failed");
+ * ```
+ */
+typedef struct CharGridCommand CharGridCommand;
+
+/**
+ * Set all pixels to the off state. Does not affect brightness.
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * connection.send_command(ClearCommand).unwrap();
+ * ```
+ */
+typedef struct ClearCommand ClearCommand;
+
+/**
+ * Show text on the screen.
+ *
+ * The text is sent in the form of a 2D grid of [CP-437] encoded characters.
+ *
+ * <div class="warning">You probably want to use [Command::Utf8Data] instead</div>
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * let grid = CharGrid::from("Hello,\nWorld!");
+ * let grid = Cp437Grid::from(&grid);
+ * connection.send_command(Cp437GridCommand{ origin: Origin::ZERO, grid }).expect("send failed");
+ * ```
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * let grid = Cp437Grid::load_ascii("Hello\nWorld", 5, false).unwrap();
+ * connection.send_command(Cp437GridCommand{ origin: Origin::new(2, 2), grid }).unwrap();
+ * ```
+ * [CP-437]: https://en.wikipedia.org/wiki/Code_page_437
+ */
+typedef struct Cp437GridCommand Cp437GridCommand;
+
+/**
+ * This is a type only used by cbindgen to have a type for pointers.
+ */
+typedef struct DisplayBitVec DisplayBitVec;
+
+/**
+ * <div class="warning">Untested</div>
+ *
+ * Slowly decrease brightness until off or something like that?
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * connection.send_command(FadeOutCommand).unwrap();
+ * ```
+ */
+typedef struct FadeOutCommand FadeOutCommand;
+
+/**
+ * Set the brightness of all tiles to the same value.
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * let command = GlobalBrightnessCommand { brightness: Brightness::MAX };
+ * connection.send_command(command).unwrap();
+ * ```
+ */
+typedef struct GlobalBrightnessCommand GlobalBrightnessCommand;
+
+/**
+ * Kills the udp daemon on the display, which usually results in a restart.
+ *
+ * Please do not send this in your normal program flow.
+ *
+ * # Examples
+ *
+ * ```rust
+ * # use servicepoint::*;
+ * # let connection = FakeConnection;
+ * connection.send_command(HardResetCommand).unwrap();
+ * ```
+ */
+typedef struct HardResetCommand HardResetCommand;
+
 /**
  * The raw packet.
  *
@@ -217,14 +408,6 @@ typedef struct Packet Packet;
  */
 typedef struct SPBitVec SPBitVec;
 
-/**
- * This enum contains all commands provided by the library.
- * This is useful in case you want one data type for all kinds of commands without using `dyn`.
- *
- * Please look at the contained structs for documentation per command.
- */
-typedef struct TypedCommand TypedCommand;
-
 /**
  * This is a type only used by cbindgen to have a type for pointers.
  */
@@ -348,6 +531,11 @@ typedef uint8_t Brightness;
  */
 typedef ValueGrid_char CharGrid;
 
+/**
+ * Type alias for documenting the meaning of the u16 in enum values
+ */
+typedef size_t Offset;
+
 /**
  * A grid containing codepage 437 characters.
  *
@@ -355,6 +543,31 @@ typedef ValueGrid_char CharGrid;
  */
 typedef ValueGrid_u8 Cp437Grid;
 
+typedef union {
+    uint8_t *null;
+    BitmapCommand */*notnull*/ bitmap;
+    BitVecCommand */*notnull*/ bitvec;
+    BrightnessGridCommand */*notnull*/ brightness_grid;
+    CharGridCommand */*notnull*/ char_grid;
+    Cp437GridCommand */*notnull*/ cp437_grid;
+    GlobalBrightnessCommand */*notnull*/ global_brightness;
+    ClearCommand */*notnull*/ clear;
+    BitmapLegacyCommand */*notnull*/ bitmap_legacy;
+    HardResetCommand */*notnull*/ hard_reset;
+    FadeOutCommand */*notnull*/ fade_out;
+} CommandUnion;
+
+typedef struct {
+    /**
+     * Specifies which kind of command struct is contained in `data`
+     */
+    CommandTag tag;
+    /**
+     * The pointer to the command struct
+     */
+    CommandUnion data;
+} SPCommand;
+
 /**
  * A raw header.
  *
@@ -669,7 +882,7 @@ ByteSlice sp_bitvec_unsafe_data_ref(SPBitVec */*notnull*/ bit_vec);
 /**
  * Clones a [BrightnessGrid].
  */
-BrightnessGrid */*notnull*/ sp_brightness_grid_clone(BrightnessGrid */*notnull*/ brightness_grid);
+BrightnessGrid */*notnull*/ sp_brightness_grid_clone(BrightnessGrid */*notnull*/ grid);
 
 /**
  * Sets the value of all cells in the [BrightnessGrid].
@@ -744,15 +957,15 @@ BrightnessGrid *sp_brightness_grid_load(size_t width,
  *
  * # Examples
  * ```C
- * UdpConnection connection = sp_udp_open("127.0.0.1:2342");
+ * UdpSocket *connection = sp_udp_open("127.0.0.1:2342");
  * if (connection == NULL)
  *     return 1;
  *
- * BrightnessGrid grid = sp_brightness_grid_new(2, 2);
+ * 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);
+ * TypedCommand *command = sp_command_char_brightness(grid);
  * sp_udp_free(connection);
  * ```
  */
@@ -805,7 +1018,7 @@ size_t sp_brightness_grid_width(BrightnessGrid */*notnull*/ brightness_grid);
 /**
  * Clones a [CharGrid].
  */
-CharGrid */*notnull*/ sp_char_grid_clone(CharGrid */*notnull*/ char_grid);
+CharGrid */*notnull*/ sp_char_grid_clone(CharGrid */*notnull*/ grid);
 
 /**
  * Sets the value of all cells in the [CharGrid].
@@ -908,18 +1121,75 @@ void sp_char_grid_set(CharGrid */*notnull*/ char_grid,
  */
 size_t sp_char_grid_width(CharGrid */*notnull*/ char_grid);
 
+BitmapCommand */*notnull*/ sp_cmd_bitmap_clone(BitmapCommand */*notnull*/ command);
+
+void sp_cmd_bitmap_free(BitmapCommand */*notnull*/ command);
+
+/**
+ * Move the provided [Bitmap] into a new [BitmapCommand],
+ * leaving other fields as their default values.
+ *
+ * Rust equivalent: [`<BitmapCommand as From<Bitmap>>::from`]
+ */
+BitmapCommand */*notnull*/ sp_cmd_bitmap_from_bitmap(Bitmap */*notnull*/ bitmap);
+
+/**
+ * Returns a pointer to the provided `BitmapCommand`.
+ *
+ * # Safety
+ *
+ * - The returned bitmap inherits the lifetime of the command in which it is contained.
+ * - The returned pointer may not be used in a function that consumes the instance, e.g. to create a command.
+ */
+Bitmap */*notnull*/ sp_cmd_bitmap_get(BitmapCommand */*notnull*/ command);
+
+CompressionCode sp_cmd_bitmap_get_compression(BitmapCommand */*notnull*/ command);
+
+void sp_cmd_bitmap_get_origin(BitmapCommand */*notnull*/ command,
+                              size_t */*notnull*/ origin_x,
+                              size_t */*notnull*/ origin_y);
+
+Packet *sp_cmd_bitmap_into_packet(BitmapCommand */*notnull*/ command);
+
 /**
  * Sets a window of pixels to the specified values.
  *
  * The passed [Bitmap] gets consumed.
  *
- * Returns: a new [servicepoint::BitmapCommand] instance.
+ * Returns: a new [BitmapCommand] instance.
  */
-TypedCommand *sp_command_bitmap(size_t x,
+BitmapCommand */*notnull*/ sp_cmd_bitmap_new(Bitmap */*notnull*/ bitmap,
-                                size_t y,
+                                             size_t origin_x,
-                                Bitmap */*notnull*/ bitmap,
+                                             size_t origin_y,
                                              CompressionCode compression);
 
+/**
+ * Moves the provided bitmap to be contained in the command.
+ */
+void sp_cmd_bitmap_set(BitmapCommand */*notnull*/ command,
+                       Bitmap */*notnull*/ bitmap);
+
+void sp_cmd_bitmap_set_compression(BitmapCommand */*notnull*/ command,
+                                   CompressionCode compression);
+
+void sp_cmd_bitmap_set_origin(BitmapCommand */*notnull*/ command,
+                              size_t origin_x,
+                              size_t origin_y);
+
+BitVecCommand */*notnull*/ sp_cmd_bitvec_clone(BitVecCommand */*notnull*/ command);
+
+void sp_cmd_bitvec_free(BitVecCommand */*notnull*/ command);
+
+DisplayBitVec *sp_cmd_bitvec_get(BitVecCommand */*notnull*/ command);
+
+CompressionCode sp_cmd_bitvec_get_compression(BitVecCommand */*notnull*/ command);
+
+Offset sp_cmd_bitvec_get_offset(BitVecCommand */*notnull*/ command);
+
+BinaryOperation sp_cmd_bitvec_get_operation(BitVecCommand */*notnull*/ command);
+
+Packet *sp_cmd_bitvec_into_packet(BitVecCommand */*notnull*/ command);
+
 /**
  * Set pixel data starting at the pixel offset on screen.
  *
@@ -932,77 +1202,163 @@ TypedCommand *sp_command_bitmap(size_t x,
  *
  * For example, [`BinaryOperation::Or`] can be used to turn on some pixels without affecting other pixels.
  *
- * The contained [`BitVecU8Msb0`] is always uncompressed.
+ * The contained [`DisplayBitVec`] is always uncompressed.
  */
-TypedCommand *sp_command_bitvec(size_t offset,
+BitVecCommand */*notnull*/ sp_cmd_bitvec_new(DisplayBitVec */*notnull*/ bitvec,
-                                SPBitVec */*notnull*/ bit_vec,
+                                             size_t offset,
-                                CompressionCode compression,
+                                             BinaryOperation operation,
+                                             CompressionCode compression);
+
+/**
+ * Moves the provided bitmap to be contained in the command.
+ */
+void sp_cmd_bitvec_set(BitVecCommand */*notnull*/ command,
+                       DisplayBitVec */*notnull*/ bitvec);
+
+void sp_cmd_bitvec_set_compression(BitVecCommand */*notnull*/ command,
+                                   CompressionCode compression);
+
+void sp_cmd_bitvec_set_offset(BitVecCommand */*notnull*/ command,
+                              Offset offset);
+
+void sp_cmd_bitvec_set_operation(BitVecCommand */*notnull*/ command,
                                  BinaryOperation operation);
 
-/**
+GlobalBrightnessCommand */*notnull*/ sp_cmd_brightness_global_clone(GlobalBrightnessCommand */*notnull*/ command);
- * Set the brightness of individual tiles in a rectangular area of the display.
+
- *
+void sp_cmd_brightness_global_free(BitmapCommand */*notnull*/ command);
- * The passed [BrightnessGrid] gets consumed.
+
- *
+Brightness *sp_cmd_brightness_global_get(GlobalBrightnessCommand */*notnull*/ command);
- * Returns: a new [servicepoint::Command::CharBrightness] instance.
+
- */
+Packet *sp_cmd_brightness_global_into_packet(GlobalBrightnessCommand */*notnull*/ command);
-TypedCommand */*notnull*/ sp_command_brightness_grid(size_t x,
+
-                                                     size_t y,
+GlobalBrightnessCommand */*notnull*/ sp_cmd_brightness_global_new(Brightness brightness);
-                                                     BrightnessGrid */*notnull*/ grid);
 
 /**
- * Show UTF-8 encoded text on the screen.
+ * Moves the provided bitmap to be contained in the command.
- *
- * The passed [CharGrid] gets consumed.
- *
- * Returns: a new [servicepoint::CharGridCommand] instance.
  */
-TypedCommand */*notnull*/ sp_command_char_grid(size_t x,
+void sp_cmd_brightness_global_set(GlobalBrightnessCommand */*notnull*/ command,
-                                               size_t y,
+                                  Brightness brightness);
+
+BrightnessGridCommand */*notnull*/ sp_cmd_brightness_grid_clone(BrightnessGridCommand */*notnull*/ command);
+
+void sp_cmd_brightness_grid_free(BitmapCommand */*notnull*/ command);
+
+BrightnessGridCommand */*notnull*/ sp_cmd_brightness_grid_from_grid(BrightnessGrid */*notnull*/ grid);
+
+BrightnessGrid *sp_cmd_brightness_grid_get(BrightnessGridCommand */*notnull*/ command);
+
+void sp_cmd_brightness_grid_get_origin(BrightnessGridCommand */*notnull*/ command,
+                                       size_t */*notnull*/ origin_x,
+                                       size_t */*notnull*/ origin_y);
+
+Packet *sp_cmd_brightness_grid_into_packet(BrightnessGridCommand */*notnull*/ command);
+
+BrightnessGridCommand */*notnull*/ sp_cmd_brightness_grid_new(BrightnessGrid */*notnull*/ grid,
+                                                              size_t origin_x,
+                                                              size_t origin_y);
+
+/**
+ * Moves the provided bitmap to be contained in the command.
+ */
+void sp_cmd_brightness_grid_set(BrightnessGridCommand */*notnull*/ command,
+                                BrightnessGrid */*notnull*/ grid);
+
+void sp_cmd_brightness_grid_set_origin(BrightnessGridCommand */*notnull*/ command,
+                                       size_t origin_x,
+                                       size_t origin_y);
+
+CharGridCommand */*notnull*/ sp_cmd_char_grid_clone(CharGridCommand */*notnull*/ command);
+
+void sp_cmd_char_grid_free(BitmapCommand */*notnull*/ command);
+
+CharGridCommand */*notnull*/ sp_cmd_char_grid_from_grid(CharGrid */*notnull*/ grid);
+
+CharGrid *sp_cmd_char_grid_get(CharGridCommand */*notnull*/ command);
+
+void sp_cmd_char_grid_get_origin(CharGridCommand */*notnull*/ command,
+                                 size_t */*notnull*/ origin_x,
+                                 size_t */*notnull*/ origin_y);
+
+Packet *sp_cmd_char_grid_into_packet(CharGridCommand */*notnull*/ command);
+
+CharGridCommand */*notnull*/ sp_cmd_char_grid_new(CharGrid */*notnull*/ grid,
+                                                  size_t origin_x,
+                                                  size_t origin_y);
+
+/**
+ * Moves the provided bitmap to be contained in the command.
+ */
+void sp_cmd_char_grid_set(CharGridCommand */*notnull*/ command,
                           CharGrid */*notnull*/ grid);
 
+void sp_cmd_char_grid_set_origin(CharGridCommand */*notnull*/ command,
+                                 size_t origin_x,
+                                 size_t origin_y);
+
+void sp_cmd_clear_free(ClearCommand */*notnull*/ command);
+
 /**
  * Set all pixels to the off state.
  *
  * Does not affect brightness.
  *
- * Returns: a new [servicepoint::Command::Clear] instance.
+ * Returns: a new [ClearCommand] instance.
  *
  * # Examples
  *
  * ```C
- * sp_udp_send_command(connection, sp_command_clear());
+ * sp_udp_send_command(connection, sp_cmd_clear());
  * ```
  */
-TypedCommand */*notnull*/ sp_command_clear(void);
+ClearCommand */*notnull*/ sp_cmd_clear_new(void);
+
+Cp437GridCommand */*notnull*/ sp_cmd_cp437_grid_clone(Cp437GridCommand */*notnull*/ command);
+
+void sp_cmd_cp437_grid_free(BitmapCommand */*notnull*/ command);
+
+Cp437GridCommand */*notnull*/ sp_cmd_cp437_grid_from_grid(Cp437Grid */*notnull*/ grid);
+
+Cp437Grid *sp_cmd_cp437_grid_get(Cp437GridCommand */*notnull*/ command);
+
+void sp_cmd_cp437_grid_get_origin(Cp437GridCommand */*notnull*/ command,
+                                  size_t */*notnull*/ origin_x,
+                                  size_t */*notnull*/ origin_y);
+
+Packet *sp_cmd_cp437_grid_into_packet(Cp437GridCommand */*notnull*/ command);
+
+Cp437GridCommand */*notnull*/ sp_cmd_cp437_grid_new(Cp437Grid */*notnull*/ grid,
+                                                    size_t origin_x,
+                                                    size_t origin_y);
 
 /**
- * Clones a [TypedCommand] instance.
+ * Moves the provided bitmap to be contained in the command.
- *
- * returns: new [TypedCommand] instance.
  */
-TypedCommand */*notnull*/ sp_command_clone(TypedCommand */*notnull*/ command);
+void sp_cmd_cp437_grid_set(Cp437GridCommand */*notnull*/ command,
-
-/**
- * Show codepage 437 encoded text on the screen.
- *
- * The passed [Cp437Grid] gets consumed.
- *
- * Returns: a new [servicepoint::Cp437GridCommand] instance.
- */
-TypedCommand */*notnull*/ sp_command_cp437_grid(size_t x,
-                                                size_t y,
                            Cp437Grid */*notnull*/ grid);
 
+void sp_cmd_cp437_grid_set_origin(Cp437GridCommand */*notnull*/ command,
+                                  size_t origin_x,
+                                  size_t origin_y);
+
+void sp_cmd_fade_out_free(ClearCommand */*notnull*/ command);
+
 /**
  * A yet-to-be-tested command.
  *
- * Returns: a new [servicepoint::Command::FadeOut] instance.
+ * Returns: a new [FadeOutCommand] instance.
  */
-TypedCommand */*notnull*/ sp_command_fade_out(void);
+FadeOutCommand */*notnull*/ sp_cmd_fade_out_new(void);
 
 /**
- * Deallocates a [TypedCommand].
+ * Clones a [SPCommand] instance.
+ *
+ * returns: new [SPCommand] instance.
+ */
+SPCommand sp_cmd_generic_clone(SPCommand command);
+
+/**
+ * Deallocates a [SPCommand].
  *
  * # Examples
  *
@@ -1011,37 +1367,31 @@ TypedCommand */*notnull*/ sp_command_fade_out(void);
  * sp_command_free(c);
  * ```
  */
-void sp_command_free(TypedCommand */*notnull*/ command);
+void sp_cmd_generic_free(SPCommand command);
 
 /**
- * Set the brightness of all tiles to the same value.
+ * Turns a [TypedCommand] into a [Packet].
+ * The [TypedCommand] gets consumed.
  *
- * Returns: a new [servicepoint::Command::Brightness] instance.
+ * Returns NULL in case of an error.
  */
-TypedCommand */*notnull*/ sp_command_global_brightness(Brightness brightness);
+Packet *sp_cmd_generic_into_packet(SPCommand command);
+
+void sp_cmd_hard_reset_free(ClearCommand */*notnull*/ command);
 
 /**
  * Kills the udp daemon on the display, which usually results in a restart.
  *
  * Please do not send this in your normal program flow.
  *
- * Returns: a new [servicepoint::Command::HardReset] instance.
+ * Returns: a new [HardResetCommand] instance.
  */
-TypedCommand */*notnull*/ sp_command_hard_reset(void);
+HardResetCommand */*notnull*/ sp_cmd_hard_reset_new(void);
-
-/**
- * Tries to turn a [Packet] into a [TypedCommand].
- *
- * The packet is deallocated in the process.
- *
- * Returns: pointer to new [TypedCommand] instance or NULL if parsing failed.
- */
-TypedCommand *sp_command_try_from_packet(Packet */*notnull*/ packet);
 
 /**
  * Clones a [Cp437Grid].
  */
-Cp437Grid */*notnull*/ sp_cp437_grid_clone(Cp437Grid */*notnull*/ cp437_grid);
+Cp437Grid */*notnull*/ sp_cp437_grid_clone(Cp437Grid */*notnull*/ grid);
 
 /**
  * Sets the value of all cells in the [Cp437Grid].
@@ -1152,14 +1502,6 @@ Packet */*notnull*/ sp_packet_clone(Packet */*notnull*/ packet);
  */
 void sp_packet_free(Packet */*notnull*/ packet);
 
-/**
- * Turns a [TypedCommand] into a [Packet].
- * The [TypedCommand] gets consumed.
- *
- * Returns NULL in case of an error.
- */
-Packet *sp_packet_from_command(TypedCommand */*notnull*/ command);
-
 /**
  * Creates a raw [Packet] from parts.
  *
@@ -1214,19 +1556,19 @@ bool sp_u16_to_command_code(uint16_t code,
                             CommandCode *result);
 
 /**
- * Closes and deallocates a [UdpConnection].
+ * Closes and deallocates a [UdpSocket].
  */
 void sp_udp_free(UdpSocket */*notnull*/ connection);
 
 /**
- * Creates a new instance of [UdpConnection].
+ * Creates a new instance of [UdpSocket].
  *
  * returns: NULL if connection fails, or connected instance
  *
  * # Examples
  *
  * ```C
- * UdpConnection connection = sp_udp_open("172.23.42.29:2342");
+ * UdpSocket connection = sp_udp_open("172.23.42.29:2342");
  * if (connection != NULL)
  *     sp_udp_send_command(connection, sp_command_clear());
  * ```
@@ -1234,14 +1576,14 @@ void sp_udp_free(UdpSocket */*notnull*/ connection);
 UdpSocket *sp_udp_open(char */*notnull*/ host);
 
 /**
- * Creates a new instance of [UdpConnection].
+ * Creates a new instance of [UdpSocket].
  *
  * returns: NULL if connection fails, or connected instance
  *
  * # Examples
  *
  * ```C
- * UdpConnection connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
+ * UdpSocket connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
  * if (connection != NULL)
  *     sp_udp_send_command(connection, sp_command_clear());
  * ```
@@ -1253,7 +1595,7 @@ UdpSocket *sp_udp_open_ipv4(uint8_t ip1,
                             uint16_t port);
 
 /**
- * Sends a [TypedCommand] to the display using the [UdpConnection].
+ * Sends a [TypedCommand] to the display using the [UdpSocket].
  *
  * The passed `command` gets consumed.
  *
@@ -1265,11 +1607,10 @@ UdpSocket *sp_udp_open_ipv4(uint8_t ip1,
  * sp_udp_send_command(connection, sp_command_brightness(5));
  * ```
  */
-bool sp_udp_send_command(UdpSocket */*notnull*/ connection,
+bool sp_udp_send_command(UdpSocket */*notnull*/ connection, SPCommand command);
-                         TypedCommand */*notnull*/ command);
 
 /**
- * Sends a [Header] to the display using the [UdpConnection].
+ * Sends a [Header] to the display using the [UdpSocket].
  *
  * returns: true in case of success
  *
@@ -1282,7 +1623,7 @@ bool sp_udp_send_command(UdpSocket */*notnull*/ connection,
 bool sp_udp_send_header(UdpSocket */*notnull*/ udp_connection, Header header);
 
 /**
- * Sends a [Packet] to the display using the [UdpConnection].
+ * Sends a [Packet] to the display using the [UdpSocket].
  *
  * The passed `packet` gets consumed.
  *

src/bitmap.rs

@@ -1,5 +1,7 @@
-use crate::byte_slice::ByteSlice;
+use crate::{
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, SPBitVec};
+    bitvec::SPBitVec, byte_slice::ByteSlice, heap_clone, heap_drop,
+    heap_move_nonnull, heap_move_ok, heap_move_some, heap_remove,
+};
 use servicepoint::{
     Bitmap, BitmapCommand, CompressionCode, DataRef, Grid, Origin, Packet,
 };
@@ -33,11 +35,7 @@ pub unsafe extern "C" fn sp_bitmap_new(
     width: usize,
     height: usize,
 ) -> *mut Bitmap {
-    if let Some(bitmap) = Bitmap::new(width, height) {
+    heap_move_some(Bitmap::new(width, height))
-        heap_move(bitmap)
-    } else {
-        std::ptr::null_mut()
-    }
 }
 
 /// Creates a new [Bitmap] with a size matching the screen.
@@ -63,11 +61,7 @@ pub unsafe extern "C" fn sp_bitmap_load(
     data: ByteSlice,
 ) -> *mut Bitmap {
     let data = unsafe { data.as_slice() };
-    if let Ok(bitmap) = Bitmap::load(width, height, data) {
+    heap_move_ok(Bitmap::load(width, height, data))
-        heap_move(bitmap)
-    } else {
-        std::ptr::null_mut()
-    }
 }
 
 /// Tries to convert the BitVec to a Bitmap.
@@ -81,11 +75,7 @@ pub unsafe extern "C" fn sp_bitmap_from_bitvec(
     bitvec: NonNull<SPBitVec>,
 ) -> *mut Bitmap {
     let bitvec = unsafe { heap_remove(bitvec) };
-    if let Ok(bitmap) = Bitmap::from_bitvec(width, bitvec.0) {
+    heap_move_ok(Bitmap::from_bitvec(width, bitvec.0))
-        heap_move(bitmap)
-    } else {
-        std::ptr::null_mut()
-    }
 }
 
 /// Clones a [Bitmap].
@@ -93,7 +83,7 @@ pub unsafe extern "C" fn sp_bitmap_from_bitvec(
 pub unsafe extern "C" fn sp_bitmap_clone(
     bitmap: NonNull<Bitmap>,
 ) -> NonNull<Bitmap> {
-    heap_move_nonnull(unsafe { bitmap.as_ref().clone() })
+    unsafe { heap_clone(bitmap) }
 }
 
 /// Deallocates a [Bitmap].
@@ -215,12 +205,9 @@ pub unsafe extern "C" fn sp_bitmap_into_packet(
     compression: CompressionCode,
 ) -> *mut Packet {
     let bitmap = unsafe { heap_remove(bitmap) };
-    match Packet::try_from(BitmapCommand {
+    heap_move_ok(Packet::try_from(BitmapCommand {
         bitmap,
         origin: Origin::new(x, y),
         compression,
-    }) {
+    }))
-        Ok(packet) => heap_move(packet),
-        Err(_) => std::ptr::null_mut(),
-    }
 }

src/bitvec.rs

@@ -1,4 +1,7 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
+use crate::{
+    byte_slice::ByteSlice, heap_clone, heap_drop, heap_move_nonnull,
+    heap_move_ok, heap_remove,
+};
 use servicepoint::{
     BinaryOperation, BitVecCommand, CompressionCode, DisplayBitVec, Packet,
 };
@@ -50,7 +53,7 @@ pub unsafe extern "C" fn sp_bitvec_load(data: ByteSlice) -> NonNull<SPBitVec> {
 pub unsafe extern "C" fn sp_bitvec_clone(
     bit_vec: NonNull<SPBitVec>,
 ) -> NonNull<SPBitVec> {
-    heap_move_nonnull(unsafe { bit_vec.as_ref().clone() })
+    unsafe { heap_clone(bit_vec) }
 }
 
 /// Deallocates a [SPBitVec].
@@ -162,13 +165,10 @@ pub unsafe extern "C" fn sp_bitvec_into_packet(
     compression: CompressionCode,
 ) -> *mut Packet {
     let bitvec = unsafe { heap_remove(bitvec) }.0;
-    match Packet::try_from(BitVecCommand {
+    heap_move_ok(Packet::try_from(BitVecCommand {
         bitvec,
         offset,
         operation,
         compression,
-    }) {
+    }))
-        Ok(packet) => heap_move(packet),
-        Err(_) => std::ptr::null_mut(),
-    }
 }

src/brightness_grid.rs

@@ -1,4 +1,7 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
+use crate::{
+    byte_slice::ByteSlice, heap_clone, heap_drop, heap_move_nonnull,
+    heap_move_ok, heap_move_some, heap_remove,
+};
 use servicepoint::{
     Brightness, BrightnessGrid, BrightnessGridCommand, ByteGrid, DataRef, Grid,
     Origin, Packet,
@@ -12,15 +15,15 @@ use std::ptr::NonNull;
 ///
 /// # Examples
 /// ```C
-/// UdpConnection connection = sp_udp_open("127.0.0.1:2342");
+/// UdpSocket *connection = sp_udp_open("127.0.0.1:2342");
 /// if (connection == NULL)
 ///     return 1;
 ///
-/// BrightnessGrid grid = sp_brightness_grid_new(2, 2);
+/// 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);
+/// TypedCommand *command = sp_command_char_brightness(grid);
 /// sp_udp_free(connection);
 /// ```
 #[no_mangle]
@@ -43,21 +46,18 @@ pub unsafe extern "C" fn sp_brightness_grid_load(
     data: ByteSlice,
 ) -> *mut BrightnessGrid {
     let data = unsafe { data.as_slice() };
-
+    heap_move_some(
-    match ByteGrid::load(width, height, data)
+        ByteGrid::load(width, height, data)
-        .map(move |grid| grid.map(Brightness::saturating_from))
+            .map(move |grid| grid.map(Brightness::saturating_from)),
-    {
+    )
-        None => std::ptr::null_mut(),
-        Some(grid) => heap_move(grid),
-    }
 }
 
 /// Clones a [BrightnessGrid].
 #[no_mangle]
 pub unsafe extern "C" fn sp_brightness_grid_clone(
-    brightness_grid: NonNull<BrightnessGrid>,
+    grid: NonNull<BrightnessGrid>,
 ) -> NonNull<BrightnessGrid> {
-    heap_move_nonnull(unsafe { brightness_grid.as_ref().clone() })
+    unsafe { heap_clone(grid) }
 }
 
 /// Deallocates a [BrightnessGrid].
@@ -187,11 +187,8 @@ pub unsafe extern "C" fn sp_brightness_grid_into_packet(
     y: usize,
 ) -> *mut Packet {
     let grid = unsafe { heap_remove(grid) };
-    match Packet::try_from(BrightnessGridCommand {
+    heap_move_ok(Packet::try_from(BrightnessGridCommand {
         grid,
         origin: Origin::new(x, y),
-    }) {
+    }))
-        Ok(packet) => heap_move(packet),
-        Err(_) => std::ptr::null_mut(),
-    }
 }

src/char_grid.rs

@@ -1,4 +1,7 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
+use crate::{
+    byte_slice::ByteSlice, heap_clone, heap_drop, heap_move_nonnull,
+    heap_move_ok, heap_remove,
+};
 use servicepoint::{CharGrid, CharGridCommand, Grid, Origin, Packet};
 use std::ptr::NonNull;
 
@@ -32,19 +35,15 @@ pub unsafe extern "C" fn sp_char_grid_load(
     data: ByteSlice,
 ) -> *mut CharGrid {
     let data = unsafe { data.as_slice() };
-    if let Ok(grid) = CharGrid::load_utf8(width, height, data.to_vec()) {
+    heap_move_ok(CharGrid::load_utf8(width, height, data.to_vec()))
-        heap_move(grid)
-    } else {
-        std::ptr::null_mut()
-    }
 }
 
 /// Clones a [CharGrid].
 #[no_mangle]
 pub unsafe extern "C" fn sp_char_grid_clone(
-    char_grid: NonNull<CharGrid>,
+    grid: NonNull<CharGrid>,
 ) -> NonNull<CharGrid> {
-    heap_move_nonnull(unsafe { char_grid.as_ref().clone() })
+    unsafe { heap_clone(grid) }
 }
 
 /// Deallocates a [CharGrid].
@@ -145,11 +144,8 @@ pub unsafe extern "C" fn sp_char_grid_into_packet(
     y: usize,
 ) -> *mut Packet {
     let grid = unsafe { heap_remove(grid) };
-    match Packet::try_from(CharGridCommand {
+    heap_move_ok(Packet::try_from(CharGridCommand {
         grid,
         origin: Origin::new(x, y),
-    }) {
+    }))
-        Ok(packet) => heap_move(packet),
-        Err(_) => std::ptr::null_mut(),
-    }
 }

src/commands/bitmap_command.rs

@@ -0,0 +1,119 @@
+use crate::{
+    heap_clone, heap_drop, 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.
+///
+/// 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],
+/// leaving other fields as their default values.
+///
+/// Rust equivalent: [`<BitmapCommand as From<Bitmap>>::from`]
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_from_bitmap(
+    bitmap: NonNull<Bitmap>,
+) -> NonNull<BitmapCommand> {
+    heap_move_nonnull(unsafe { heap_remove(bitmap) }.into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_into_packet(
+    command: NonNull<BitmapCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_clone(
+    command: NonNull<BitmapCommand>,
+) -> NonNull<BitmapCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_free(command: NonNull<BitmapCommand>) {
+    unsafe { heap_drop(command) }
+}
+
+/// Returns a pointer to the provided `BitmapCommand`.
+///
+/// # Safety
+///
+/// - The returned bitmap inherits the lifetime of the command in which it is contained.
+/// - The returned pointer may not be used in a function that consumes the instance, e.g. to create a command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_get(
+    mut command: NonNull<BitmapCommand>,
+) -> NonNull<Bitmap> {
+    unsafe { NonNull::from(&mut (command.as_mut().bitmap)) }
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_set(
+    mut command: NonNull<BitmapCommand>,
+    bitmap: NonNull<Bitmap>,
+) {
+    unsafe {
+        command.as_mut().bitmap = heap_remove(bitmap);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_get_origin(
+    command: NonNull<BitmapCommand>,
+    origin_x: NonNull<usize>,
+    origin_y: NonNull<usize>,
+) {
+    unsafe {
+        let origin = &command.as_ref().origin;
+        *origin_x.as_ptr() = origin.x;
+        *origin_y.as_ptr() = origin.y;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_set_origin(
+    mut command: NonNull<BitmapCommand>,
+    origin_x: usize,
+    origin_y: usize,
+) {
+    unsafe {
+        command.as_mut().origin = Origin::new(origin_x, origin_y);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_set_compression(
+    mut command: NonNull<BitmapCommand>,
+    compression: CompressionCode,
+) {
+    unsafe {
+        command.as_mut().compression = compression;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitmap_get_compression(
+    command: NonNull<BitmapCommand>,
+) -> CompressionCode {
+    unsafe { command.as_ref().compression }
+}

src/commands/bitvec_command.rs

@@ -0,0 +1,123 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{
+    BinaryOperation, BitVecCommand, CompressionCode, DisplayBitVec, Offset,
+    Packet,
+};
+use std::ptr::NonNull;
+
+/// Set pixel data starting at the pixel offset on screen.
+///
+/// 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,
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_into_packet(
+    command: NonNull<BitVecCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_clone(
+    command: NonNull<BitVecCommand>,
+) -> NonNull<BitVecCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_free(command: NonNull<BitVecCommand>) {
+    unsafe { heap_drop(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_get(
+    mut command: NonNull<BitVecCommand>,
+) -> *mut DisplayBitVec {
+    &mut unsafe { command.as_mut() }.bitvec
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_set(
+    mut command: NonNull<BitVecCommand>,
+    bitvec: NonNull<DisplayBitVec>,
+) {
+    unsafe {
+        command.as_mut().bitvec = heap_remove(bitvec);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_get_offset(
+    command: NonNull<BitVecCommand>,
+) -> Offset {
+    unsafe { command.as_ref().offset }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_set_offset(
+    mut command: NonNull<BitVecCommand>,
+    offset: Offset,
+) {
+    unsafe {
+        command.as_mut().offset = offset;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_get_operation(
+    command: NonNull<BitVecCommand>,
+) -> BinaryOperation {
+    unsafe { command.as_ref().operation.clone() } // TODO remove clone
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_set_operation(
+    mut command: NonNull<BitVecCommand>,
+    operation: BinaryOperation,
+) {
+    unsafe {
+        command.as_mut().operation = operation;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_set_compression(
+    mut command: NonNull<BitVecCommand>,
+    compression: CompressionCode,
+) {
+    unsafe {
+        command.as_mut().compression = compression;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_bitvec_get_compression(
+    command: NonNull<BitVecCommand>,
+) -> CompressionCode {
+    unsafe { command.as_ref().compression }
+}

src/commands/brightness_grid_command.rs

@@ -0,0 +1,89 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{
+    BitmapCommand, BrightnessGrid, BrightnessGridCommand, Origin, Packet,
+};
+use std::ptr::NonNull;
+
+#[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),
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_from_grid(
+    grid: NonNull<BrightnessGrid>,
+) -> NonNull<BrightnessGridCommand> {
+    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_into_packet(
+    command: NonNull<BrightnessGridCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_clone(
+    command: NonNull<BrightnessGridCommand>,
+) -> NonNull<BrightnessGridCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_free(
+    command: NonNull<BitmapCommand>,
+) {
+    unsafe { heap_drop(command) }
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_set(
+    mut command: NonNull<BrightnessGridCommand>,
+    grid: NonNull<BrightnessGrid>,
+) {
+    unsafe {
+        command.as_mut().grid = heap_remove(grid);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_get(
+    mut command: NonNull<BrightnessGridCommand>,
+) -> *mut BrightnessGrid {
+    &mut unsafe { command.as_mut() }.grid
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_get_origin(
+    command: NonNull<BrightnessGridCommand>,
+    origin_x: NonNull<usize>,
+    origin_y: NonNull<usize>,
+) {
+    unsafe {
+        let origin = &command.as_ref().origin;
+        *origin_x.as_ptr() = origin.x;
+        *origin_y.as_ptr() = origin.y;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_grid_set_origin(
+    mut command: NonNull<BrightnessGridCommand>,
+    origin_x: usize,
+    origin_y: usize,
+) {
+    unsafe {
+        command.as_mut().origin = Origin::new(origin_x, origin_y);
+    }
+}

src/commands/cc_only_commands.rs

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

src/commands/char_grid_command.rs

@@ -0,0 +1,87 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{BitmapCommand, CharGrid, CharGridCommand, Origin, Packet};
+use std::ptr::NonNull;
+
+#[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),
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_from_grid(
+    grid: NonNull<CharGrid>,
+) -> NonNull<CharGridCommand> {
+    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_into_packet(
+    command: NonNull<CharGridCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_clone(
+    command: NonNull<CharGridCommand>,
+) -> NonNull<CharGridCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_free(
+    command: NonNull<BitmapCommand>,
+) {
+    unsafe { heap_drop(command) }
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_set(
+    mut command: NonNull<CharGridCommand>,
+    grid: NonNull<CharGrid>,
+) {
+    unsafe {
+        command.as_mut().grid = heap_remove(grid);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_get(
+    mut command: NonNull<CharGridCommand>,
+) -> *mut CharGrid {
+    &mut unsafe { command.as_mut() }.grid
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_get_origin(
+    command: NonNull<CharGridCommand>,
+    origin_x: NonNull<usize>,
+    origin_y: NonNull<usize>,
+) {
+    unsafe {
+        let origin = &command.as_ref().origin;
+        *origin_x.as_ptr() = origin.x;
+        *origin_y.as_ptr() = origin.y;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_char_grid_set_origin(
+    mut command: NonNull<CharGridCommand>,
+    origin_x: usize,
+    origin_y: usize,
+) {
+    unsafe {
+        command.as_mut().origin = Origin::new(origin_x, origin_y);
+    }
+}

src/commands/cp437_grid_command.rs

@@ -0,0 +1,89 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{
+    BitmapCommand, Cp437Grid, Cp437GridCommand, Origin, Packet,
+};
+use std::ptr::NonNull;
+
+#[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),
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_from_grid(
+    grid: NonNull<Cp437Grid>,
+) -> NonNull<Cp437GridCommand> {
+    heap_move_nonnull(unsafe { heap_remove(grid) }.into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_into_packet(
+    command: NonNull<Cp437GridCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_clone(
+    command: NonNull<Cp437GridCommand>,
+) -> NonNull<Cp437GridCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_free(
+    command: NonNull<BitmapCommand>,
+) {
+    unsafe { heap_drop(command) }
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_set(
+    mut command: NonNull<Cp437GridCommand>,
+    grid: NonNull<Cp437Grid>,
+) {
+    unsafe {
+        command.as_mut().grid = heap_remove(grid);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_get(
+    mut command: NonNull<Cp437GridCommand>,
+) -> *mut Cp437Grid {
+    &mut unsafe { command.as_mut() }.grid
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_get_origin(
+    command: NonNull<Cp437GridCommand>,
+    origin_x: NonNull<usize>,
+    origin_y: NonNull<usize>,
+) {
+    unsafe {
+        let origin = &command.as_ref().origin;
+        *origin_x.as_ptr() = origin.x;
+        *origin_y.as_ptr() = origin.y;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_cp437_grid_set_origin(
+    mut command: NonNull<Cp437GridCommand>,
+    origin_x: usize,
+    origin_y: usize,
+) {
+    unsafe {
+        command.as_mut().origin = Origin::new(origin_x, origin_y);
+    }
+}

src/commands/generic_command.rs

@@ -0,0 +1,281 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{
+    BitVecCommand, BitmapCommand, BitmapLegacyCommand, BrightnessGridCommand,
+    CharGridCommand, ClearCommand, Cp437GridCommand, FadeOutCommand,
+    GlobalBrightnessCommand, HardResetCommand, Packet, TypedCommand,
+};
+use std::ptr::{null_mut, NonNull};
+
+#[repr(C)]
+pub union CommandUnion {
+    pub null: *mut u8,
+    pub bitmap: NonNull<BitmapCommand>,
+    pub bitvec: NonNull<BitVecCommand>,
+    pub brightness_grid: NonNull<BrightnessGridCommand>,
+    pub char_grid: NonNull<CharGridCommand>,
+    pub cp437_grid: NonNull<Cp437GridCommand>,
+    pub global_brightness: NonNull<GlobalBrightnessCommand>,
+    pub clear: NonNull<ClearCommand>,
+    #[allow(deprecated)]
+    pub bitmap_legacy: NonNull<BitmapLegacyCommand>,
+    pub hard_reset: NonNull<HardResetCommand>,
+    pub fade_out: NonNull<FadeOutCommand>,
+}
+
+#[repr(u8)]
+pub enum CommandTag {
+    Invalid = 0,
+    Bitmap,
+    BitVec,
+    BrightnessGrid,
+    CharGrid,
+    Cp437Grid,
+    GlobalBrightness,
+    Clear,
+    HardReset,
+    FadeOut,
+    BitmapLegacy,
+}
+
+#[repr(C)]
+pub struct SPCommand {
+    /// Specifies which kind of command struct is contained in `data`
+    pub tag: CommandTag,
+    /// The pointer to the command struct
+    pub data: CommandUnion,
+}
+
+impl SPCommand {
+    const INVALID: SPCommand = SPCommand {
+        tag: CommandTag::Invalid,
+        data: CommandUnion { null: null_mut() },
+    };
+}
+
+/// Tries to turn a [Packet] into a [TypedCommand].
+///
+/// The packet is deallocated in the process.
+///
+/// Returns: pointer to new [TypedCommand] instance or NULL if parsing failed.
+/// #[no_mangle]
+pub unsafe extern "C" fn sp_cmd_generic_try_from_packet(
+    packet: NonNull<Packet>,
+) -> *mut SPCommand {
+    let packet = *unsafe { Box::from_raw(packet.as_ptr()) };
+    heap_move_ok(servicepoint::TypedCommand::try_from(packet).map(|value| {
+        match value {
+            TypedCommand::Clear(clear) => SPCommand {
+                tag: CommandTag::Clear,
+                data: CommandUnion {
+                    clear: heap_move_nonnull(clear),
+                },
+            },
+            TypedCommand::CharGrid(char_grid) => SPCommand {
+                tag: CommandTag::CharGrid,
+                data: CommandUnion {
+                    char_grid: heap_move_nonnull(char_grid),
+                },
+            },
+            TypedCommand::Cp437Grid(cp437_grid) => SPCommand {
+                tag: CommandTag::Cp437Grid,
+                data: CommandUnion {
+                    cp437_grid: heap_move_nonnull(cp437_grid),
+                },
+            },
+            TypedCommand::Bitmap(bitmap) => SPCommand {
+                tag: CommandTag::Bitmap,
+                data: CommandUnion {
+                    bitmap: heap_move_nonnull(bitmap),
+                },
+            },
+            TypedCommand::Brightness(global_brightness) => SPCommand {
+                tag: CommandTag::GlobalBrightness,
+                data: CommandUnion {
+                    global_brightness: heap_move_nonnull(global_brightness),
+                },
+            },
+            TypedCommand::BrightnessGrid(brightness_grid) => SPCommand {
+                tag: CommandTag::BrightnessGrid,
+                data: CommandUnion {
+                    brightness_grid: heap_move_nonnull(brightness_grid),
+                },
+            },
+            TypedCommand::BitVec(bitvec) => SPCommand {
+                tag: CommandTag::BitVec,
+                data: CommandUnion {
+                    bitvec: heap_move_nonnull(bitvec),
+                },
+            },
+            TypedCommand::HardReset(hard_reset) => SPCommand {
+                tag: CommandTag::HardReset,
+                data: CommandUnion {
+                    hard_reset: heap_move_nonnull(hard_reset),
+                },
+            },
+            TypedCommand::FadeOut(fade_out) => SPCommand {
+                tag: CommandTag::FadeOut,
+                data: CommandUnion {
+                    fade_out: heap_move_nonnull(fade_out),
+                },
+            },
+            #[allow(deprecated)]
+            TypedCommand::BitmapLegacy(bitmap_legacy) => SPCommand {
+                tag: CommandTag::BitmapLegacy,
+                data: CommandUnion {
+                    bitmap_legacy: heap_move_nonnull(bitmap_legacy),
+                },
+            },
+        }
+    }))
+}
+
+/// Clones a [SPCommand] instance.
+///
+/// returns: new [SPCommand] instance.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_generic_clone(command: SPCommand) -> SPCommand {
+    unsafe {
+        match command.tag {
+            CommandTag::Clear => SPCommand {
+                tag: CommandTag::Clear,
+                data: CommandUnion {
+                    clear: heap_clone(command.data.clear),
+                },
+            },
+            CommandTag::CharGrid => SPCommand {
+                tag: CommandTag::CharGrid,
+                data: CommandUnion {
+                    char_grid: heap_clone(command.data.char_grid),
+                },
+            },
+            CommandTag::Cp437Grid => SPCommand {
+                tag: CommandTag::Cp437Grid,
+                data: CommandUnion {
+                    cp437_grid: heap_clone(command.data.cp437_grid),
+                },
+            },
+            CommandTag::Bitmap => SPCommand {
+                tag: CommandTag::Bitmap,
+                data: CommandUnion {
+                    bitmap: heap_clone(command.data.bitmap),
+                },
+            },
+            CommandTag::GlobalBrightness => SPCommand {
+                tag: CommandTag::GlobalBrightness,
+                data: CommandUnion {
+                    global_brightness: heap_clone(
+                        command.data.global_brightness,
+                    ),
+                },
+            },
+            CommandTag::BrightnessGrid => SPCommand {
+                tag: CommandTag::BrightnessGrid,
+                data: CommandUnion {
+                    brightness_grid: heap_clone(command.data.brightness_grid),
+                },
+            },
+            CommandTag::BitVec => SPCommand {
+                tag: CommandTag::BitVec,
+                data: CommandUnion {
+                    bitvec: heap_clone(command.data.bitvec),
+                },
+            },
+            CommandTag::HardReset => SPCommand {
+                tag: CommandTag::HardReset,
+                data: CommandUnion {
+                    hard_reset: heap_clone(command.data.hard_reset),
+                },
+            },
+            CommandTag::FadeOut => SPCommand {
+                tag: CommandTag::FadeOut,
+                data: CommandUnion {
+                    fade_out: heap_clone(command.data.fade_out),
+                },
+            },
+            #[allow(deprecated)]
+            CommandTag::BitmapLegacy => SPCommand {
+                tag: CommandTag::BitmapLegacy,
+                data: CommandUnion {
+                    bitmap_legacy: heap_clone(command.data.bitmap_legacy),
+                },
+            },
+            CommandTag::Invalid => SPCommand::INVALID,
+        }
+    }
+}
+
+/// Deallocates a [SPCommand].
+///
+/// # Examples
+///
+/// ```C
+/// TypedCommand c = sp_command_clear();
+/// sp_command_free(c);
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_generic_free(command: SPCommand) {
+    unsafe {
+        match command.tag {
+            CommandTag::Invalid => return,
+            CommandTag::Bitmap => heap_drop(command.data.bitmap),
+            CommandTag::BitVec => heap_drop(command.data.bitvec),
+            CommandTag::BrightnessGrid => {
+                heap_drop(command.data.brightness_grid)
+            }
+            CommandTag::CharGrid => heap_drop(command.data.char_grid),
+            CommandTag::Cp437Grid => heap_drop(command.data.cp437_grid),
+            CommandTag::GlobalBrightness => {
+                heap_drop(command.data.global_brightness)
+            }
+            CommandTag::Clear => heap_drop(command.data.clear),
+            CommandTag::HardReset => heap_drop(command.data.hard_reset),
+            CommandTag::FadeOut => heap_drop(command.data.fade_out),
+            CommandTag::BitmapLegacy => heap_drop(command.data.bitmap_legacy),
+        }
+    }
+}
+
+/// Turns a [TypedCommand] into a [Packet].
+/// The [TypedCommand] gets consumed.
+///
+/// Returns NULL in case of an error.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_generic_into_packet(
+    command: SPCommand,
+) -> *mut Packet {
+    match command.tag {
+        CommandTag::Invalid => null_mut(),
+        CommandTag::Bitmap => {
+            heap_move_ok(unsafe { heap_remove(command.data.bitmap).try_into() })
+        }
+        CommandTag::BitVec => {
+            heap_move_ok(unsafe { heap_remove(command.data.bitvec).try_into() })
+        }
+        CommandTag::BrightnessGrid => heap_move_ok(unsafe {
+            heap_remove(command.data.brightness_grid).try_into()
+        }),
+        CommandTag::CharGrid => heap_move_ok(unsafe {
+            heap_remove(command.data.char_grid).try_into()
+        }),
+        CommandTag::Cp437Grid => heap_move_ok(unsafe {
+            heap_remove(command.data.cp437_grid).try_into()
+        }),
+        CommandTag::GlobalBrightness => heap_move_ok(unsafe {
+            heap_remove(command.data.global_brightness).try_into()
+        }),
+        CommandTag::Clear => {
+            heap_move_ok(unsafe { heap_remove(command.data.clear).try_into() })
+        }
+        CommandTag::HardReset => heap_move_ok(unsafe {
+            heap_remove(command.data.hard_reset).try_into()
+        }),
+        CommandTag::FadeOut => heap_move_ok(unsafe {
+            heap_remove(command.data.fade_out).try_into()
+        }),
+        CommandTag::BitmapLegacy => heap_move_ok(unsafe {
+            heap_remove(command.data.bitmap_legacy).try_into()
+        }),
+    }
+}

src/commands/global_brightness_command.rs

@@ -0,0 +1,53 @@
+use crate::{
+    heap_clone, heap_drop, heap_move_nonnull, heap_move_ok, heap_remove,
+};
+use servicepoint::{
+    BitmapCommand, Brightness, GlobalBrightnessCommand, Packet,
+};
+use std::ptr::NonNull;
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_new(
+    brightness: Brightness,
+) -> NonNull<GlobalBrightnessCommand> {
+    heap_move_nonnull(GlobalBrightnessCommand::from(brightness))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_into_packet(
+    command: NonNull<GlobalBrightnessCommand>,
+) -> *mut Packet {
+    heap_move_ok(unsafe { heap_remove(command) }.try_into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_clone(
+    command: NonNull<GlobalBrightnessCommand>,
+) -> NonNull<GlobalBrightnessCommand> {
+    unsafe { heap_clone(command) }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_free(
+    command: NonNull<BitmapCommand>,
+) {
+    unsafe { heap_drop(command) }
+}
+
+/// Moves the provided bitmap to be contained in the command.
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_set(
+    mut command: NonNull<GlobalBrightnessCommand>,
+    brightness: Brightness,
+) {
+    unsafe {
+        command.as_mut().brightness = brightness;
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn sp_cmd_brightness_global_get(
+    mut command: NonNull<GlobalBrightnessCommand>,
+) -> *mut Brightness {
+    &mut unsafe { command.as_mut() }.brightness
+}

src/commands/mod.rs

@@ -0,0 +1,15 @@
+mod bitmap_command;
+mod bitvec_command;
+mod brightness_grid_command;
+mod cc_only_commands;
+mod char_grid_command;
+mod cp437_grid_command;
+mod generic_command;
+mod global_brightness_command;
+
+pub use bitmap_command::*;
+pub use bitvec_command::*;
+pub use brightness_grid_command::*;
+pub use char_grid_command::*;
+pub use cp437_grid_command::*;
+pub use generic_command::*;

src/cp437_grid.rs

@@ -1,4 +1,7 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
+use crate::{
+    byte_slice::ByteSlice, heap_clone, heap_drop, heap_move_nonnull,
+    heap_move_ok, heap_move_some, heap_remove,
+};
 use servicepoint::{
     Cp437Grid, Cp437GridCommand, DataRef, Grid, Origin, Packet,
 };
@@ -23,20 +26,15 @@ pub unsafe extern "C" fn sp_cp437_grid_load(
     data: ByteSlice,
 ) -> *mut Cp437Grid {
     let data = unsafe { data.as_slice() };
-    let grid = Cp437Grid::load(width, height, data);
+    heap_move_some(Cp437Grid::load(width, height, data))
-    if let Some(grid) = grid {
-        heap_move(grid)
-    } else {
-        std::ptr::null_mut()
-    }
 }
 
 /// Clones a [Cp437Grid].
 #[no_mangle]
 pub unsafe extern "C" fn sp_cp437_grid_clone(
-    cp437_grid: NonNull<Cp437Grid>,
+    grid: NonNull<Cp437Grid>,
 ) -> NonNull<Cp437Grid> {
-    heap_move_nonnull(unsafe { cp437_grid.as_ref().clone() })
+    unsafe { heap_clone(grid) }
 }
 
 /// Deallocates a [Cp437Grid].
@@ -147,11 +145,8 @@ pub unsafe extern "C" fn sp_cp437_grid_into_packet(
     y: usize,
 ) -> *mut Packet {
     let grid = unsafe { heap_remove(grid) };
-    match Packet::try_from(Cp437GridCommand {
+    heap_move_ok(Packet::try_from(Cp437GridCommand {
         grid,
         origin: Origin::new(x, y),
-    }) {
+    }))
-        Ok(packet) => heap_move(packet),
-        Err(_) => std::ptr::null_mut(),
-    }
 }

src/lib.rs

@@ -9,7 +9,7 @@
 //! #include "servicepoint.h"
 //!
 //! int main(void) {
-//!     UdpConnection *connection = sp_udp_open("172.23.42.29:2342");
+//!     UdpSocket *connection = sp_udp_open("172.23.42.29:2342");
 //!     if (connection == NULL)
 //!         return 1;
 //!
@@ -25,27 +25,17 @@
 //! }
 //! ```
 
-pub use crate::bitmap::*;
-pub use crate::bitvec::*;
-pub use crate::brightness_grid::*;
-pub use crate::byte_slice::*;
-pub use crate::char_grid::*;
-pub use crate::cp437_grid::*;
-pub use crate::packet::*;
-pub use crate::typed_command::*;
-pub use crate::udp::*;
-pub use servicepoint::CommandCode;
 use std::ptr::NonNull;
 
-mod bitmap;
+pub mod bitmap;
-mod bitvec;
+pub mod bitvec;
-mod brightness_grid;
+pub mod brightness_grid;
-mod byte_slice;
+pub mod byte_slice;
-mod char_grid;
+pub mod char_grid;
-mod cp437_grid;
+pub mod commands;
-mod packet;
+pub mod cp437_grid;
-mod typed_command;
+pub mod packet;
-mod udp;
+pub mod udp;
 
 use std::time::Duration;
 
@@ -60,6 +50,14 @@ pub(crate) fn heap_move_nonnull<T>(x: T) -> NonNull<T> {
     NonNull::from(Box::leak(Box::new(x)))
 }
 
+pub(crate) fn heap_move_ok<T, E>(x: Result<T, E>) -> *mut T {
+    x.map(|x| heap_move(x)).unwrap_or(std::ptr::null_mut())
+}
+
+pub(crate) fn heap_move_some<T>(x: Option<T>) -> *mut T {
+    x.map(|x| heap_move(x)).unwrap_or(std::ptr::null_mut())
+}
+
 pub(crate) unsafe fn heap_drop<T>(x: NonNull<T>) {
     drop(unsafe { heap_remove(x) });
 }
@@ -68,5 +66,12 @@ pub(crate) unsafe fn heap_remove<T>(x: NonNull<T>) -> T {
     unsafe { *Box::from_raw(x.as_ptr()) }
 }
 
+unsafe fn heap_clone<T: Clone>(source: NonNull<T>) -> NonNull<T> {
+    heap_move_nonnull(unsafe { source.as_ref().clone() })
+}
+
 /// This is a type only used by cbindgen to have a type for pointers.
 pub struct UdpSocket;
+
+/// This is a type only used by cbindgen to have a type for pointers.
+pub struct DisplayBitVec;

src/packet.rs

@@ -1,33 +1,17 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, heap_remove, ByteSlice};
+use crate::{
-use servicepoint::{CommandCode, Header, Packet, TypedCommand};
+    byte_slice::ByteSlice, heap_clone, heap_drop, heap_move_nonnull,
+    heap_move_ok,
+};
+use servicepoint::{CommandCode, Header, Packet};
 use std::ptr::NonNull;
 
-/// Turns a [TypedCommand] into a [Packet].
-/// The [TypedCommand] gets consumed.
-///
-/// Returns NULL in case of an error.
-#[no_mangle]
-pub unsafe extern "C" fn sp_packet_from_command(
-    command: NonNull<TypedCommand>,
-) -> *mut Packet {
-    let command = unsafe { heap_remove(command) };
-    if let Ok(packet) = command.try_into() {
-        heap_move(packet)
-    } else {
-        std::ptr::null_mut()
-    }
-}
-
 /// Tries to load a [Packet] from the passed array with the specified length.
 ///
 /// returns: NULL in case of an error, pointer to the allocated packet otherwise
 #[no_mangle]
 pub unsafe extern "C" fn sp_packet_try_load(data: ByteSlice) -> *mut Packet {
     let data = unsafe { data.as_slice() };
-    match servicepoint::Packet::try_from(data) {
+    heap_move_ok(servicepoint::Packet::try_from(data))
-        Err(_) => std::ptr::null_mut(),
-        Ok(packet) => heap_move(packet),
-    }
 }
 
 /// Creates a raw [Packet] from parts.
@@ -99,7 +83,7 @@ pub unsafe extern "C" fn sp_packet_serialize_to(
 pub unsafe extern "C" fn sp_packet_clone(
     packet: NonNull<Packet>,
 ) -> NonNull<Packet> {
-    heap_move_nonnull(unsafe { packet.as_ref().clone() })
+    unsafe { heap_clone(packet) }
 }
 
 /// Deallocates a [Packet].

src/typed_command.rs

@@ -1,201 +0,0 @@
-use crate::{heap_drop, heap_move, heap_move_nonnull, SPBitVec};
-use servicepoint::{
-    BinaryOperation, Bitmap, Brightness, BrightnessGrid, CharGrid,
-    CompressionCode, Cp437Grid, GlobalBrightnessCommand, Packet, TypedCommand,
-};
-use std::ptr::NonNull;
-
-/// Tries to turn a [Packet] into a [TypedCommand].
-///
-/// The packet is deallocated in the process.
-///
-/// Returns: pointer to new [TypedCommand] instance or NULL if parsing failed.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_try_from_packet(
-    packet: NonNull<Packet>,
-) -> *mut TypedCommand {
-    let packet = *unsafe { Box::from_raw(packet.as_ptr()) };
-    match servicepoint::TypedCommand::try_from(packet) {
-        Err(_) => std::ptr::null_mut(),
-        Ok(command) => heap_move(command),
-    }
-}
-
-/// Clones a [TypedCommand] instance.
-///
-/// returns: new [TypedCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_clone(
-    command: NonNull<TypedCommand>,
-) -> NonNull<TypedCommand> {
-    heap_move_nonnull(unsafe { command.as_ref().clone() })
-}
-
-/// Set all pixels to the off state.
-///
-/// Does not affect brightness.
-///
-/// Returns: a new [servicepoint::Command::Clear] instance.
-///
-/// # Examples
-///
-/// ```C
-/// sp_udp_send_command(connection, sp_command_clear());
-/// ```
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_clear() -> NonNull<TypedCommand> {
-    heap_move_nonnull(servicepoint::ClearCommand.into())
-}
-
-/// Kills the udp daemon on the display, which usually results in a restart.
-///
-/// Please do not send this in your normal program flow.
-///
-/// Returns: a new [servicepoint::Command::HardReset] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_hard_reset() -> NonNull<TypedCommand> {
-    heap_move_nonnull(servicepoint::HardResetCommand.into())
-}
-
-/// A yet-to-be-tested command.
-///
-/// Returns: a new [servicepoint::Command::FadeOut] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_fade_out() -> NonNull<TypedCommand> {
-    heap_move_nonnull(servicepoint::FadeOutCommand.into())
-}
-
-/// Set the brightness of all tiles to the same value.
-///
-/// Returns: a new [servicepoint::Command::Brightness] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_global_brightness(
-    brightness: Brightness,
-) -> NonNull<TypedCommand> {
-    heap_move_nonnull(GlobalBrightnessCommand::from(brightness).into())
-}
-
-/// Set the brightness of individual tiles in a rectangular area of the display.
-///
-/// The passed [BrightnessGrid] gets consumed.
-///
-/// Returns: a new [servicepoint::Command::CharBrightness] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_brightness_grid(
-    x: usize,
-    y: usize,
-    grid: NonNull<BrightnessGrid>,
-) -> NonNull<TypedCommand> {
-    let grid = unsafe { *Box::from_raw(grid.as_ptr()) };
-    let result = servicepoint::BrightnessGridCommand {
-        origin: servicepoint::Origin::new(x, y),
-        grid,
-    }
-    .into();
-    heap_move_nonnull(result)
-}
-
-/// Set pixel data starting at the pixel offset on screen.
-///
-/// 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 [`BitVecU8Msb0`] is always uncompressed.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_bitvec(
-    offset: usize,
-    bit_vec: NonNull<SPBitVec>,
-    compression: CompressionCode,
-    operation: BinaryOperation,
-) -> *mut TypedCommand {
-    let bit_vec = unsafe { *Box::from_raw(bit_vec.as_ptr()) };
-    let command = servicepoint::BitVecCommand {
-        offset,
-        operation,
-        bitvec: bit_vec.0,
-        compression,
-    }
-    .into();
-    heap_move(command)
-}
-
-/// Show codepage 437 encoded text on the screen.
-///
-/// The passed [Cp437Grid] gets consumed.
-///
-/// Returns: a new [servicepoint::Cp437GridCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_cp437_grid(
-    x: usize,
-    y: usize,
-    grid: NonNull<Cp437Grid>,
-) -> NonNull<TypedCommand> {
-    let grid = *unsafe { Box::from_raw(grid.as_ptr()) };
-    let result = servicepoint::Cp437GridCommand {
-        origin: servicepoint::Origin::new(x, y),
-        grid,
-    }
-    .into();
-    heap_move_nonnull(result)
-}
-
-/// Show UTF-8 encoded text on the screen.
-///
-/// The passed [CharGrid] gets consumed.
-///
-/// Returns: a new [servicepoint::CharGridCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_char_grid(
-    x: usize,
-    y: usize,
-    grid: NonNull<CharGrid>,
-) -> NonNull<TypedCommand> {
-    let grid = unsafe { *Box::from_raw(grid.as_ptr()) };
-    let result = servicepoint::CharGridCommand {
-        origin: servicepoint::Origin::new(x, y),
-        grid,
-    }
-    .into();
-    heap_move_nonnull(result)
-}
-
-/// Sets a window of pixels to the specified values.
-///
-/// The passed [Bitmap] gets consumed.
-///
-/// Returns: a new [servicepoint::BitmapCommand] instance.
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_bitmap(
-    x: usize,
-    y: usize,
-    bitmap: NonNull<Bitmap>,
-    compression: CompressionCode,
-) -> *mut TypedCommand {
-    let bitmap = unsafe { *Box::from_raw(bitmap.as_ptr()) };
-    let command = servicepoint::BitmapCommand {
-        origin: servicepoint::Origin::new(x, y),
-        bitmap,
-        compression,
-    }
-    .into();
-    heap_move(command)
-}
-
-/// Deallocates a [TypedCommand].
-///
-/// # Examples
-///
-/// ```C
-/// TypedCommand c = sp_command_clear();
-/// sp_command_free(c);
-/// ```
-#[no_mangle]
-pub unsafe extern "C" fn sp_command_free(command: NonNull<TypedCommand>) {
-    unsafe { heap_drop(command) }
-}

src/udp.rs

@@ -1,17 +1,18 @@
-use crate::{heap_drop, heap_move, heap_remove};
+use crate::commands::{CommandTag, SPCommand};
-use servicepoint::{Header, Packet, TypedCommand, UdpSocketExt};
+use crate::{heap_drop, heap_move_ok, heap_remove};
+use servicepoint::{Header, Packet, UdpSocketExt};
 use std::ffi::{c_char, CStr};
 use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
 use std::ptr::NonNull;
 
-/// Creates a new instance of [UdpConnection].
+/// Creates a new instance of [UdpSocket].
 ///
 /// returns: NULL if connection fails, or connected instance
 ///
 /// # Examples
 ///
 /// ```C
-/// UdpConnection connection = sp_udp_open("172.23.42.29:2342");
+/// UdpSocket connection = sp_udp_open("172.23.42.29:2342");
 /// if (connection != NULL)
 ///     sp_udp_send_command(connection, sp_command_clear());
 /// ```
@@ -20,22 +21,18 @@ pub unsafe extern "C" fn sp_udp_open(host: NonNull<c_char>) -> *mut UdpSocket {
     let host = unsafe { CStr::from_ptr(host.as_ptr()) }
         .to_str()
         .expect("Bad encoding");
-    let connection = match UdpSocket::bind_connect(host) {
-        Err(_) => return std::ptr::null_mut(),
-        Ok(value) => value,
-    };
 
-    heap_move(connection)
+    heap_move_ok(UdpSocket::bind_connect(host))
 }
 
-/// Creates a new instance of [UdpConnection].
+/// Creates a new instance of [UdpSocket].
 ///
 /// returns: NULL if connection fails, or connected instance
 ///
 /// # Examples
 ///
 /// ```C
-/// UdpConnection connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
+/// UdpSocket connection = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
 /// if (connection != NULL)
 ///     sp_udp_send_command(connection, sp_command_clear());
 /// ```
@@ -48,14 +45,10 @@ pub unsafe extern "C" fn sp_udp_open_ipv4(
     port: u16,
 ) -> *mut UdpSocket {
     let addr = SocketAddrV4::new(Ipv4Addr::from([ip1, ip2, ip3, ip4]), port);
-    let connection = match UdpSocket::bind_connect(addr) {
+    heap_move_ok(UdpSocket::bind_connect(addr))
-        Err(_) => return std::ptr::null_mut(),
-        Ok(value) => value,
-    };
-    heap_move(connection)
 }
 
-/// Sends a [Packet] to the display using the [UdpConnection].
+/// Sends a [Packet] to the display using the [UdpSocket].
 ///
 /// The passed `packet` gets consumed.
 ///
@@ -69,7 +62,7 @@ pub unsafe extern "C" fn sp_udp_send_packet(
     unsafe { connection.as_ref().send(&Vec::from(packet)) }.is_ok()
 }
 
-/// Sends a [TypedCommand] to the display using the [UdpConnection].
+/// Sends a [TypedCommand] to the display using the [UdpSocket].
 ///
 /// The passed `command` gets consumed.
 ///
@@ -83,13 +76,47 @@ pub unsafe extern "C" fn sp_udp_send_packet(
 #[no_mangle]
 pub unsafe extern "C" fn sp_udp_send_command(
     connection: NonNull<UdpSocket>,
-    command: NonNull<TypedCommand>,
+    command: SPCommand,
 ) -> bool {
-    let command = unsafe { heap_remove(command) };
+    unsafe {
-    unsafe { connection.as_ref().send_command(command) }.is_some()
+        match command.tag {
+            CommandTag::Invalid => return false,
+            CommandTag::Bitmap => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.bitmap)),
+            CommandTag::BitVec => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.bitvec)),
+            CommandTag::BrightnessGrid => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.brightness_grid)),
+            CommandTag::CharGrid => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.char_grid)),
+            CommandTag::Cp437Grid => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.cp437_grid)),
+            CommandTag::GlobalBrightness => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.global_brightness)),
+            CommandTag::Clear => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.clear)),
+            CommandTag::HardReset => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.hard_reset)),
+            CommandTag::FadeOut => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.fade_out)),
+            CommandTag::BitmapLegacy => connection
+                .as_ref()
+                .send_command(heap_remove(command.data.bitmap_legacy)),
+        }
+    }
+    .is_some()
 }
 
-/// Sends a [Header] to the display using the [UdpConnection].
+/// Sends a [Header] to the display using the [UdpSocket].
 ///
 /// returns: true in case of success
 ///
@@ -112,7 +139,7 @@ pub unsafe extern "C" fn sp_udp_send_header(
         .is_ok()
 }
 
-/// Closes and deallocates a [UdpConnection].
+/// Closes and deallocates a [UdpSocket].
 #[no_mangle]
 pub unsafe extern "C" fn sp_udp_free(connection: NonNull<UdpSocket>) {
     unsafe { heap_drop(connection) }