wrapit 0.2.0

//! wrapped crate.
//! A small library that wraps any variable using interior mutability
//! (`RefCell` or `Cell`) to allow mutation through shared reference
#![deny(clippy::all, clippy::pedantic, unused)]

use std::cell::RefCell;
use std::sync::Arc;

#[derive(Default, Clone, PartialOrd, PartialEq)]
#[non_exhaustive]
pub struct Wrapper<T> {
    data: Arc<RefCell<T>>,
}

impl<T> std::fmt::Debug for Wrapper<T>
where
    T: std::fmt::Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.data)
    }
}

impl<T> Wrapper<T>
where
    T: Clone,
{
    ///```
    /// use std::cell::RefCell;
    /// use std::sync::Arc;
    /// use wrapit::Wrapper;
    /// let wrapper = Wrapper::new("java");
    /// assert_eq!(wrapper, Wrapper::new("java"));
    ///```
    pub fn new(data: T) -> Self {
        Self {
            data: Arc::new(RefCell::new(data)),
        }
    }

    ///```
    /// use wrapit::Wrapper;
    /// use std::cell::RefCell;
    /// let wrapper = Wrapper::new("java");
    /// let res = wrapper.reset("clojure");
    /// let got = Wrapper::new("clojure");
    /// assert_eq!(got, *res);
    ///```
    pub fn reset(&self, ndata: T) -> &Self {
        *self.data.borrow_mut() = ndata;
        self
    }

    ///```
    /// use wrapit::Wrapper;
    /// use std::cell::RefCell;
    /// use std::sync::Arc;
    /// let wrapper = Wrapper::new("java");
    /// assert_eq!(wrapper.get(), "java");
    ///```
    pub fn get(&self) -> T {
        self.data.borrow().clone()
    }

    pub fn borrow(&self) -> std::cell::Ref<'_, T> {
        self.data.borrow()
    }

    pub fn map<F, U>(&self, f: F) -> U
    where
        F: FnOnce(&T) -> U,
    {
        let borrow = self.data.borrow();
        f(&borrow)
    }
}

#[cfg(test)]
mod unittest;