1 files changed, 48 insertions, 80 deletions
diff --git a/ecs/src/lock.rs b/ecs/src/lock.rs
index c700098..0b36922 100644
--- a/ecs/src/lock.rs
+++ b/ecs/src/lock.rs
@@ -1,4 +1,4 @@
-use std::mem::{forget, transmute};
+use std::mem::forget;
 use std::ops::{Deref, DerefMut};
 
 use parking_lot::{
@@ -9,23 +9,21 @@ use parking_lot::{
     RwLockWriteGuard,
 };
 
-use crate::type_name::TypeName;
-
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct Lock<Value>
-where
-    Value: TypeName,
 {
     inner: RwLock<Value>,
+    value_type_name: &'static str,
 }
 
 impl<Value> Lock<Value>
-where
-    Value: TypeName,
 {
-    pub fn new(value: Value) -> Self
+    pub fn new(value: Value, value_type_name: &'static str) -> Self
     {
-        Self { inner: RwLock::new(value) }
+        Self {
+            inner: RwLock::new(value),
+            value_type_name,
+        }
     }
 
     /// Tries to a acquire a handle to the resource with read access.
@@ -36,9 +34,12 @@ where
     {
         let guard = self.inner.try_read().ok_or(Error::ReadUnavailable)?;
 
-        tracing::trace!("Acquired lock to value of type {}", guard.type_name());
+        tracing::trace!("Acquired lock to value of type {}", self.value_type_name);
 
-        Ok(ReadGuard { inner: guard })
+        Ok(ReadGuard {
+            inner: guard,
+            value_type_name: self.value_type_name,
+        })
     }
 
     /// Tries to a acquire a handle to the resource with mutable access.
@@ -51,15 +52,13 @@ where
 
         tracing::trace!(
             "Acquired mutable lock to value of type {}",
-            guard.type_name()
+            self.value_type_name
         );
 
-        Ok(WriteGuard { inner: guard })
-    }
-
-    pub fn into_inner(self) -> Value
-    {
-        self.inner.into_inner()
+        Ok(WriteGuard {
+            inner: guard,
+            value_type_name: self.value_type_name,
+        })
     }
 }
 
@@ -75,23 +74,20 @@ pub enum Error
 
 #[derive(Debug)]
 pub struct ReadGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     inner: RwLockReadGuard<'guard, Value>,
+    value_type_name: &'static str,
 }
 
 impl<'guard, Value> ReadGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     pub fn map<NewValue>(
         self,
         func: impl FnOnce(&Value) -> &NewValue,
     ) -> MappedReadGuard<'guard, NewValue>
-    where
-        NewValue: TypeName,
     {
+        let value_type_name = self.value_type_name;
+
         // The 'inner' field cannot be moved out of ReadGuard in a normal way since
         // ReadGuard implements Drop
         let inner = unsafe { std::ptr::read(&self.inner) };
@@ -99,24 +95,12 @@ where
 
         MappedReadGuard {
             inner: RwLockReadGuard::map(inner, func),
+            value_type_name,
         }
     }
-
-    /// Converts the `ReadGuard` to a `ReadGuard` with a possibly longer lifetime.
-    ///
-    /// # Safety
-    /// The returned `ReadGuard` must **NOT** be used for longer than the original
-    /// lifetime.
-    #[must_use]
-    pub unsafe fn upgrade_lifetime<'new>(self) -> ReadGuard<'new, Value>
-    {
-        unsafe { transmute(self) }
-    }
 }
 
-impl<'guard, Value> Deref for ReadGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Deref for ReadGuard<'_, Value>
 {
     type Target = Value;
 
@@ -126,27 +110,22 @@ where
     }
 }
 
-impl<'guard, Value> Drop for ReadGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Drop for ReadGuard<'_, Value>
 {
     fn drop(&mut self)
     {
-        tracing::trace!("Dropped lock to value of type {}", self.type_name());
+        tracing::trace!("Dropped lock to value of type {}", self.value_type_name);
     }
 }
 
 #[derive(Debug)]
 pub struct MappedReadGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     inner: MappedRwLockReadGuard<'guard, Value>,
+    value_type_name: &'static str,
 }
 
-impl<'guard, Value> Deref for MappedReadGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Deref for MappedReadGuard<'_, Value>
 {
     type Target = Value;
 
@@ -156,35 +135,33 @@ where
     }
 }
 
-impl<'guard, Value> Drop for MappedReadGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Drop for MappedReadGuard<'_, Value>
 {
     fn drop(&mut self)
     {
-        tracing::trace!("Dropped mapped lock to value of type {}", self.type_name());
+        tracing::trace!(
+            "Dropped mapped lock to value of type {}",
+            self.value_type_name
+        );
     }
 }
 
 #[derive(Debug)]
 pub struct WriteGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     inner: RwLockWriteGuard<'guard, Value>,
+    value_type_name: &'static str,
 }
 
 impl<'guard, Value> WriteGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     pub fn map<NewValue>(
         self,
         func: impl FnOnce(&mut Value) -> &mut NewValue,
     ) -> MappedWriteGuard<'guard, NewValue>
-    where
-        NewValue: TypeName,
     {
+        let value_type_name = self.value_type_name;
+
         // The 'inner' field cannot be moved out of ReadGuard in a normal way since
         // ReadGuard implements Drop
         let inner = unsafe { std::ptr::read(&self.inner) };
@@ -192,13 +169,12 @@ where
 
         MappedWriteGuard {
             inner: RwLockWriteGuard::map(inner, func),
+            value_type_name,
         }
     }
 }
 
-impl<'guard, Value> Deref for WriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Deref for WriteGuard<'_, Value>
 {
     type Target = Value;
 
@@ -208,9 +184,7 @@ where
     }
 }
 
-impl<'guard, Value> DerefMut for WriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> DerefMut for WriteGuard<'_, Value>
 {
     fn deref_mut(&mut self) -> &mut Self::Target
     {
@@ -218,27 +192,25 @@ where
     }
 }
 
-impl<'guard, Value> Drop for WriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Drop for WriteGuard<'_, Value>
 {
     fn drop(&mut self)
     {
-        tracing::trace!("Dropped mutable lock to value of type {}", self.type_name());
+        tracing::trace!(
+            "Dropped mutable lock to value of type {}",
+            self.value_type_name
+        );
     }
 }
 
 #[derive(Debug)]
 pub struct MappedWriteGuard<'guard, Value>
-where
-    Value: TypeName,
 {
     inner: MappedRwLockWriteGuard<'guard, Value>,
+    value_type_name: &'static str,
 }
 
-impl<'guard, Value> Deref for MappedWriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Deref for MappedWriteGuard<'_, Value>
 {
     type Target = Value;
 
@@ -248,9 +220,7 @@ where
     }
 }
 
-impl<'guard, Value> DerefMut for MappedWriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> DerefMut for MappedWriteGuard<'_, Value>
 {
     fn deref_mut(&mut self) -> &mut Self::Target
     {
@@ -258,15 +228,13 @@ where
     }
 }
 
-impl<'guard, Value> Drop for MappedWriteGuard<'guard, Value>
-where
-    Value: TypeName,
+impl<Value> Drop for MappedWriteGuard<'_, Value>
 {
     fn drop(&mut self)
     {
         tracing::trace!(
             "Dropped mapped mutable lock to value of type {}",
-            self.type_name()
+            self.value_type_name
         );
     }
 }