feat: BorshSerialize/BoshDeserialize/BorshSchema for Cell/RefCell

borsh/src/de/mod.rs

@@ -925,6 +925,47 @@ impl<T: ?Sized> BorshDeserialize for PhantomData<T> {
         Ok(PhantomData)
     }
 }
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for core::cell::Cell<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::Cell::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for core::cell::RefCell<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::RefCell::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for std::sync::Mutex<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(std::sync::Mutex::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for std::sync::RwLock<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(std::sync::RwLock::new)
+    }
+}
+
 /// Deserializes an object from a slice of bytes.
 /// # Example
 /// ```

borsh/src/ser/mod.rs

@@ -637,3 +637,55 @@ impl<T: ?Sized> BorshSerialize for PhantomData<T> {
         Ok(())
     }
 }
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for core::cell::Cell<T>
+where
+    T: BorshSerialize + Copy,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        <T as BorshSerialize>::serialize(&self.get(), writer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for core::cell::RefCell<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        <T as BorshSerialize>::serialize(core::ops::Deref::deref(&self.borrow()), writer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for std::sync::Mutex<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        match self.lock().as_deref() {
+            Ok(locked) => <T as BorshSerialize>::serialize(locked, writer),
+            Err(_) => Err(Error::new(
+                ErrorKind::InvalidData,
+                "lock poison error while serializing",
+            )),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for std::sync::RwLock<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        match self.read().as_deref() {
+            Ok(locked) => <T as BorshSerialize>::serialize(locked, writer),
+            Err(_) => Err(Error::new(
+                ErrorKind::InvalidData,
+                "lock poison error while serializing",
+            )),
+        }
+    }
+}