mirror of
https://github.com/id-Software/GtkRadiant.git
synced 2026-03-20 00:49:29 +01:00
The GtkRadiant sources as originally released under the GPL license.
This commit is contained in:
Travis Bradshaw
80
libs/memory/allocator.cpp
Normal file
80
libs/memory/allocator.cpp
Normal file
@@ -0,0 +1,80 @@
|
||||
/*
|
||||
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
|
||||
*/
|
||||
|
||||
#include "memory/allocator.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
template<typename Value>
|
||||
struct Vector
|
||||
{
|
||||
typedef std::vector<Value, DefaultAllocator<Value> > Type;
|
||||
};
|
||||
|
||||
namespace
|
||||
{
|
||||
class Bleh
|
||||
{
|
||||
int* m_blah;
|
||||
public:
|
||||
Bleh(int* blah) : m_blah(blah)
|
||||
{
|
||||
}
|
||||
~Bleh()
|
||||
{
|
||||
*m_blah = 15;
|
||||
}
|
||||
};
|
||||
|
||||
void TestAllocator()
|
||||
{
|
||||
Vector<Bleh>::Type test;
|
||||
|
||||
int i = 0;
|
||||
test.push_back(Bleh(&i));
|
||||
}
|
||||
|
||||
void TestNewDelete()
|
||||
{
|
||||
{
|
||||
NamedAllocator<int> allocator("test");
|
||||
int* p = NamedNew<int>::type(allocator).scalar();
|
||||
//new int();
|
||||
NamedDelete<int>::type(allocator).scalar(p);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = New<int>().scalar(3);
|
||||
Delete<int>().scalar(p);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = New<int>().scalar(int(15.9));
|
||||
Delete<int>().scalar(p);
|
||||
}
|
||||
|
||||
{
|
||||
int* p = New<int>().vector(15);
|
||||
// new int[15]
|
||||
Delete<int>().vector(p, 15);
|
||||
}
|
||||
}
|
||||
}
|
||||
336
libs/memory/allocator.h
Normal file
336
libs/memory/allocator.h
Normal file
@@ -0,0 +1,336 @@
|
||||
/*
|
||||
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
|
||||
Reference in New Issue
Block a user