split servicepoint_binding_uniffi into own crate

src/bin/uniffi-bindgen-cs.rs

@@ -0,0 +1,3 @@
+fn main() {
+    uniffi_bindgen_cs::main().unwrap();
+}

src/bin/uniffi-bindgen-go.rs

@@ -0,0 +1,3 @@
+fn main() {
+    uniffi_bindgen_go::main().unwrap();
+}

src/bin/uniffi-bindgen.rs

@@ -0,0 +1,3 @@
+fn main() {
+    uniffi::uniffi_bindgen_main()
+}

src/bitmap.rs

@@ -0,0 +1,77 @@
+use servicepoint::{DataRef, Grid};
+use std::sync::{Arc, RwLock};
+
+#[derive(uniffi::Object)]
+pub struct Bitmap {
+    pub(crate) actual: RwLock<servicepoint::Bitmap>,
+}
+
+impl Bitmap {
+    fn internal_new(actual: servicepoint::Bitmap) -> Arc<Self> {
+        Arc::new(Self {
+            actual: RwLock::new(actual),
+        })
+    }
+}
+
+#[uniffi::export]
+impl Bitmap {
+    #[uniffi::constructor]
+    pub fn new(width: u64, height: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::Bitmap::new(
+            width as usize,
+            height as usize,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn new_max_sized() -> Arc<Self> {
+        Self::internal_new(servicepoint::Bitmap::max_sized())
+    }
+
+    #[uniffi::constructor]
+    pub fn load(width: u64, height: u64, data: Vec<u8>) -> Arc<Self> {
+        Self::internal_new(servicepoint::Bitmap::load(
+            width as usize,
+            height as usize,
+            &data,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.read().unwrap().clone())
+    }
+
+    pub fn set(&self, x: u64, y: u64, value: bool) {
+        self.actual
+            .write()
+            .unwrap()
+            .set(x as usize, y as usize, value)
+    }
+
+    pub fn get(&self, x: u64, y: u64) -> bool {
+        self.actual.read().unwrap().get(x as usize, y as usize)
+    }
+
+    pub fn fill(&self, value: bool) {
+        self.actual.write().unwrap().fill(value)
+    }
+    pub fn width(&self) -> u64 {
+        self.actual.read().unwrap().width() as u64
+    }
+
+    pub fn height(&self) -> u64 {
+        self.actual.read().unwrap().height() as u64
+    }
+
+    pub fn equals(&self, other: &Bitmap) -> bool {
+        let a = self.actual.read().unwrap();
+        let b = other.actual.read().unwrap();
+        *a == *b
+    }
+
+    pub fn copy_raw(&self) -> Vec<u8> {
+        self.actual.read().unwrap().data_ref().to_vec()
+    }
+}

src/bitvec.rs

@@ -0,0 +1,61 @@
+use std::sync::{Arc, RwLock};
+
+#[derive(uniffi::Object)]
+pub struct BitVec {
+    pub(crate) actual: RwLock<servicepoint::BitVec>,
+}
+
+impl BitVec {
+    fn internal_new(actual: servicepoint::BitVec) -> Arc<Self> {
+        Arc::new(Self {
+            actual: RwLock::new(actual),
+        })
+    }
+}
+
+#[uniffi::export]
+impl BitVec {
+    #[uniffi::constructor]
+    pub fn new(size: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::BitVec::repeat(false, size as usize))
+    }
+    #[uniffi::constructor]
+    pub fn load(data: Vec<u8>) -> Arc<Self> {
+        Self::internal_new(servicepoint::BitVec::from_slice(&data))
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.read().unwrap().clone())
+    }
+
+    pub fn set(&self, index: u64, value: bool) {
+        self.actual.write().unwrap().set(index as usize, value)
+    }
+
+    pub fn get(&self, index: u64) -> bool {
+        self.actual
+            .read()
+            .unwrap()
+            .get(index as usize)
+            .is_some_and(move |bit| *bit)
+    }
+
+    pub fn fill(&self, value: bool) {
+        self.actual.write().unwrap().fill(value)
+    }
+
+    pub fn len(&self) -> u64 {
+        self.actual.read().unwrap().len() as u64
+    }
+
+    pub fn equals(&self, other: &BitVec) -> bool {
+        let a = self.actual.read().unwrap();
+        let b = other.actual.read().unwrap();
+        *a == *b
+    }
+
+    pub fn copy_raw(&self) -> Vec<u8> {
+        self.actual.read().unwrap().clone().into_vec()
+    }
+}

src/brightness_grid.rs

@@ -0,0 +1,86 @@
+use servicepoint::{Brightness, DataRef, Grid};
+use std::sync::{Arc, RwLock};
+
+#[derive(uniffi::Object)]
+pub struct BrightnessGrid {
+    pub(crate) actual: RwLock<servicepoint::BrightnessGrid>,
+}
+
+impl BrightnessGrid {
+    fn internal_new(actual: servicepoint::BrightnessGrid) -> Arc<Self> {
+        Arc::new(Self {
+            actual: RwLock::new(actual),
+        })
+    }
+}
+
+#[uniffi::export]
+impl BrightnessGrid {
+    #[uniffi::constructor]
+    pub fn new(width: u64, height: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::BrightnessGrid::new(
+            width as usize,
+            height as usize,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn load(width: u64, height: u64, data: Vec<u8>) -> Arc<Self> {
+        Self::internal_new(servicepoint::BrightnessGrid::saturating_load(
+            width as usize,
+            height as usize,
+            &data,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.read().unwrap().clone())
+    }
+
+    pub fn set(&self, x: u64, y: u64, value: u8) {
+        self.actual.write().unwrap().set(
+            x as usize,
+            y as usize,
+            Brightness::saturating_from(value),
+        )
+    }
+
+    pub fn get(&self, x: u64, y: u64) -> u8 {
+        self.actual
+            .read()
+            .unwrap()
+            .get(x as usize, y as usize)
+            .into()
+    }
+
+    pub fn fill(&self, value: u8) {
+        self.actual
+            .write()
+            .unwrap()
+            .fill(Brightness::saturating_from(value))
+    }
+    pub fn width(&self) -> u64 {
+        self.actual.read().unwrap().width() as u64
+    }
+
+    pub fn height(&self) -> u64 {
+        self.actual.read().unwrap().height() as u64
+    }
+
+    pub fn equals(&self, other: &BrightnessGrid) -> bool {
+        let a = self.actual.read().unwrap();
+        let b = other.actual.read().unwrap();
+        *a == *b
+    }
+
+    pub fn copy_raw(&self) -> Vec<u8> {
+        self.actual
+            .read()
+            .unwrap()
+            .data_ref()
+            .iter()
+            .map(u8::from)
+            .collect()
+    }
+}

src/char_grid.rs

@@ -0,0 +1,169 @@
+use crate::cp437_grid::Cp437Grid;
+use servicepoint::{Grid, SetValueSeriesError};
+use std::convert::Into;
+use std::sync::{Arc, RwLock};
+
+#[derive(uniffi::Object)]
+pub struct CharGrid {
+    pub(crate) actual: RwLock<servicepoint::CharGrid>,
+}
+
+#[derive(uniffi::Error, thiserror::Error, Debug)]
+pub enum CharGridError {
+    #[error("Exactly one character was expected, but {value:?} was provided")]
+    StringNotOneChar { value: String },
+    #[error("The provided series was expected to have a length of {expected}, but was {actual}")]
+    InvalidSeriesLength { actual: u64, expected: u64 },
+    #[error("The index {index} was out of bounds for size {size}")]
+    OutOfBounds { index: u64, size: u64 },
+}
+
+#[uniffi::export]
+impl CharGrid {
+    #[uniffi::constructor]
+    pub fn new(width: u64, height: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::CharGrid::new(
+            width as usize,
+            height as usize,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn load(data: String) -> Arc<Self> {
+        Self::internal_new(servicepoint::CharGrid::from(&*data))
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.read().unwrap().clone())
+    }
+
+    pub fn set(
+        &self,
+        x: u64,
+        y: u64,
+        value: String,
+    ) -> Result<(), CharGridError> {
+        let value = Self::str_to_char(value)?;
+        self.actual
+            .write()
+            .unwrap()
+            .set(x as usize, y as usize, value);
+        Ok(())
+    }
+
+    pub fn get(&self, x: u64, y: u64) -> String {
+        self.actual
+            .read()
+            .unwrap()
+            .get(x as usize, y as usize)
+            .into()
+    }
+
+    pub fn fill(&self, value: String) -> Result<(), CharGridError> {
+        let value = Self::str_to_char(value)?;
+        self.actual.write().unwrap().fill(value);
+        Ok(())
+    }
+
+    pub fn width(&self) -> u64 {
+        self.actual.read().unwrap().width() as u64
+    }
+
+    pub fn height(&self) -> u64 {
+        self.actual.read().unwrap().height() as u64
+    }
+
+    pub fn equals(&self, other: &CharGrid) -> bool {
+        let a = self.actual.read().unwrap();
+        let b = other.actual.read().unwrap();
+        *a == *b
+    }
+
+    pub fn as_string(&self) -> String {
+        let grid = self.actual.read().unwrap();
+        String::from(&*grid)
+    }
+
+    pub fn set_row(&self, y: u64, row: String) -> Result<(), CharGridError> {
+        self.actual
+            .write()
+            .unwrap()
+            .set_row(y as usize, &row.chars().collect::<Vec<_>>())
+            .map_err(CharGridError::from)
+    }
+
+    pub fn set_col(&self, x: u64, col: String) -> Result<(), CharGridError> {
+        self.actual
+            .write()
+            .unwrap()
+            .set_row(x as usize, &col.chars().collect::<Vec<_>>())
+            .map_err(CharGridError::from)
+    }
+
+    pub fn get_row(&self, y: u64) -> Result<String, CharGridError> {
+        self.actual
+            .read()
+            .unwrap()
+            .get_row(y as usize)
+            .map(String::from_iter)
+            .ok_or(CharGridError::OutOfBounds {
+                index: y,
+                size: self.height(),
+            })
+    }
+
+    pub fn get_col(&self, x: u64) -> Result<String, CharGridError> {
+        self.actual
+            .read()
+            .unwrap()
+            .get_col(x as usize)
+            .map(String::from_iter)
+            .ok_or(CharGridError::OutOfBounds {
+                index: x,
+                size: self.width(),
+            })
+    }
+
+    pub fn to_cp437(&self) -> Arc<Cp437Grid> {
+        Cp437Grid::internal_new(servicepoint::Cp437Grid::from(
+            &*self.actual.read().unwrap(),
+        ))
+    }
+}
+
+impl CharGrid {
+    pub(crate) fn internal_new(actual: servicepoint::CharGrid) -> Arc<Self> {
+        Arc::new(Self {
+            actual: RwLock::new(actual),
+        })
+    }
+
+    fn str_to_char(value: String) -> Result<char, CharGridError> {
+        if value.len() != 1 {
+            return Err(CharGridError::StringNotOneChar { value });
+        }
+
+        let value = value.chars().nth(0).unwrap();
+        Ok(value)
+    }
+}
+
+impl From<SetValueSeriesError> for CharGridError {
+    fn from(e: SetValueSeriesError) -> Self {
+        match e {
+            SetValueSeriesError::OutOfBounds { index, size } => {
+                CharGridError::OutOfBounds {
+                    index: index as u64,
+                    size: size as u64,
+                }
+            }
+            SetValueSeriesError::InvalidLength { actual, expected } => {
+                CharGridError::InvalidSeriesLength {
+                    actual: actual as u64,
+                    expected: expected as u64,
+                }
+            }
+        }
+    }
+}

src/command.rs

@@ -0,0 +1,175 @@
+use crate::bitmap::Bitmap;
+use crate::bitvec::BitVec;
+use crate::brightness_grid::BrightnessGrid;
+use crate::char_grid::CharGrid;
+use crate::compression_code::CompressionCode;
+use crate::cp437_grid::Cp437Grid;
+use crate::errors::ServicePointError;
+use servicepoint::Origin;
+use std::sync::Arc;
+
+#[derive(uniffi::Object)]
+pub struct Command {
+    pub(crate) actual: servicepoint::Command,
+}
+
+impl Command {
+    fn internal_new(actual: servicepoint::Command) -> Arc<Command> {
+        Arc::new(Command { actual })
+    }
+}
+
+#[uniffi::export]
+impl Command {
+    #[uniffi::constructor]
+    pub fn clear() -> Arc<Self> {
+        Self::internal_new(servicepoint::Command::Clear)
+    }
+
+    #[uniffi::constructor]
+    pub fn brightness(brightness: u8) -> Result<Arc<Self>, ServicePointError> {
+        servicepoint::Brightness::try_from(brightness)
+            .map_err(move |value| ServicePointError::InvalidBrightness {
+                value,
+            })
+            .map(servicepoint::Command::Brightness)
+            .map(Self::internal_new)
+    }
+
+    #[uniffi::constructor]
+    pub fn fade_out() -> Arc<Self> {
+        Self::internal_new(servicepoint::Command::FadeOut)
+    }
+
+    #[uniffi::constructor]
+    pub fn hard_reset() -> Arc<Self> {
+        Self::internal_new(servicepoint::Command::HardReset)
+    }
+
+    #[uniffi::constructor]
+    pub fn bitmap_linear_win(
+        offset_x: u64,
+        offset_y: u64,
+        bitmap: &Arc<Bitmap>,
+        compression: CompressionCode,
+    ) -> Arc<Self> {
+        let origin = Origin::new(offset_x as usize, offset_y as usize);
+        let bitmap = bitmap.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::BitmapLinearWin(
+            origin,
+            bitmap,
+            servicepoint::CompressionCode::try_from(compression as u16)
+                .unwrap(),
+        );
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn char_brightness(
+        offset_x: u64,
+        offset_y: u64,
+        grid: &Arc<BrightnessGrid>,
+    ) -> Arc<Self> {
+        let origin = Origin::new(offset_x as usize, offset_y as usize);
+        let grid = grid.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::CharBrightness(origin, grid);
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn bitmap_linear(
+        offset: u64,
+        bitmap: &Arc<BitVec>,
+        compression: CompressionCode,
+    ) -> Arc<Self> {
+        let bitmap = bitmap.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::BitmapLinear(
+            offset as usize,
+            bitmap,
+            servicepoint::CompressionCode::try_from(compression as u16)
+                .unwrap(),
+        );
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn bitmap_linear_and(
+        offset: u64,
+        bitmap: &Arc<BitVec>,
+        compression: CompressionCode,
+    ) -> Arc<Self> {
+        let bitmap = bitmap.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::BitmapLinearAnd(
+            offset as usize,
+            bitmap,
+            servicepoint::CompressionCode::try_from(compression as u16)
+                .unwrap(),
+        );
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn bitmap_linear_or(
+        offset: u64,
+        bitmap: &Arc<BitVec>,
+        compression: CompressionCode,
+    ) -> Arc<Self> {
+        let bitmap = bitmap.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::BitmapLinearOr(
+            offset as usize,
+            bitmap,
+            servicepoint::CompressionCode::try_from(compression as u16)
+                .unwrap(),
+        );
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn bitmap_linear_xor(
+        offset: u64,
+        bitmap: &Arc<BitVec>,
+        compression: CompressionCode,
+    ) -> Arc<Self> {
+        let bitmap = bitmap.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::BitmapLinearXor(
+            offset as usize,
+            bitmap,
+            servicepoint::CompressionCode::try_from(compression as u16)
+                .unwrap(),
+        );
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn cp437_data(
+        offset_x: u64,
+        offset_y: u64,
+        grid: &Arc<Cp437Grid>,
+    ) -> Arc<Self> {
+        let origin = Origin::new(offset_x as usize, offset_y as usize);
+        let grid = grid.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::Cp437Data(origin, grid);
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn utf8_data(
+        offset_x: u64,
+        offset_y: u64,
+        grid: &Arc<CharGrid>,
+    ) -> Arc<Self> {
+        let origin = Origin::new(offset_x as usize, offset_y as usize);
+        let grid = grid.actual.read().unwrap().clone();
+        let actual = servicepoint::Command::Utf8Data(origin, grid);
+        Self::internal_new(actual)
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.clone())
+    }
+
+    pub fn equals(&self, other: &Command) -> bool {
+        self.actual == other.actual
+    }
+}

src/compression_code.rs

@@ -0,0 +1,14 @@
+#[repr(u16)]
+#[derive(Debug, Clone, Copy, PartialEq, uniffi::Enum)]
+pub enum CompressionCode {
+    /// no compression
+    Uncompressed = 0x0,
+    /// compress using flate2 with zlib header
+    Zlib = 0x677a,
+    /// compress using bzip2
+    Bzip2 = 0x627a,
+    /// compress using lzma
+    Lzma = 0x6c7a,
+    /// compress using Zstandard
+    Zstd = 0x7a73,
+}

src/connection.rs

@@ -0,0 +1,36 @@
+use std::sync::Arc;
+
+use crate::command::Command;
+use crate::errors::ServicePointError;
+
+#[derive(uniffi::Object)]
+pub struct Connection {
+    actual: servicepoint::Connection,
+}
+
+#[uniffi::export]
+impl Connection {
+    #[uniffi::constructor]
+    pub fn new(host: String) -> Result<Arc<Self>, ServicePointError> {
+        servicepoint::Connection::open(host)
+            .map(|actual| Arc::new(Connection { actual }))
+            .map_err(|err| ServicePointError::IoError {
+                error: err.to_string(),
+            })
+    }
+
+    #[uniffi::constructor]
+    pub fn new_fake() -> Arc<Self> {
+        Arc::new(Self {
+            actual: servicepoint::Connection::Fake,
+        })
+    }
+
+    pub fn send(&self, command: Arc<Command>) -> Result<(), ServicePointError> {
+        self.actual.send(command.actual.clone()).map_err(|err| {
+            ServicePointError::IoError {
+                error: format!("{err:?}"),
+            }
+        })
+    }
+}

src/constants.rs

@@ -0,0 +1,23 @@
+#[derive(
+    Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, uniffi::Record,
+)]
+pub struct Constants {
+    pub tile_size: u64,
+    pub tile_width: u64,
+    pub tile_height: u64,
+    pub pixel_width: u64,
+    pub pixel_height: u64,
+    pub pixel_count: u64,
+}
+
+#[uniffi::export]
+fn get_constants() -> Constants {
+    Constants {
+        tile_size: servicepoint::TILE_SIZE as u64,
+        tile_width: servicepoint::TILE_WIDTH as u64,
+        tile_height: servicepoint::TILE_HEIGHT as u64,
+        pixel_width: servicepoint::PIXEL_WIDTH as u64,
+        pixel_height: servicepoint::PIXEL_HEIGHT as u64,
+        pixel_count: servicepoint::PIXEL_COUNT as u64,
+    }
+}

src/cp437_grid.rs

@@ -0,0 +1,79 @@
+use crate::char_grid::CharGrid;
+use servicepoint::{DataRef, Grid};
+use std::sync::{Arc, RwLock};
+
+#[derive(uniffi::Object)]
+pub struct Cp437Grid {
+    pub(crate) actual: RwLock<servicepoint::Cp437Grid>,
+}
+
+impl Cp437Grid {
+    pub(crate) fn internal_new(actual: servicepoint::Cp437Grid) -> Arc<Self> {
+        Arc::new(Self {
+            actual: RwLock::new(actual),
+        })
+    }
+}
+
+#[uniffi::export]
+impl Cp437Grid {
+    #[uniffi::constructor]
+    pub fn new(width: u64, height: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::Cp437Grid::new(
+            width as usize,
+            height as usize,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn load(width: u64, height: u64, data: Vec<u8>) -> Arc<Self> {
+        Self::internal_new(servicepoint::Cp437Grid::load(
+            width as usize,
+            height as usize,
+            &data,
+        ))
+    }
+
+    #[uniffi::constructor]
+    pub fn clone(other: &Arc<Self>) -> Arc<Self> {
+        Self::internal_new(other.actual.read().unwrap().clone())
+    }
+
+    pub fn set(&self, x: u64, y: u64, value: u8) {
+        self.actual
+            .write()
+            .unwrap()
+            .set(x as usize, y as usize, value)
+    }
+
+    pub fn get(&self, x: u64, y: u64) -> u8 {
+        self.actual.read().unwrap().get(x as usize, y as usize)
+    }
+
+    pub fn fill(&self, value: u8) {
+        self.actual.write().unwrap().fill(value)
+    }
+    pub fn width(&self) -> u64 {
+        self.actual.read().unwrap().width() as u64
+    }
+
+    pub fn height(&self) -> u64 {
+        self.actual.read().unwrap().height() as u64
+    }
+
+    pub fn equals(&self, other: &Cp437Grid) -> bool {
+        let a = self.actual.read().unwrap();
+        let b = other.actual.read().unwrap();
+        *a == *b
+    }
+
+    pub fn copy_raw(&self) -> Vec<u8> {
+        self.actual.read().unwrap().data_ref().to_vec()
+    }
+
+    pub fn to_utf8(&self) -> Arc<CharGrid> {
+        CharGrid::internal_new(servicepoint::CharGrid::from(
+            &*self.actual.read().unwrap(),
+        ))
+    }
+}

src/errors.rs

@@ -0,0 +1,7 @@
+#[derive(uniffi::Error, thiserror::Error, Debug)]
+pub enum ServicePointError {
+    #[error("An IO error occurred: {error}")]
+    IoError { error: String },
+    #[error("The specified brightness value {value} is out of range")]
+    InvalidBrightness { value: u8 },
+}

src/lib.rs

@@ -0,0 +1,12 @@
+uniffi::setup_scaffolding!();
+
+mod bitmap;
+mod bitvec;
+mod brightness_grid;
+mod char_grid;
+mod command;
+mod compression_code;
+mod connection;
+mod constants;
+mod cp437_grid;
+mod errors;