StlWrapper.hpp #1

#pragma once

#include "PoolAllocator.hpp"
#include <memory>

#ifdef _WIN32
#	include <xstddef>
#endif

namespace sprawl
{
	namespace memory
	{
		template<typename T, typename allocator=PoolAllocator<sizeof(T)> >
		class StlWrapper
		{
		public:
			typedef StlWrapper<T, allocator> other;

			typedef T value_type;

			typedef T* pointer;
			typedef const T* const_pointer;
			typedef T& reference;
			typedef T const& const_reference;

			typedef size_t size_type;
			typedef ptrdiff_t difference_type;

#ifdef _WIN32
#	if _HAS_CPP0X
			typedef std::false_type propagate_on_container_copy_assignment;
			typedef std::false_type propagate_on_container_move_assignment;
			typedef std::false_type propagate_on_container_swap;

			StlWrapper<T, allocator> select_on_container_copy_construction() const
			{	// return this allocator
				return (*this);
			}
#	endif
#endif

			template<class T2>
			struct rebind
			{
				typedef StlWrapper<T2, typename allocator::template rebind<T2>::otherAllocator> other;
			};

			value_type* address(value_type& val) const
			{
				return reinterpret_cast<value_type*>(&reinterpret_cast<char&>(val));
			}

			StlWrapper()
			{
				//
			}

			StlWrapper(StlWrapper<value_type> const& /*other*/)
			{
				//
			}

			template<class T2, class alloc>
			StlWrapper(const StlWrapper<T2, alloc>& /*other*/)
			{
				//
			}

			template<class T2>
			StlWrapper<value_type>& operator=(StlWrapper<T2> const& /*other*/)
			{
				return (*this);
			}

			bool operator==(const StlWrapper<value_type, allocator>& /*other*/) const
			{
				return true;
			}

			bool operator!=(const StlWrapper<value_type, allocator>& /*other*/) const
			{
				return false;
			}

			template<typename otherAllocator>
			bool operator==(const StlWrapper<value_type, otherAllocator>& /*other*/) const
			{
				return false;
			}

			template<typename otherAllocator>
			bool operator!=(const StlWrapper<value_type, otherAllocator>& /*other*/) const
			{
				return true;
			}

			void deallocate(value_type* ptr, size_type /*unused*/)
			{
				allocator::free(ptr);
			}

			value_type* allocate(size_type count)
			{
				if(count == 1)
				{
					return (value_type*)(allocator::alloc());
				}
				return (value_type*)(allocator::alloc(count));
			}

			value_type* allocate(size_type count, const void* /*unused*/)
			{
				return (value_type*)(allocate(count));
			}

			void construct(value_type* ptr)
			{
				::new ((void *)ptr) T();
			}

			void construct(value_type* ptr, value_type const& other)
			{
				::new ((void *)ptr) T(other);
			}

			template< typename T2, typename... Args >
			void construct( T2* ptr, Args&&... args )
			{
				::new ((void*)ptr) T2(std::forward<Args>(args)...);
			}

			template<class T2>
			void destroy(T2* ptr)
			{
				(void)(ptr);
				ptr->~T2();
			}

			size_t max_size() const
			{
				return ((size_t)(-1) / sizeof (T));
			}
		};
	}
}