ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreMemoryNedAlloc.h

@@ -1,140 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __MemoryNedAlloc_H__
-#define __MemoryNedAlloc_H__
-
-#if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NED
-
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Memory
-	*  @{
-	*/
-	/** Non-templated utility class just to hide nedmalloc.
-	*/
-	class _OgreExport NedAllocImpl
-	{
-	public:
-		static void* allocBytes(size_t count, 
-			const char* file, int line, const char* func);
-		static void deallocBytes(void* ptr);
-		static void* allocBytesAligned(size_t align, size_t count, 
-			const char* file, int line, const char* func);
-		static void deallocBytesAligned(size_t align, void* ptr);
-
-	};
-
-	/**	An allocation policy for use with AllocatedObject and 
-	STLAllocator. This is the class that actually does the allocation
-	and deallocation of physical memory, and is what you will want to 
-	provide a custom version of if you wish to change how memory is allocated.
-	@par
-	This allocation policy uses nedmalloc 
-		(http://nedprod.com/programs/portable/nedmalloc/index.html). 
-	*/
-	class _OgreExport NedAllocPolicy
-	{
-	public:
-		static inline void* allocateBytes(size_t count, 
-			const char* file = 0, int line = 0, const char* func = 0)
-		{
-			return NedAllocImpl::allocBytes(count, file, line, func);
-		}
-		static inline void deallocateBytes(void* ptr)
-		{
-			NedAllocImpl::deallocBytes(ptr);
-		}
-		/// Get the maximum size of a single allocation
-		static inline size_t getMaxAllocationSize()
-		{
-			return std::numeric_limits<size_t>::max();
-		}
-	private:
-		// No instantiation
-		NedAllocPolicy()
-		{ }
-	};
-
-
-	/**	An allocation policy for use with AllocatedObject and 
-	STLAllocator, which aligns memory at a given boundary (which should be
-	a power of 2). This is the class that actually does the allocation
-	and deallocation of physical memory, and is what you will want to 
-	provide a custom version of if you wish to change how memory is allocated.
-	@par
-	This allocation policy uses nedmalloc 
-		(http://nedprod.com/programs/portable/nedmalloc/index.html). 
-	@note
-		template parameter Alignment equal to zero means use default
-		platform dependent alignment.
-	*/
-	template <size_t Alignment = 0>
-	class NedAlignedAllocPolicy
-	{
-	public:
-		// compile-time check alignment is available.
-		typedef int IsValidAlignment
-			[Alignment <= 128 && ((Alignment & (Alignment-1)) == 0) ? +1 : -1];
-
-		static inline void* allocateBytes(size_t count, 
-			const char* file = 0, int line = 0, const char* func = 0)
-		{
-			return NedAllocImpl::allocBytesAligned(Alignment, count, file, line, func);
-		}
-
-		static inline void deallocateBytes(void* ptr)
-		{
-			NedAllocImpl::deallocBytesAligned(Alignment, ptr);
-		}
-
-		/// Get the maximum size of a single allocation
-		static inline size_t getMaxAllocationSize()
-		{
-			return std::numeric_limits<size_t>::max();
-		}
-	private:
-		// no instantiation allowed
-		NedAlignedAllocPolicy()
-		{ }
-	};
-
-
-
-	/** @} */
-	/** @} */
-
-}// namespace Ogre
-
-#endif 
-
-#endif // __MemoryNedAlloc_H__
-

data/deps/include/OGRE/OgreMemoryNedPooling.h

