From f21e8e1bea1e93aaa22e4d6baa3a490140977617 Mon Sep 17 00:00:00 2001
From: SoniEx2 <endermoneymod@gmail.com>
Date: Sat, 7 May 2022 12:18:38 -0300
Subject: [Project] LtPtr

"Checked" raw pointers for Rust.
---
 src/impls/ptr_traits.rs | 174 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 174 insertions(+)
 create mode 100644 src/impls/ptr_traits.rs

(limited to 'src/impls/ptr_traits.rs')

diff --git a/src/impls/ptr_traits.rs b/src/impls/ptr_traits.rs
new file mode 100644
index 0000000..768d364
--- /dev/null
+++ b/src/impls/ptr_traits.rs
@@ -0,0 +1,174 @@
+
+//use core::ops::{Deref, DerefMut};
+use core::panic::{RefUnwindSafe, UnwindSafe};
+
+use crate::*;
+
+// maybe we shouldn't have Deref? we want to make it hard to fuck things up.
+
+//impl<'a, T: ?Sized> Deref for ConstLtPtr<'a, T> {
+//    type Target = *const T;
+//    fn deref(&self) -> &*const T {
+//        &self.raw
+//    }
+//}
+//
+//impl<'a, T: ?Sized> DerefMut for ConstLtPtr<'a, T> {
+//    fn deref_mut(&mut self) -> &mut *const T {
+//        &mut self.raw
+//    }
+//}
+//
+//impl<'a, T: ?Sized> Deref for MutLtPtr<'a, T> {
+//    type Target = *mut T;
+//    fn deref(&self) -> &*mut T {
+//        &self.raw
+//    }
+//}
+//
+//impl<'a, T: ?Sized> DerefMut for MutLtPtr<'a, T> {
+//    fn deref_mut(&mut self) -> &mut *mut T {
+//        &mut self.raw
+//    }
+//}
+
+// *mut T are UnwindSafe, so ours should be too.
+impl<'a, T: RefUnwindSafe + ?Sized> UnwindSafe for MutLtPtr<'a, T> {}
+
+impl<'a, T: ?Sized> Copy for ConstLtPtr<'a, T> {}
+impl<'a, T: ?Sized> Clone for ConstLtPtr<'a, T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, T: ?Sized> core::fmt::Debug for ConstLtPtr<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&self.raw, f)
+    }
+}
+
+impl<'a, T: ?Sized> core::fmt::Pointer for ConstLtPtr<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::Pointer::fmt(&self.raw, f)
+    }
+}
+
+impl<'a, T: ?Sized> core::hash::Hash for ConstLtPtr<'a, T> {
+    #[inline]
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        core::hash::Hash::hash(&self.raw, state)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::Ord for ConstLtPtr<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        core::cmp::Ord::cmp(&self.raw, &other.raw)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::Eq for ConstLtPtr<'a, T> {}
+impl<'a, T: ?Sized> core::cmp::PartialEq for ConstLtPtr<'a, T> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        core::cmp::PartialEq::eq(&self.raw, &other.raw)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::PartialOrd for ConstLtPtr<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        core::cmp::PartialOrd::partial_cmp(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn lt(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::lt(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn le(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::le(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn gt(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::gt(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn ge(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::ge(&self.raw, &other.raw)
+    }
+}
+
+impl<'a, T: ?Sized> Copy for MutLtPtr<'a, T> {}
+impl<'a, T: ?Sized> Clone for MutLtPtr<'a, T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, T: ?Sized> core::fmt::Debug for MutLtPtr<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&self.raw, f)
+    }
+}
+
+impl<'a, T: ?Sized> core::fmt::Pointer for MutLtPtr<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::Pointer::fmt(&self.raw, f)
+    }
+}
+
+impl<'a, T: ?Sized> core::hash::Hash for MutLtPtr<'a, T> {
+    #[inline]
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        core::hash::Hash::hash(&self.raw, state)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::Ord for MutLtPtr<'a, T> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        core::cmp::Ord::cmp(&self.raw, &other.raw)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::Eq for MutLtPtr<'a, T> {}
+impl<'a, T: ?Sized> core::cmp::PartialEq for MutLtPtr<'a, T> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        core::cmp::PartialEq::eq(&self.raw, &other.raw)
+    }
+}
+
+impl<'a, T: ?Sized> core::cmp::PartialOrd for MutLtPtr<'a, T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        core::cmp::PartialOrd::partial_cmp(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn lt(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::lt(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn le(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::le(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn gt(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::gt(&self.raw, &other.raw)
+    }
+
+    #[inline]
+    fn ge(&self, other: &Self) -> bool {
+        core::cmp::PartialOrd::ge(&self.raw, &other.raw)
+    }
+}
-- 
cgit 1.4.1