embedded_svc/

storage.rs

use core::any::Any;
use core::fmt::{self, Debug};

#[cfg(feature = "use_serde")]
use serde::{de::DeserializeOwned, Serialize};

pub trait StorageBase {
    type Error: Debug;

    fn contains(&self, name: &str) -> Result<bool, Self::Error>;
    fn remove(&mut self, name: &str) -> Result<bool, Self::Error>;
}

impl<S> StorageBase for &mut S
where
    S: StorageBase,
{
    type Error = S::Error;

    fn contains(&self, name: &str) -> Result<bool, Self::Error> {
        (**self).contains(name)
    }

    fn remove(&mut self, name: &str) -> Result<bool, Self::Error> {
        (*self).remove(name)
    }
}

#[cfg(feature = "use_serde")]
pub trait Storage: StorageBase {
    fn get<T>(&self, name: &str) -> Result<Option<T>, Self::Error>
    where
        T: serde::de::DeserializeOwned;

    fn set<T>(&mut self, name: &str, value: &T) -> Result<bool, Self::Error>
    where
        T: serde::Serialize;
}

#[cfg(feature = "use_serde")]
impl<S> Storage for &mut S
where
    S: Storage,
{
    fn get<T>(&self, name: &str) -> Result<Option<T>, Self::Error>
    where
        T: serde::de::DeserializeOwned,
    {
        (**self).get(name)
    }

    fn set<T>(&mut self, name: &str, value: &T) -> Result<bool, Self::Error>
    where
        T: serde::Serialize,
    {
        (*self).set(name, value)
    }
}

pub trait DynStorage<'a>: StorageBase {
    fn get(&self, name: &str) -> Result<Option<&'a dyn Any>, Self::Error>;

    fn set(&mut self, name: &'a str, value: &'a dyn Any) -> Result<bool, Self::Error>;
}

impl<'a, D> DynStorage<'a> for &'a mut D
where
    D: DynStorage<'a>,
{
    fn get(&self, name: &str) -> Result<Option<&'a dyn Any>, Self::Error> {
        (**self).get(name)
    }

    fn set(&mut self, name: &'a str, value: &'a dyn Any) -> Result<bool, Self::Error> {
        (*self).set(name, value)
    }
}

pub trait RawStorage: StorageBase {
    fn len(&self, name: &str) -> Result<Option<usize>, Self::Error>;

    fn get_raw<'a>(&self, name: &str, buf: &'a mut [u8]) -> Result<Option<&'a [u8]>, Self::Error>;

    fn set_raw(&mut self, name: &str, buf: &[u8]) -> Result<bool, Self::Error>;
}

impl<R> RawStorage for &mut R
where
    R: RawStorage,
{
    fn len(&self, name: &str) -> Result<Option<usize>, Self::Error> {
        (**self).len(name)
    }

    fn get_raw<'a>(&self, name: &str, buf: &'a mut [u8]) -> Result<Option<&'a [u8]>, Self::Error> {
        (**self).get_raw(name, buf)
    }

    fn set_raw(&mut self, name: &str, buf: &[u8]) -> Result<bool, Self::Error> {
        (**self).set_raw(name, buf)
    }
}

#[cfg(feature = "use_serde")]
pub trait SerDe {
    type Error: Debug;

    fn serialize<'a, T>(&self, slice: &'a mut [u8], value: &T) -> Result<&'a [u8], Self::Error>
    where
        T: Serialize;

    fn deserialize<T>(&self, slice: &[u8]) -> Result<T, Self::Error>
    where
        T: DeserializeOwned;
}

#[cfg(feature = "use_serde")]
impl<S> SerDe for &S
where
    S: SerDe,
{
    type Error = S::Error;

    fn serialize<'a, T>(&self, slice: &'a mut [u8], value: &T) -> Result<&'a [u8], Self::Error>
    where
        T: Serialize,
    {
        (*self).serialize(slice, value)
    }

    fn deserialize<T>(&self, slice: &[u8]) -> Result<T, Self::Error>
    where
        T: DeserializeOwned,
    {
        (*self).deserialize(slice)
    }
}

#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum StorageError<R, S> {
    RawStorageError(R),
    SerdeError(S),
}

impl<R, S> fmt::Display for StorageError<R, S>
where
    R: fmt::Display,
    S: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::RawStorageError(e) => write!(f, "Storage error: {e}"),
            Self::SerdeError(e) => write!(f, "SerDe error: {e}"),
        }
    }
}

impl<R, S> core::error::Error for StorageError<R, S>
where
    R: core::error::Error,
    S: core::error::Error,
{
}

#[cfg(feature = "use_serde")]
pub struct StorageImpl<const N: usize, R, S> {
    raw_storage: R,
    serde: S,
}

#[cfg(feature = "use_serde")]
impl<const N: usize, R, S> StorageImpl<N, R, S>
where
    R: RawStorage,
    S: SerDe,
{
    pub const fn new(raw_storage: R, serde: S) -> Self {
        Self { raw_storage, serde }
    }

    pub fn raw_storage(&self) -> &R {
        &self.raw_storage
    }

    pub fn raw_storage_mut(&mut self) -> &mut R {
        &mut self.raw_storage
    }

    pub fn contains(&self, name: &str) -> Result<bool, StorageError<R::Error, S::Error>> {
        self.raw_storage
            .contains(name)
            .map_err(StorageError::RawStorageError)
    }

    pub fn remove(&mut self, name: &str) -> Result<bool, StorageError<R::Error, S::Error>> {
        self.raw_storage
            .remove(name)
            .map_err(StorageError::RawStorageError)
    }

    pub fn get<T>(&self, name: &str) -> Result<Option<T>, StorageError<R::Error, S::Error>>
    where
        T: DeserializeOwned,
    {
        let mut buf = [0_u8; N];

        if let Some(buf) = self
            .raw_storage
            .get_raw(name, &mut buf)
            .map_err(StorageError::RawStorageError)?
        {
            Ok(Some(
                self.serde
                    .deserialize(buf)
                    .map_err(StorageError::SerdeError)?,
            ))
        } else {
            Ok(None)
        }
    }

    pub fn set<T>(
        &mut self,
        name: &str,
        value: &T,
    ) -> Result<bool, StorageError<R::Error, S::Error>>
    where
        T: Serialize,
    {
        let mut buf = [0_u8; N];

        let buf = self
            .serde
            .serialize(&mut buf, value)
            .map_err(StorageError::SerdeError)?;

        self.raw_storage
            .set_raw(name, buf)
            .map_err(StorageError::RawStorageError)
    }
}

#[cfg(feature = "use_serde")]
impl<const N: usize, R, S> StorageBase for StorageImpl<N, R, S>
where
    R: RawStorage,
    S: SerDe,
{
    type Error = StorageError<R::Error, S::Error>;

    fn contains(&self, name: &str) -> Result<bool, Self::Error> {
        StorageImpl::contains(self, name)
    }

    fn remove(&mut self, name: &str) -> Result<bool, Self::Error> {
        StorageImpl::remove(self, name)
    }
}

#[cfg(feature = "use_serde")]
impl<const N: usize, R, S> Storage for StorageImpl<N, R, S>
where
    R: RawStorage,
    S: SerDe,
{
    fn get<T>(&self, name: &str) -> Result<Option<T>, Self::Error>
    where
        T: DeserializeOwned,
    {
        StorageImpl::get(self, name)
    }

    fn set<T>(&mut self, name: &str, value: &T) -> Result<bool, Self::Error>
    where
        T: Serialize,
    {
        StorageImpl::set(self, name, value)
    }
}