Initial commit

1 files changed, 113 insertions, 0 deletions

diff --git a/Minecraft.Client/Common/C4JMemoryPoolAllocator.h b/Minecraft.Client/Common/C4JMemoryPoolAllocator.h
new file mode 100644
index 00000000..a46cc76d
--- /dev/null
+++ b/Minecraft.Client/Common/C4JMemoryPoolAllocator.h
@@ -0,0 +1,113 @@
+
+
+#pragma once
+#include "..\Minecraft.Client\Common\C4JMemoryPool.h"
+
+// Custom allocator, takes a C4JMemoryPool class, which can be one of a number of pool implementations.
+
+template <class T>
+class C4JPoolAllocator
+{
+public:
+    typedef T          value_type;
+    typedef size_t     size_type;
+    typedef ptrdiff_t  difference_type;
+ 
+    typedef T*         pointer;
+    typedef const T*   const_pointer;
+ 
+    typedef T&         reference;
+    typedef const T&   const_reference;
+ 
+	//! A struct to construct an allocator for a different type.
+	template<typename U> 
+	struct rebind { typedef C4JPoolAllocator<U> other; };
+
+
+	C4JMemoryPool*	m_pPool;
+	bool			m_selfAllocated;
+
+	C4JPoolAllocator( C4JMemoryPool* pool = new C4JMemoryPoolFixed(32, 4096 )) : m_pPool( pool ), m_selfAllocated(true) 
+	{
+		printf("allocated mempool\n");
+	}
+
+	template<typename U>
+	C4JPoolAllocator(C4JPoolAllocator<U> const& obj) : m_pPool( obj.m_pPool ), m_selfAllocated(false) // copy constructor
+    {
+		printf("C4JPoolAllocator constructed from 0x%08x\n", &obj);
+		assert(obj.m_pPool);
+    }
+private:
+
+public:
+  
+    ~C4JPoolAllocator()
+    {
+		if(m_selfAllocated)
+			delete m_pPool;
+    }
+ 
+    pointer address( reference r ) const				{ return &r; }
+    const_pointer address( const_reference r ) const    { return &r; }
+ 
+    pointer allocate( size_type n, const void* /*hint*/=0 )
+    {
+		assert(m_pPool);
+        return (pointer)m_pPool->Alloc(n * sizeof(T));
+    }
+ 
+    void deallocate( pointer p, size_type /*n*/ )
+    {
+		assert(m_pPool);
+		m_pPool->Free(p);
+    }
+ 
+    void construct( pointer p, const T& val )
+    {
+        new (p) T(val);
+    }
+ 
+    void destroy( pointer p )
+    {
+        p->~T();
+    }
+ 
+    size_type max_size() const
+    {
+        return ULONG_MAX / sizeof(T);
+    }
+ 
+};
+ 
+ 
+template <class T>
+bool
+operator==( const C4JPoolAllocator<T>& left, const C4JPoolAllocator<T>& right )
+{
+	if (left.m_pPool == right.m_pPool)
+    {
+        return true;
+    }
+	return false;
+}
+ 
+template <class T>
+bool
+operator!=( const C4JPoolAllocator<T>& left, const C4JPoolAllocator<T>& right)
+{
+     if (left.m_pPool != right.m_pPool)
+     {
+         return true;
+     }
+    return false;
+}
+
+ 
+
+
+
+
+
+
+