[Project] LtPtr

"Checked" raw pointers for Rust.

3 files changed, 232 insertions, 0 deletions

diff --git a/src/impls/cstr.rs b/src/impls/cstr.rs
new file mode 100644
index 0000000..5467963
--- /dev/null
+++ b/src/impls/cstr.rs
@@ -0,0 +1,18 @@
+
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+use crate::*;
+
+impl AsLtPtr for CStr {
+    type Target = c_char;
+
+    /// Returns the inner pointer to this C string.
+    ///
+    /// The returned pointer points to a contiguous region of memory terminated
+    /// with a 0 byte to represent the end of the string.
+    #[inline]
+    fn as_lt_ptr(&self) -> ConstLtPtr<'_, c_char> {
+        unsafe { ConstLtPtr::from_raw(self.as_ptr()) }
+    }
+}
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)
+    }
+}
diff --git a/src/impls/slice.rs b/src/impls/slice.rs
new file mode 100644
index 0000000..ff9b9de
--- /dev/null
+++ b/src/impls/slice.rs
@@ -0,0 +1,40 @@
+
+use crate::*;
+
+pub trait Sealed {}
+impl<T> Sealed for [T] {}
+
+impl<T> AsLtPtr for [T] {
+    type Target = T;
+    fn as_lt_ptr(&self) -> ConstLtPtr<'_, T> {
+        unsafe { ConstLtPtr::from_raw(self.as_ptr()) }
+    }
+}
+
+impl<T> AsMutLtPtr for [T] {
+    fn as_mut_lt_ptr(&mut self) -> MutLtPtr<'_, T> {
+        unsafe { MutLtPtr::from_raw(self.as_mut_ptr()) }
+    }
+}
+
+impl<T> SliceExt<T> for [T] {
+    fn as_lt_ptr_range(&self) -> Range<ConstLtPtr<'_, T>> {
+        let Range { start, end } = self.as_ptr_range();
+        unsafe {
+            Range {
+                start: ConstLtPtr::from_raw(start),
+                end: ConstLtPtr::from_raw(end),
+            }
+        }
+    }
+
+    fn as_mut_lt_ptr_range(&mut self) -> Range<MutLtPtr<'_, T>> {
+        let Range { start, end } = self.as_mut_ptr_range();
+        unsafe {
+            Range {
+                start: MutLtPtr::from_raw(start),
+                end: MutLtPtr::from_raw(end),
+            }
+        }
+    }
+}