Merge pull request RustPython#2239 from RustPython/coolreader18/unified-common-locks

Unified lock types for rustpython_common

Author: coolreader18

Cargo.lock

@@ -8,6 +8,7 @@ edition = "2018"
 threading = ["parking_lot"]
 
 [dependencies]
+lock_api = "0.4"
 parking_lot = { version = "0.11.0", optional = true }
 num-traits = "0.2"
 num-complex = "0.3"

common/Cargo.toml

@@ -1,6 +1,6 @@
-use crate::cell::{
-    PyMappedMutexGuard, PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyMutexGuard,
-    PyRwLockReadGuard, PyRwLockWriteGuard,
+use crate::lock::{
+    MapImmutable, PyImmutableMappedMutexGuard, PyMappedMutexGuard, PyMappedRwLockReadGuard,
+    PyMappedRwLockWriteGuard, PyMutexGuard, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
 use std::ops::{Deref, DerefMut};
 
@@ -13,11 +13,30 @@ pub trait BorrowValue<'a> {
 pub enum BorrowedValue<'a, T: ?Sized> {
     Ref(&'a T),
     MuLock(PyMutexGuard<'a, T>),
-    MappedMuLock(PyMappedMutexGuard<'a, T>),
+    MappedMuLock(PyImmutableMappedMutexGuard<'a, T>),
     ReadLock(PyRwLockReadGuard<'a, T>),
     MappedReadLock(PyMappedRwLockReadGuard<'a, T>),
 }
 
+impl<'a, T: ?Sized> BorrowedValue<'a, T> {
+    pub fn map<U: ?Sized, F>(s: Self, f: F) -> BorrowedValue<'a, U>
+    where
+        F: FnOnce(&T) -> &U,
+    {
+        match s {
+            Self::Ref(r) => BorrowedValue::Ref(f(r)),
+            Self::MuLock(m) => BorrowedValue::MappedMuLock(PyMutexGuard::map_immutable(m, f)),
+            Self::MappedMuLock(m) => {
+                BorrowedValue::MappedMuLock(PyImmutableMappedMutexGuard::map(m, f))
+            }
+            Self::ReadLock(r) => BorrowedValue::MappedReadLock(PyRwLockReadGuard::map(r, f)),
+            Self::MappedReadLock(m) => {
+                BorrowedValue::MappedReadLock(PyMappedRwLockReadGuard::map(m, f))
+            }
+        }
+    }
+}
+
 impl<T: ?Sized> Deref for BorrowedValue<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {
@@ -40,6 +59,23 @@ pub enum BorrowedValueMut<'a, T: ?Sized> {
     MappedWriteLock(PyMappedRwLockWriteGuard<'a, T>),
 }
 
+impl<'a, T: ?Sized> BorrowedValueMut<'a, T> {
+    pub fn map<U: ?Sized, F>(s: Self, f: F) -> BorrowedValueMut<'a, U>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+    {
+        match s {
+            Self::RefMut(r) => BorrowedValueMut::RefMut(f(r)),
+            Self::MuLock(m) => BorrowedValueMut::MappedMuLock(PyMutexGuard::map(m, f)),
+            Self::MappedMuLock(m) => BorrowedValueMut::MappedMuLock(PyMappedMutexGuard::map(m, f)),
+            Self::WriteLock(r) => BorrowedValueMut::MappedWriteLock(PyRwLockWriteGuard::map(r, f)),
+            Self::MappedWriteLock(m) => {
+                BorrowedValueMut::MappedWriteLock(PyMappedRwLockWriteGuard::map(m, f))
+            }
+        }
+    }
+}
+
 impl<T: ?Sized> Deref for BorrowedValueMut<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {

common/src/borrow.rs

@@ -1,8 +1,8 @@
 //! A crate to hold types and functions common to all rustpython components.
 
 pub mod borrow;
-pub mod cell;
 pub mod float_ops;
 pub mod hash;
+pub mod lock;
 pub mod rc;
 pub mod str;