+++ /dev/null
-/*
-Copyright (C) 2001-2006, William Joseph.
-All Rights Reserved.
-
-This file is part of GtkRadiant.
-
-GtkRadiant is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-GtkRadiant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#if !defined(INCLUDED_MEMORY_ALLOCATOR_H)
-#define INCLUDED_MEMORY_ALLOCATOR_H
-
-#include <memory>
-
-#if 0
-
-#define DefaultAllocator std::allocator
-
-#else
-
-/// \brief An allocator that uses c++ new/delete.
-/// Compliant with the std::allocator interface.
-template<typename Type>
-class DefaultAllocator
-{
-public:
-
- typedef Type value_type;
- typedef value_type* pointer;
- typedef const Type* const_pointer;
- typedef Type& reference;
- typedef const Type& const_reference;
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
-
- template<typename Other>
- struct rebind
- {
- typedef DefaultAllocator<Other> other;
- };
-
- DefaultAllocator()
- {
- }
- DefaultAllocator(const DefaultAllocator<Type>&)
- {
- }
- template<typename Other> DefaultAllocator(const DefaultAllocator<Other>&)
- {
- }
- ~DefaultAllocator()
- {
- }
-
- pointer address(reference instance) const
- {
- return &instance;
- }
- const_pointer address(const_reference instance) const
- {
- return &instance;
- }
- Type* allocate(size_type size, const void* = 0)
- {
- return static_cast<Type*>(::operator new(size * sizeof(Type)));
- }
- void deallocate(pointer p, size_type)
- {
- ::operator delete(p);
- }
- size_type max_size() const
- {
- return std::size_t(-1) / sizeof (Type);
- }
- void construct(pointer p, const Type& value)
- {
- new(p) Type(value);
- }
- void destroy(pointer p)
- {
- p->~Type();
- }
-};
-
-template<typename Type, typename Other>
-inline bool operator==(const DefaultAllocator<Type>&, const DefaultAllocator<Other>&)
-{
- return true;
-}
-template<typename Type, typename OtherAllocator>
-inline bool operator==(const DefaultAllocator<Type>&, const OtherAllocator&)
-{
- return false;
-}
-
-#endif
-
-
-template<typename Type>
-class NamedAllocator : public DefaultAllocator<Type>
-{
- typedef DefaultAllocator<Type> allocator_type;
-
- const char* m_name;
-public:
-
- typedef Type value_type;
- typedef value_type* pointer;
- typedef const Type* const_pointer;
- typedef Type& reference;
- typedef const Type& const_reference;
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
-
- template<typename Other>
- struct rebind
- {
- typedef NamedAllocator<Other> other;
- };
-
- explicit NamedAllocator(const char* name) : m_name(name)
- {
- }
- NamedAllocator(const NamedAllocator<Type>& other) : m_name(other.m_name)
- {
- }
- template<typename Other> NamedAllocator(const NamedAllocator<Other>& other) : m_name(other.m_name)
- {
- }
- ~NamedAllocator()
- {
- }
-
- pointer address(reference instance) const
- {
- return allocator_type::address(instance);
- }
- const_pointer address(const_reference instance) const
- {
- return allocator_type::address(instance);
- }
- Type* allocate(size_type size, const void* = 0)
- {
- return allocator_type::allocate(size);
- }
- void deallocate(pointer p, size_type size)
- {
- allocator_type::deallocate(p, size);
- }
- size_type max_size() const
- {
- return allocator_type::max_size();
- }
- void construct(pointer p, const Type& value)
- {
- allocator_type::construct(p, value);
- }
- void destroy(pointer p)
- {
- allocator_type::destroy(p);
- }
-
- template<typename Other>
- bool operator==(const NamedAllocator<Other>& other)
- {
- return true;
- }
-
- // returns true if the allocators are not interchangeable
- template<typename Other>
- bool operator!=(const NamedAllocator<Other>& other)
- {
- return false;
- }
-};
-
-
-
-#include <algorithm>
-#include "generic/object.h"
-
-
-
-template<typename Type>
-class DefaultConstruct
-{
-public:
- void operator()(Type& t)
- {
- constructor(t);
- }
-};
-
-template<typename Type, typename T1>
-class Construct
-{
- const T1& other;
-public:
- Construct(const T1& other_) : other(other_)
- {
- }
- void operator()(Type& t)
- {
- constructor(t, other);
- }
-};
-
-template<typename Type>
-class Destroy
-{
-public:
- void operator()(Type& t)
- {
- destructor(t);
- }
-};
-
-template<typename Type, typename Allocator = DefaultAllocator<Type> >
-class New : public Allocator
-{
-public:
- New()
- {
- }
- explicit New(const Allocator& allocator) : Allocator(allocator)
- {
- }
-
- Type* scalar()
- {
- return new(Allocator::allocate(1)) Type();
- }
- template<typename T1>
- Type* scalar(const T1& t1)
- {
- return new(Allocator::allocate(1)) Type(t1);
- }
- template<typename T1, typename T2>
- Type* scalar(const T1& t1, const T2& t2)
- {
- return new(Allocator::allocate(1)) Type(t1, t2);
- }
- template<typename T1, typename T2, typename T3>
- Type* scalar(const T1& t1, const T2& t2, const T3& t3)
- {
- return new(Allocator::allocate(1)) Type(t1, t2, t3);
- }
- template<typename T1, typename T2, typename T3, typename T4>
- Type* scalar(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
- {
- return new(Allocator::allocate(1)) Type(t1, t2, t3, t4);
- }
- template<typename T1, typename T2, typename T3, typename T4, typename T5>
- Type* scalar(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
- {
- return new(Allocator::allocate(1)) Type(t1, t2, t3, t4, t5);
- }
- Type* vector(std::size_t size)
- {
-#if 1
- Type* p = Allocator::allocate(size);
- std::for_each(p, p + size, DefaultConstruct<Type>());
- return p;
-#else
- // this does not work with msvc71 runtime
- return new(Allocator::allocate(size)) Type[size];
-#endif
- }
- template<typename T1>
- Type* vector(std::size_t size, const T1& t1)
- {
- Type* p = Allocator::allocate(size);
- std::for_each(p, p + size, Construct<Type, T1>(t1));
- return p;
- }
-};
-
-template<typename Type, typename Allocator = DefaultAllocator<Type> >
-class Delete : public Allocator
-{
-public:
- Delete()
- {
- }
- explicit Delete(const Allocator& allocator) : Allocator(allocator)
- {
- }
-
- void scalar(Type* p)
- {
- if(p != 0)
- {
- p->~Type();
- Allocator::deallocate(p, 1);
- }
- }
- void vector(Type* p, std::size_t size)
- {
- // '::operator delete' handles null
- // 'std::allocator::deallocate' requires non-null
- if(p != 0)
- {
- std::for_each(p, p + size, Destroy<Type>());
- Allocator::deallocate(p, size);
- }
- }
-};
-
-
-template<typename Type>
-class NamedNew
-{
-public:
- typedef New<Type, NamedAllocator<Type> > type;
-};
-
-template<typename Type>
-class NamedDelete
-{
-public:
- typedef Delete<Type, NamedAllocator<Type> > type;
-};
-
-#endif
projects / voretournament / voretournament.git / blobdiff