Move Irrlicht to src/others.

author: David Walter Seikel 2016-03-28 22:28:34 +1000
committer: David Walter Seikel 2016-03-28 22:28:34 +1000
commit: 7028cbe09c688437910a25623098762bf0fa592d (patch)
tree: 10b5af58277d9880380c2251f109325542c4e6eb /src/others/irrlicht-1.8.1/include/irrAllocator.h
parent: Move lemon to the src/others directory. (diff)
download: SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.zip
SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.gz
SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.bz2
SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.xz
1 files changed, 124 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/irrAllocator.h b/src/others/irrlicht-1.8.1/include/irrAllocator.h
new file mode 100644
index 0000000..648c410
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/irrAllocator.h
@@ -0,0 +1,124 @@
+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
+#ifndef __IRR_ALLOCATOR_H_INCLUDED__
+#define __IRR_ALLOCATOR_H_INCLUDED__
+#include "irrTypes.h"
+#include <new>
+// necessary for older compilers
+#include <memory.h>
+namespace irr
+{
+namespace core
+{
+#ifdef DEBUG_CLIENTBLOCK
+#undef DEBUG_CLIENTBLOCK
+#define DEBUG_CLIENTBLOCK new
+#endif
+//! Very simple allocator implementation, containers using it can be used across dll boundaries
+template<typename T>
+class irrAllocator
+{
+public:
+        //! Destructor
+        virtual ~irrAllocator() {}
+        //! Allocate memory for an array of objects
+        T* allocate(size_t cnt)
+        {
+                return (T*)internal_new(cnt* sizeof(T));
+        }
+        //! Deallocate memory for an array of objects
+        void deallocate(T* ptr)
+        {
+                internal_delete(ptr);
+        }
+        //! Construct an element
+        void construct(T* ptr, const T&e)
+        {
+                new ((void*)ptr) T(e);
+        }
+        //! Destruct an element
+        void destruct(T* ptr)
+        {
+                ptr->~T();
+        }
+protected:
+        virtual void* internal_new(size_t cnt)
+        {
+                return operator new(cnt);
+        }
+        virtual void internal_delete(void* ptr)
+        {
+                operator delete(ptr);
+        }
+};
+//! Fast allocator, only to be used in containers inside the same memory heap.
+/** Containers using it are NOT able to be used it across dll boundaries. Use this
+when using in an internal class or function or when compiled into a static lib */
+template<typename T>
+class irrAllocatorFast
+{
+public:
+        //! Allocate memory for an array of objects
+        T* allocate(size_t cnt)
+        {
+                return (T*)operator new(cnt* sizeof(T));
+        }
+        //! Deallocate memory for an array of objects
+        void deallocate(T* ptr)
+        {
+                operator delete(ptr);
+        }
+        //! Construct an element
+        void construct(T* ptr, const T&e)
+        {
+                new ((void*)ptr) T(e);
+        }
+        //! Destruct an element
+        void destruct(T* ptr)
+        {
+                ptr->~T();
+        }
+};
+#ifdef DEBUG_CLIENTBLOCK
+#undef DEBUG_CLIENTBLOCK
+#define DEBUG_CLIENTBLOCK new( _CLIENT_BLOCK, __FILE__, __LINE__)
+#endif
+//! defines an allocation strategy
+enum eAllocStrategy
+{
+        ALLOC_STRATEGY_SAFE    = 0,
+        ALLOC_STRATEGY_DOUBLE  = 1,
+        ALLOC_STRATEGY_SQRT    = 2
+};
+} // end namespace core
+} // end namespace irr
+#endif
author	David Walter Seikel	2016-03-28 22:28:34 +1000
committer	David Walter Seikel	2016-03-28 22:28:34 +1000
commit	7028cbe09c688437910a25623098762bf0fa592d (patch)
tree	10b5af58277d9880380c2251f109325542c4e6eb /src/others/irrlicht-1.8.1/include/irrAllocator.h
parent	Move lemon to the src/others directory. (diff)
download	SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.zip SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.gz SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.bz2 SledjHamr-7028cbe09c688437910a25623098762bf0fa592d.tar.xz

