---

yaml
---
r: 166765
b: refs/heads/master
c: ef5da14
h: refs/heads/master
i:
  166763: 92a4717
v: v3

Author: luqmana

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 46e73764896316ef1384591656cfca01280c5e5c
+refs/heads/master: ef5da14edb09d6425b1b6576d418e12c268ddf17
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 023dfb0c898d851dee6ace2f8339b73b5287136b
 refs/heads/try: f5d619caf9f32458680fae55526b99582ca682dd

trunk/src/libcore/ptr.rs

@@ -90,6 +90,7 @@
 use mem;
 use clone::Clone;
 use intrinsics;
+use kinds::Copy;
 use option::Option;
 use option::Option::{Some, None};
 use kinds::{Send, Sync};
@@ -109,6 +110,15 @@ pub use intrinsics::copy_memory;
 #[experimental = "uncertain about naming and semantics"]
 pub use intrinsics::set_memory;
 
+
+/// A wrapper type for raw pointers and integers that will never be
+/// NULL or 0 that might allow certain optimizations.
+#[lang="non_zero"]
+#[deriving(Clone, PartialEq, Eq, PartialOrd)]
+pub struct NonZero<T>(pub T);
+
+impl<T: Copy> Copy for NonZero<T> {}
+
 /// Creates a null raw pointer.
 ///
 /// # Examples
@@ -313,6 +323,32 @@ impl<T> RawPtr<T> for *const T {
     }
 }
 
+impl<T> RawPtr<T> for NonZero<*const T> {
+    #[inline]
+    fn null() -> NonZero<*const T> { NonZero(null()) }
+
+    #[inline]
+    fn is_null(&self) -> bool { false }
+
+    #[inline]
+    fn to_uint(&self) -> uint {
+        let NonZero(p) = *self;
+        p as uint
+    }
+
+    #[inline]
+    unsafe fn offset(self, count: int) -> NonZero<*const T> {
+        let NonZero(p) = self;
+        NonZero(intrinsics::offset(p, count))
+    }
+
+    #[inline]
+    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+        let NonZero(p) = *self;
+        Some(&*p)
+    }
+}
+
 impl<T> RawPtr<T> for *mut T {
     #[inline]
     fn null() -> *mut T { null_mut() }
@@ -338,6 +374,32 @@ impl<T> RawPtr<T> for *mut T {
     }
 }
 
+impl<T> RawPtr<T> for NonZero<*mut T> {
+    #[inline]
+    fn null() -> NonZero<*mut T> { NonZero(null_mut()) }
+
+    #[inline]
+    fn is_null(&self) -> bool { false }
+
+    #[inline]
+    fn to_uint(&self) -> uint {
+        let NonZero(p) = *self;
+        p as uint
+    }
+
+    #[inline]
+    unsafe fn offset(self, count: int) -> NonZero<*mut T> {
+        let NonZero(p) = self;
+        NonZero(intrinsics::offset(p as *const T, count) as *mut T)
+    }
+
+    #[inline]
+    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+        let NonZero(p) = *self;
+        Some(&*p)
+    }
+}
+
 impl<T> RawMutPtr<T> for *mut T {
     #[inline]
     unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
@@ -349,6 +411,14 @@ impl<T> RawMutPtr<T> for *mut T {
     }
 }
 
+impl<T> RawMutPtr<T> for NonZero<*mut T> {
+    #[inline]
+    unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
+        let NonZero(p) = *self;
+        Some(&mut *p)
+    }
+}
+
 // Equality for pointers
 impl<T> PartialEq for *const T {
     #[inline]