@@ -1,143 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-
-#ifndef __MemoryNedPooling_H__
-#define __MemoryNedPooling_H__
-
-#if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NEDPOOLING
-
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Memory
-	*  @{
-	*/
-	/** Non-templated utility class just to hide nedmalloc.
-	*/
-	class _OgreExport NedPoolingImpl
-	{
-	public:
-		static void* allocBytes(size_t count, 
-			const char* file, int line, const char* func);
-		static void deallocBytes(void* ptr);
-		static void* allocBytesAligned(size_t align, size_t count, 
-			const char* file, int line, const char* func);
-		static void deallocBytesAligned(size_t align, void* ptr);
-
-	};
-
-	/**	An allocation policy for use with AllocatedObject and 
-	STLAllocator. This is the class that actually does the allocation
-	and deallocation of physical memory, and is what you will want to 
-	provide a custom version of if you wish to change how memory is allocated.
-	@par
-	This allocation policy uses nedmalloc 
-		(http://nedprod.com/programs/portable/nedmalloc/index.html). 
-	*/
-	class _OgreExport NedPoolingPolicy
-	{
-	public:
-		static inline void* allocateBytes(size_t count, 
-			const char* file = 0, int line = 0, const char* func = 0)
-		{
-			return NedPoolingImpl::allocBytes(count, file, line, func);
-		}
-		static inline void deallocateBytes(void* ptr)
-		{
-			NedPoolingImpl::deallocBytes(ptr);
-		}
-		/// Get the maximum size of a single allocation
-		static inline size_t getMaxAllocationSize()
-		{
-			return std::numeric_limits<size_t>::max();
-		}
-
-	private:
-		// No instantiation
-		NedPoolingPolicy()
-		{ }
-	};
-
-
-	/**	An allocation policy for use with AllocatedObject and 
-	STLAllocator, which aligns memory at a given boundary (which should be
-	a power of 2). This is the class that actually does the allocation
-	and deallocation of physical memory, and is what you will want to 
-	provide a custom version of if you wish to change how memory is allocated.
-	@par
-	This allocation policy uses nedmalloc 
-		(http://nedprod.com/programs/portable/nedmalloc/index.html). 
-	@note
-		template parameter Alignment equal to zero means use default
-		platform dependent alignment.
-	*/
-	template <size_t Alignment = 0>
-	class NedPoolingAlignedPolicy
-	{
-	public:
-		// compile-time check alignment is available.
-		typedef int IsValidAlignment
-			[Alignment <= 128 && ((Alignment & (Alignment-1)) == 0) ? +1 : -1];
-
-		static inline void* allocateBytes(size_t count, 
-			const char* file = 0, int line = 0, const char* func = 0)
-		{
-			return NedPoolingImpl::allocBytesAligned(Alignment, count, file, line, func);
-		}
-
-		static inline void deallocateBytes(void* ptr)
-		{
-			NedPoolingImpl::deallocBytesAligned(Alignment, ptr);
-		}
-
-		/// Get the maximum size of a single allocation
-		static inline size_t getMaxAllocationSize()
-		{
-			return std::numeric_limits<size_t>::max();
-		}
-	private:
-		// no instantiation allowed
-		NedPoolingAlignedPolicy()
-		{ }
-	};
-
-
-
-
-	/** @} */
-	/** @} */
-
-}// namespace Ogre
-
-#endif 
-
-#endif // __MemoryNedPooling_H__
-

data/deps/include/OGRE/OgreMemorySTLAllocator.h

