mirror of
https://github.com/libretro/pcsx2.git
synced 2024-11-23 09:19:42 +00:00
common: Remove SafeList and SafeAllignedArray as unused.
This commit is contained in:
arcum42
refractionpcsx2
parent
64a6d8027b
commit
e37fff1213
@ -97,114 +97,3 @@ public:
|
||||
|
||||
virtual SafeArray<T>* Clone() const;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
// SafeList - Simple growable container without all the mess or hassle of std containers.
|
||||
//
|
||||
// This container is intended for reasonably simple class types only. Things which this
|
||||
// container does not handle with desired robustness:
|
||||
//
|
||||
// * Classes with non-trivial constructors (such that construction creates much overhead)
|
||||
// * Classes with copy constructors (copying is done using performance memcpy)
|
||||
// * Classes with destructors (they're not called, sorry!)
|
||||
//
|
||||
template <typename T>
|
||||
class SafeList
|
||||
{
|
||||
DeclareNoncopyableObject(SafeList);
|
||||
|
||||
public:
|
||||
static const int DefaultChunkSize = 0x80 * sizeof(T);
|
||||
|
||||
public:
|
||||
std::string Name; // user-assigned block name
|
||||
int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
|
||||
|
||||
protected:
|
||||
T* m_ptr;
|
||||
int m_allocsize; // size of the allocation of memory
|
||||
uint m_length; // length of the array (active items, not buffer allocation)
|
||||
|
||||
protected:
|
||||
virtual T* _virtual_realloc(int newsize);
|
||||
void _MakeRoomFor_threshold(int newsize);
|
||||
|
||||
T* _getPtr(uint i) const;
|
||||
|
||||
public:
|
||||
virtual ~SafeList();
|
||||
explicit SafeList(const char* name = "Unnamed");
|
||||
explicit SafeList(int initialSize, const char* name = "Unnamed");
|
||||
virtual SafeList<T>* Clone() const;
|
||||
|
||||
void Remove(int index);
|
||||
void MakeRoomFor(int blockSize);
|
||||
|
||||
T& New();
|
||||
int Add(const T& src);
|
||||
T& AddNew(const T& src);
|
||||
|
||||
// Returns the size of the list, as according to the array type. This includes
|
||||
// mapped items only. The actual size of the allocation may differ.
|
||||
int GetLength() const { return m_length; }
|
||||
|
||||
// Returns the size of the list, in bytes. This includes mapped items only.
|
||||
// The actual size of the allocation may differ.
|
||||
int GetSizeInBytes() const { return m_length * sizeof(T); }
|
||||
|
||||
void MatchLengthToAllocatedSize()
|
||||
{
|
||||
m_length = m_allocsize;
|
||||
}
|
||||
|
||||
void GrowBy(int items)
|
||||
{
|
||||
MakeRoomFor(m_length + ChunkSize + items + 1);
|
||||
}
|
||||
|
||||
// Sets the item length to zero. Does not free memory allocations.
|
||||
void Clear()
|
||||
{
|
||||
m_length = 0;
|
||||
}
|
||||
|
||||
// Gets an element of this memory allocation much as if it were an array.
|
||||
// DevBuilds : Generates assertion if the index is invalid.
|
||||
T& operator[](int idx) { return *_getPtr((uint)idx); }
|
||||
const T& operator[](int idx) const { return *_getPtr((uint)idx); }
|
||||
|
||||
T* GetPtr() { return m_ptr; }
|
||||
const T* GetPtr() const { return m_ptr; }
|
||||
|
||||
T& GetLast() { return m_ptr[m_length - 1]; }
|
||||
const T& GetLast() const { return m_ptr[m_length - 1]; }
|
||||
};
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
// SafeAlignedArray<T>
|
||||
// --------------------------------------------------------------------------------------
|
||||
// Handy little class for allocating a resizable memory block, complete with
|
||||
// exception-based error handling and automatic cleanup.
|
||||
// This one supports aligned data allocations too!
|
||||
|
||||
template <typename T, uint Alignment>
|
||||
class SafeAlignedArray : public SafeArray<T>
|
||||
{
|
||||
typedef SafeArray<T> _parent;
|
||||
|
||||
protected:
|
||||
T* _virtual_realloc(int newsize);
|
||||
|
||||
public:
|
||||
using _parent::operator[];
|
||||
|
||||
virtual ~SafeAlignedArray();
|
||||
|
||||
explicit SafeAlignedArray(std::string name = "Unnamed")
|
||||
: SafeArray<T>::SafeArray(name)
|
||||
{
|
||||
}
|
||||
|
||||
explicit SafeAlignedArray(int initialSize, std::string name = "Unnamed");
|
||||
virtual SafeAlignedArray<T, Alignment>* Clone() const;
|
||||
};
|
||||
|
||||
@ -123,165 +123,3 @@ SafeArray<T>* SafeArray<T>::Clone() const
|
||||
memcpy(retval->GetPtr(), m_ptr, sizeof(T) * m_size);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
// SafeAlignedArray<T> (implementations)
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
template <typename T, uint Alignment>
|
||||
T* SafeAlignedArray<T, Alignment>::_virtual_realloc(int newsize)
|
||||
{
|
||||
return (T*)((this->m_ptr == NULL) ?
|
||||
_aligned_malloc(newsize * sizeof(T), Alignment) :
|
||||
pcsx2_aligned_realloc(this->m_ptr, newsize * sizeof(T), Alignment, this->m_size * sizeof(T)));
|
||||
}
|
||||
|
||||
// Appends "(align: xx)" to the name of the allocation in devel builds.
|
||||
// Maybe useful,maybe not... no harm in attaching it. :D
|
||||
|
||||
template <typename T, uint Alignment>
|
||||
SafeAlignedArray<T, Alignment>::~SafeAlignedArray()
|
||||
{
|
||||
safe_aligned_free(this->m_ptr);
|
||||
// mptr is set to null, so the parent class's destructor won't re-free it.
|
||||
}
|
||||
|
||||
template <typename T, uint Alignment>
|
||||
SafeAlignedArray<T, Alignment>::SafeAlignedArray(int initialSize, std::string name)
|
||||
: SafeArray<T>::SafeArray(
|
||||
std::move(name),
|
||||
(T*)_aligned_malloc(initialSize * sizeof(T), Alignment),
|
||||
initialSize)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename T, uint Alignment>
|
||||
SafeAlignedArray<T, Alignment>* SafeAlignedArray<T, Alignment>::Clone() const
|
||||
{
|
||||
SafeAlignedArray<T, Alignment>* retval = new SafeAlignedArray<T, Alignment>(this->m_size);
|
||||
memcpy(retval->GetPtr(), this->m_ptr, sizeof(T) * this->m_size);
|
||||
return retval;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
// SafeList<T> (implementations)
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
template <typename T>
|
||||
T* SafeList<T>::_virtual_realloc(int newsize)
|
||||
{
|
||||
return (T*)realloc(m_ptr, newsize * sizeof(T));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
SafeList<T>::~SafeList()
|
||||
{
|
||||
safe_free(m_ptr);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
SafeList<T>::SafeList(const char* name)
|
||||
: Name(name)
|
||||
{
|
||||
ChunkSize = DefaultChunkSize;
|
||||
m_ptr = NULL;
|
||||
m_allocsize = 0;
|
||||
m_length = 0;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
SafeList<T>::SafeList(int initialSize, const char* name)
|
||||
: Name(name)
|
||||
{
|
||||
ChunkSize = DefaultChunkSize;
|
||||
m_allocsize = initialSize;
|
||||
m_length = 0;
|
||||
m_ptr = (T*)malloc(initialSize * sizeof(T));
|
||||
|
||||
if (m_ptr == NULL)
|
||||
pxFailRel("SafeList exact alloc failed");
|
||||
|
||||
for (int i = 0; i < m_allocsize; ++i)
|
||||
{
|
||||
new (&m_ptr[i]) T();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T* SafeList<T>::_getPtr(uint i) const
|
||||
{
|
||||
pxAssumeDev(i < m_length, "Index in bounds");
|
||||
return &m_ptr[i];
|
||||
}
|
||||
|
||||
// Ensures that the allocation is large enough to fit data of the
|
||||
// amount requested. The memory allocation is not resized smaller.
|
||||
template <typename T>
|
||||
void SafeList<T>::MakeRoomFor(int blockSize)
|
||||
{
|
||||
if (blockSize > m_allocsize)
|
||||
{
|
||||
const int newalloc = blockSize + ChunkSize;
|
||||
m_ptr = _virtual_realloc(newalloc);
|
||||
if (m_ptr == NULL)
|
||||
pxFailRel("SafeList MakeRoomFor failed");
|
||||
|
||||
for (; m_allocsize < newalloc; ++m_allocsize)
|
||||
{
|
||||
new (&m_ptr[m_allocsize]) T();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Appends an item to the end of the list and returns a handle to it.
|
||||
template <typename T>
|
||||
T& SafeList<T>::New()
|
||||
{
|
||||
_MakeRoomFor_threshold(m_length + 1);
|
||||
return m_ptr[m_length++];
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
int SafeList<T>::Add(const T& src)
|
||||
{
|
||||
_MakeRoomFor_threshold(m_length + 1);
|
||||
m_ptr[m_length] = src;
|
||||
return m_length++;
|
||||
}
|
||||
|
||||
// Same as Add, but returns the handle of the new object instead of it's array index.
|
||||
template <typename T>
|
||||
T& SafeList<T>::AddNew(const T& src)
|
||||
{
|
||||
_MakeRoomFor_threshold(m_length + 1);
|
||||
m_ptr[m_length] = src;
|
||||
return m_ptr[m_length];
|
||||
}
|
||||
|
||||
// Performs a standard array-copy removal of the given item. All items past the
|
||||
// given item are copied over.
|
||||
// DevBuilds : Generates assertion if the index is invalid.
|
||||
template <typename T>
|
||||
void SafeList<T>::Remove(int index)
|
||||
{
|
||||
pxAssert(index < m_length);
|
||||
|
||||
int copylen = m_length - index;
|
||||
if (copylen > 0)
|
||||
memcpy(&m_ptr[index], &m_ptr[index + 1], copylen);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
SafeList<T>* SafeList<T>::Clone() const
|
||||
{
|
||||
SafeList<T>* retval = new SafeList<T>(m_length);
|
||||
memcpy(retval->m_ptr, m_ptr, sizeof(T) * m_length);
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void SafeList<T>::_MakeRoomFor_threshold(int newsize)
|
||||
{
|
||||
MakeRoomFor(newsize + ChunkSize);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user