diff --git a/src/others/irrlicht-1.8.1/include/irrAllocator.h b/src/others/irrlicht-1.8.1/include/irrAllocator.h new file mode 100644 index 0000000..648c410 --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/irrAllocator.h
@@ -0,0 +1,124 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine" and the "irrXML" project.
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
	4
	5	#ifndef __IRR_ALLOCATOR_H_INCLUDED__
	6	#define __IRR_ALLOCATOR_H_INCLUDED__
	7
	8	#include "irrTypes.h"
	9	#include <new>
	10	// necessary for older compilers
	11	#include <memory.h>
	12
	13	namespace irr
	14	{
	15	namespace core
	16	{
	17
	18	#ifdef DEBUG_CLIENTBLOCK
	19	#undef DEBUG_CLIENTBLOCK
	20	#define DEBUG_CLIENTBLOCK new
	21	#endif
	22
	23	//! Very simple allocator implementation, containers using it can be used across dll boundaries
	24	template<typename T>
	25	class irrAllocator
	26	{
	27	public:
	28
	29	//! Destructor
	30	virtual ~irrAllocator() {}
	31
	32	//! Allocate memory for an array of objects
	33	T* allocate(size_t cnt)
	34	{
	35	return (T)internal_new(cnt sizeof(T));
	36	}
	37
	38	//! Deallocate memory for an array of objects
	39	void deallocate(T* ptr)
	40	{
	41	internal_delete(ptr);
	42	}
	43
	44	//! Construct an element
	45	void construct(T* ptr, const T&e)
	46	{
	47	new ((void*)ptr) T(e);
	48	}
	49
	50	//! Destruct an element
	51	void destruct(T* ptr)
	52	{
	53	ptr->~T();
	54	}
	55
	56	protected:
	57
	58	virtual void* internal_new(size_t cnt)
	59	{
	60	return operator new(cnt);
	61	}
	62
	63	virtual void internal_delete(void* ptr)
	64	{
	65	operator delete(ptr);
	66	}
	67
	68	};
	69
	70
	71	//! Fast allocator, only to be used in containers inside the same memory heap.
	72	/** Containers using it are NOT able to be used it across dll boundaries. Use this
	73	when using in an internal class or function or when compiled into a static lib */
	74	template<typename T>
	75	class irrAllocatorFast
	76	{
	77	public:
	78
	79	//! Allocate memory for an array of objects
	80	T* allocate(size_t cnt)
	81	{
	82	return (T)operator new(cnt sizeof(T));
	83	}
	84
	85	//! Deallocate memory for an array of objects
	86	void deallocate(T* ptr)
	87	{
	88	operator delete(ptr);
	89	}
	90
	91	//! Construct an element
	92	void construct(T* ptr, const T&e)
	93	{
	94	new ((void*)ptr) T(e);
	95	}
	96
	97	//! Destruct an element
	98	void destruct(T* ptr)
	99	{
	100	ptr->~T();
	101	}
	102	};
	103
	104
	105
	106	#ifdef DEBUG_CLIENTBLOCK
	107	#undef DEBUG_CLIENTBLOCK
	108	#define DEBUG_CLIENTBLOCK new( _CLIENT_BLOCK, __FILE__, __LINE__)
	109	#endif
	110
	111	//! defines an allocation strategy
	112	enum eAllocStrategy
	113	{
	114	ALLOC_STRATEGY_SAFE = 0,
	115	ALLOC_STRATEGY_DOUBLE = 1,
	116	ALLOC_STRATEGY_SQRT = 2
	117	};
	118
	119
	120	} // end namespace core
	121	} // end namespace irr
	122
	123	#endif
	124