@@ -1,225 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef _MemorySTLAllocator_H__
-#define _MemorySTLAllocator_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreHeaderPrefix.h"
-
-namespace Ogre
-{
-
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Memory
-	*  @{
-	*/
-	/**
-	Wrapper class for operating as an STL container allocator.
-	This class acts as the host for a configured allocation policy.
-
-	It takes the following template parameters:-
-	<ul>
-	<li>T			: the type we will be allocating (see rebind later)</li>
-	<li>AllocPolicy : a memory allocator policy </li>
-	</ul>
-
-	See StdAllocPolicy for an example of implementing a Policy. The reason for
-	implementing the allocation in a policy is that it makes implementing
-	a custom allocator easier -  you just have to provide an alternative
-	policy with just allocate/deallocate implementations; this class does all the
-	housekeeping associated with keeping the STL happy.
-	*/
-
-	// Base STL allocator class.
-	template<typename T>
-	struct STLAllocatorBase
-	{	// base class for generic allocators
-		typedef T value_type;
-	};
-
-	// Base STL allocator class. (const T version).
-	template<typename T>
-	struct STLAllocatorBase<const T>
-	{	// base class for generic allocators for const T
-		typedef T value_type;
-	};
-
-	template
-		<
-		typename T,
-		typename AllocPolicy
-		>
-	class STLAllocator : public STLAllocatorBase<T>
-	{
-	public :
-		/// define our types, as per ISO C++
-		typedef STLAllocatorBase<T>			Base;
-		typedef typename Base::value_type	value_type;
-		typedef value_type*					pointer;
-		typedef const value_type*			const_pointer;
-		typedef value_type&					reference;
-		typedef const value_type&			const_reference;
-		typedef std::size_t					size_type;
-		typedef std::ptrdiff_t				difference_type;
-
-
-		/// the standard rebind mechanism
-		template<typename U>
-		struct rebind
-		{
-			typedef STLAllocator<U, AllocPolicy> other;
-		};
-
-		/// ctor
-		inline explicit STLAllocator()
-		{ }
-
-		/// dtor
-		virtual ~STLAllocator()
-		{ }
-
-		/// copy ctor - done component wise
-		inline STLAllocator( STLAllocator const& )
-		{ }
-
-		/// cast
-		template <typename U>
-		inline STLAllocator( STLAllocator<U, AllocPolicy> const& )
-		{ }
-
-		/// cast
-		template <typename U, typename P>
-		inline STLAllocator( STLAllocator<U, P> const& )
-		{ }
-
-		/// memory allocation (elements, used by STL)
-		inline pointer allocate( size_type count,
-			typename std::allocator<void>::const_pointer ptr = 0 )
-		{
-                        (void)ptr;
-			// convert request to bytes
-			register size_type sz = count*sizeof( T );
-			pointer p  = static_cast<pointer>(AllocPolicy::allocateBytes(sz));
-			return p;
-		}
-
-		/// memory deallocation (elements, used by STL)
-		inline void deallocate( pointer ptr, size_type )
-		{
-			// convert request to bytes, but we can't use this?
-			// register size_type sz = count*sizeof( T );
-			AllocPolicy::deallocateBytes(ptr);
-		}
-
-		pointer address(reference x) const
-		{
-			return &x;
-		}
-
-		const_pointer address(const_reference x) const
-		{
-			return &x;
-		}
-
-		size_type max_size() const throw()
-		{
-			// maximum size this can handle, delegate
-			return AllocPolicy::getMaxAllocationSize();
-		}
-
-		void construct(pointer p)
-		{
-			// call placement new
-			new(static_cast<void*>(p)) T();
-		}
-
-		void construct(pointer p, const T& val)
-		{
-			// call placement new
-			new(static_cast<void*>(p)) T(val);
-		}
-
-		void destroy(pointer p)
-		{
-			// do we have to protect against non-classes here?
-			// some articles suggest yes, some no
-			p->~T();
-		}
-
-	};
-
-	/// determine equality, can memory from another allocator
-	/// be released by this allocator, (ISO C++)
-	template<typename T, typename T2, typename P>
-	inline bool operator==(STLAllocator<T,P> const&,
-		STLAllocator<T2,P> const&)
-	{
-		// same alloc policy (P), memory can be freed
-		return true;
-	}
-
-	/// determine equality, can memory from another allocator
-	/// be released by this allocator, (ISO C++)
-	template<typename T, typename P, typename OtherAllocator>
-	inline bool operator==(STLAllocator<T,P> const&,
-		OtherAllocator const&)
-	{
-		return false;
-	}
-	/// determine equality, can memory from another allocator
-	/// be released by this allocator, (ISO C++)
-	template<typename T, typename T2, typename P>
-	inline bool operator!=(STLAllocator<T,P> const&,
-		STLAllocator<T2,P> const&)
-	{
-		// same alloc policy (P), memory can be freed
-		return false;
-	}
-
-	/// determine equality, can memory from another allocator
-	/// be released by this allocator, (ISO C++)
-	template<typename T, typename P, typename OtherAllocator>
-	inline bool operator!=(STLAllocator<T,P> const&,
-		OtherAllocator const&)
-	{
-		return true;
-	}
-
-
-	/** @} */
-	/** @} */
-
-}// namespace Ogre
-
-#include "OgreHeaderSuffix.h"
-#endif // _MemorySTLAllocator_H__
-