diff --git a/common/SafeArray.h b/common/SafeArray.h index 686ce271f4..b6eca8e6fa 100644 --- a/common/SafeArray.h +++ b/common/SafeArray.h @@ -97,114 +97,3 @@ public: virtual SafeArray* 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 -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* 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 -// -------------------------------------------------------------------------------------- -// 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 -class SafeAlignedArray : public SafeArray -{ - typedef SafeArray _parent; - -protected: - T* _virtual_realloc(int newsize); - -public: - using _parent::operator[]; - - virtual ~SafeAlignedArray(); - - explicit SafeAlignedArray(std::string name = "Unnamed") - : SafeArray::SafeArray(name) - { - } - - explicit SafeAlignedArray(int initialSize, std::string name = "Unnamed"); - virtual SafeAlignedArray* Clone() const; -}; diff --git a/common/SafeArray.inl b/common/SafeArray.inl index 8da05be8db..8ae15feae9 100644 --- a/common/SafeArray.inl +++ b/common/SafeArray.inl @@ -123,165 +123,3 @@ SafeArray* SafeArray::Clone() const memcpy(retval->GetPtr(), m_ptr, sizeof(T) * m_size); return retval; } - - -// -------------------------------------------------------------------------------------- -// SafeAlignedArray (implementations) -// -------------------------------------------------------------------------------------- - -template -T* SafeAlignedArray::_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 -SafeAlignedArray::~SafeAlignedArray() -{ - safe_aligned_free(this->m_ptr); - // mptr is set to null, so the parent class's destructor won't re-free it. -} - -template -SafeAlignedArray::SafeAlignedArray(int initialSize, std::string name) - : SafeArray::SafeArray( - std::move(name), - (T*)_aligned_malloc(initialSize * sizeof(T), Alignment), - initialSize) -{ -} - -template -SafeAlignedArray* SafeAlignedArray::Clone() const -{ - SafeAlignedArray* retval = new SafeAlignedArray(this->m_size); - memcpy(retval->GetPtr(), this->m_ptr, sizeof(T) * this->m_size); - return retval; -} - -// -------------------------------------------------------------------------------------- -// SafeList (implementations) -// -------------------------------------------------------------------------------------- - -template -T* SafeList::_virtual_realloc(int newsize) -{ - return (T*)realloc(m_ptr, newsize * sizeof(T)); -} - -template -SafeList::~SafeList() -{ - safe_free(m_ptr); -} - -template -SafeList::SafeList(const char* name) - : Name(name) -{ - ChunkSize = DefaultChunkSize; - m_ptr = NULL; - m_allocsize = 0; - m_length = 0; -} - -template -SafeList::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 -T* SafeList::_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 -void SafeList::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 -T& SafeList::New() -{ - _MakeRoomFor_threshold(m_length + 1); - return m_ptr[m_length++]; -} - -template -int SafeList::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 -T& SafeList::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 -void SafeList::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 -SafeList* SafeList::Clone() const -{ - SafeList* retval = new SafeList(m_length); - memcpy(retval->m_ptr, m_ptr, sizeof(T) * m_length); - return retval; -} - -template -void SafeList::_MakeRoomFor_threshold(int newsize) -{ - MakeRoomFor(newsize + ChunkSize); -}