GEEKING

Base/include/rbx/BaldPtr.h

@@ -0,0 +1,187 @@
+/**
+ * BaldPtr.h
+ * Copyright (c) 2013 ROBLOX Corp. All Rights Reserved.
+ */
+
+#pragma once
+
+#include "rbx/Debug.h"
+
+namespace RBX
+{
+
+/**
+ * Wraps raw pointers with a layer of protection in debug builds.
+ * Checks for bad pointers on access.
+ */
+template<class T>
+class BaldPtr
+{
+public:
+
+    /**
+     * Constructor.
+     *  Sets pointer to NULL.
+     */
+    inline BaldPtr() 
+        : mPointer(NULL)
+    {}
+
+	/**
+	 * Constructor.
+	 *  Pointer is also validated.
+	 *
+	 * @param	Pointer     pointer to wrap, may be NULL
+	 */
+	inline BaldPtr(T* Pointer)
+        : mPointer(Pointer) 
+    {
+        validate();
+	}
+
+	/**
+	 * Shallow copies pointer.
+	 *  Pointer is validated.
+	 *
+	 * @param	Pointer     pointer to copy, may be NULL
+	 * @return  this pointer
+	 */
+	inline T*& operator=(T* Pointer) 
+    {
+		mPointer = Pointer;
+		validate();
+		return mPointer;
+	}
+
+    /**
+     * Dereference operator.
+     *  Checks for NULL and validates.
+     *
+     * @return  reference to pointer
+     */
+    inline T& operator*() const
+    {
+		RBXASSERT_VERY_FAST(mPointer);
+        validate();
+		return *mPointer;
+	}
+
+    /**
+     * Class pointer cast.
+     *  Validates pointer.
+     *
+     * @return  pointer cast to a class *, may be NULL
+     */
+    inline operator T*() const
+    {
+		validate();
+		return mPointer;
+	}
+
+	/**
+	 * Arrow operator that checks and returns the pointer.
+	 *  Checks for NULL and validates.
+	 *
+	 * @return  data pointer
+	 */
+	inline T* operator->() const
+    {
+		RBXASSERT_VERY_FAST(mPointer);
+		validate();
+		return mPointer;
+	}
+
+    /**
+     * Get the raw pointer value.
+     *  Performs no checks.
+     *
+     * @return  data pointer, may be NULL
+     */
+    inline T* get() const { return mPointer; }
+
+	/**
+	 * Validates the pointer.
+	 *  Various memory patterns are checked such as fence posts, 
+	 *  deleted, and allocated memory.  Standard CRT patterns are
+	 *  checked as well as Ogre patterns.
+	 *
+	 * @return 	description
+	 */
+	inline void validate() const
+    {
+#ifdef __RBX_VERY_FAST_ASSERT
+        if ( !mPointer )
+            return;
+#endif
+
+		RBXASSERT_VERY_FAST(
+            // CRT debug allocator
+            (unsigned)mPointer != 0xCCCCCCCC &&     // uninitialized stack memory
+		    (unsigned)mPointer != 0xCDCDCDCD &&     // uninitialized heap memory
+		    (unsigned)mPointer != 0xFDFDFDFD &&     // "no man's land" guard bytes before and after allocated heap memory
+		    (unsigned)mPointer != 0xDDDDDDDD &&     // deleted heap memory
+            (unsigned)mPointer != 0xFEEEFEEE &&     // deleted heap memory
+
+            // Ogre allocator
+            (unsigned)mPointer != 0xBAADF00D &&     // before "no man's land" guard bytes
+            (unsigned)mPointer != 0xDEADC0DE &&     // after "no man's land" guard bytes
+            (unsigned)mPointer != 0xFEEDFACE &&     // uninitialized memory
+            (unsigned)mPointer != 0xDEADBEEF  );    // deleted memory
+	}
+
+private:
+
+    T* mPointer;
+};
+
+}
+
+// struct Foo
+// {
+// 	int x;
+// };
+// 
+// template<typename Ptr>
+// void test()
+// {
+// 	Ptr f = new Foo();
+// 	Foo* f2 = f;
+// 	f->x = 23;
+// 	(*f).x = 32;
+// 	void* v = f;
+// 	BaldPtr<Foo> b = f;
+// 	BaldPtr<Foo> b2(f);
+// 	const void* vc = f;
+// 
+// 	delete f;
+// }
+// 
+// template<typename Ptr>
+// void testConst()
+// {
+// 	Ptr f = new Foo();
+// 	const Foo* f2 = f;
+// 	int x = f->x;
+// 	int y = (*f).x;
+// 	const void* v = f;
+// 	BaldPtr<const Foo> b = f;
+// 	BaldPtr<const Foo> b2(f);
+// 
+// 	delete f;
+// }
+// 
+// int _tmain(int argc, _TCHAR* argv[])
+// {
+// 	test<BaldPtr<Foo> const>();
+// 	test<Foo* const>();
+// 	test<BaldPtr<Foo> >();
+// 	test<Foo* >();
+// 
+// 	testConst<BaldPtr<const Foo> const>();
+// 	testConst<const Foo* const>();
+// 	testConst<BaldPtr<const Foo> >();
+// 	testConst<const Foo* >();
+// 
+// 	return 0;
+// }
+