move containers to module

src/containers/bitmap.rs

@@ -0,0 +1,40 @@
+use crate::macros::*;
+use servicepoint::Grid;
+use std::{ops::Deref, sync::Arc};
+
+wrap_uniffi_object!(Bitmap);
+wrap_width_height!(Bitmap);
+wrap_get_set_fill_2d!(Bitmap, bool);
+
+#[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).unwrap(),
+        )
+    }
+
+    #[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)
+                .unwrap(),
+        )
+    }
+
+    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().deref().into()
+    }
+}

src/containers/bitvec.rs

@@ -0,0 +1,49 @@
+use crate::macros::wrap_uniffi_object;
+use std::sync::Arc;
+
+wrap_uniffi_object!(DisplayBitVec, BitVec);
+
+#[uniffi::export]
+impl BitVec {
+    #[uniffi::constructor]
+    pub fn new(size: u64) -> Arc<Self> {
+        Self::internal_new(servicepoint::DisplayBitVec::repeat(
+            false,
+            size as usize,
+        ))
+    }
+    #[uniffi::constructor]
+    pub fn load(data: Vec<u8>) -> Arc<Self> {
+        Self::internal_new(servicepoint::DisplayBitVec::from_slice(&data))
+    }
+
+    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/containers/brightness_grid.rs

@@ -0,0 +1,40 @@
+use crate::macros::*;
+use servicepoint::{Brightness, Grid};
+use std::{ops::Deref, sync::Arc};
+
+wrap_uniffi_object!(BrightnessGrid);
+wrap_width_height!(BrightnessGrid);
+wrap_get_set_fill_2d!(BrightnessGrid, Brightness);
+
+#[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,
+            )
+            .unwrap(),
+        )
+    }
+
+    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().deref().into()
+    }
+}

src/containers/char_grid.rs

@@ -0,0 +1,147 @@
+use crate::{containers::cp437_grid::Cp437Grid, macros::*};
+use servicepoint::{Grid, SetValueSeriesError};
+use std::{convert::Into, sync::Arc};
+
+wrap_uniffi_object!(CharGrid);
+wrap_width_height!(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))
+    }
+
+    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 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 {
+    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/containers/cp437_grid.rs

@@ -0,0 +1,46 @@
+use crate::{containers::char_grid::CharGrid, macros::*};
+use servicepoint::Grid;
+use std::{ops::Deref, sync::Arc};
+
+wrap_uniffi_object!(Cp437Grid);
+wrap_width_height!(Cp437Grid);
+wrap_get_set_fill_2d!(Cp437Grid, u8);
+
+#[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,
+            )
+            .unwrap(),
+        )
+    }
+
+    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().deref().into()
+    }
+
+    pub fn to_utf8(&self) -> Arc<CharGrid> {
+        CharGrid::internal_new(servicepoint::CharGrid::from(
+            &*self.actual.read().unwrap(),
+        ))
+    }
+}

src/containers/mod.rs

@@ -0,0 +1,5 @@
+pub mod bitmap;
+pub mod bitvec;
+pub mod brightness_grid;
+pub mod char_grid;
+pub mod cp437_grid;