CloverBootloader/rEFIt_UEFI/cpp_foundation/XArray.h
2020-08-22 16:39:24 +03:00

387 lines
10 KiB
C++
Executable File

//*************************************************************************************************
//*************************************************************************************************
//
// XArray
//
// Developed by jief666, from 1997.
//
//*************************************************************************************************
//*************************************************************************************************
#if !defined(__XARRAY_H__)
#define __XARRAY_H__
#include <XToolsConf.h>
#if 0
#define XArray_DBG(...) printf(__VA_ARGS__)
#else
#define XArray_DBG(...)
#endif
template<class TYPE>
class XArray
{
protected:
TYPE* m_data;
size_t m_len;
size_t m_allocatedSize;
public:
// void Init();
XArray() : m_data(0), m_len(0), m_allocatedSize(0) { }
XArray(const XArray<TYPE> &anArray);
const XArray<TYPE> &operator =(const XArray<TYPE> &anArray);
virtual ~XArray();
public:
const TYPE *data() const { return m_data; }
TYPE *data() { return m_data; }
public:
size_t allocatedSize() const { return m_allocatedSize; }
size_t length() const { return m_len; }
size_t size() const { return m_len; }
void setSize(size_t l);
//low case functions like in std::vector
const TYPE& begin() const { return ElementAt(0); }
TYPE& begin() { return ElementAt(0); }
const TYPE& end() const { return ElementAt(m_len - 1); }
TYPE& end() { return ElementAt(m_len - 1); }
size_t insert(const TYPE newElement, size_t pos, size_t count = 1) { return Insert(newElement, pos, count); }
//--------------------------------------------------
const TYPE& ElementAt(size_t nIndex) const;
TYPE& ElementAt(size_t nIndex);
const TYPE& ElementAt(int nIndex) const;
TYPE& ElementAt(int nIndex);
// const TYPE& operator[](size_t nIndex) const { return ElementAt(nIndex); }
// TYPE& operator[](size_t nIndex) { return ElementAt(nIndex); }
// const TYPE& operator[]( int nIndex) const { return ElementAt(nIndex); }
TYPE& operator[]( int nIndex) { return ElementAt(nIndex); }
// const TYPE& operator[]( unsigned long long nIndex) const { return ElementAt((size_t)nIndex); }
// const TYPE& operator[]( long long nIndex) const { return ElementAt((size_t)nIndex); }
TYPE& operator[]( unsigned long long nIndex) { return ElementAt((size_t)nIndex); }
TYPE& operator[]( long long nIndex) { return ElementAt((size_t)nIndex); }
operator const void *() const { return m_data; };
operator void *() { return m_data; };
operator const TYPE *() const { return m_data; };
operator TYPE *() { return m_data; };
const TYPE * operator +( int i) const { return m_data+i; };
TYPE * operator +( int i) { return m_data+i; };
const TYPE * operator +(size_t i) const { return m_data+i; };
TYPE * operator +(size_t i) { return m_data+i; };
const TYPE * operator -( int i) const { return m_data-i; };
TYPE * operator -( int i) { return m_data-i; };
const TYPE * operator -(size_t i) const { return m_data-i; };
TYPE * operator -(size_t i) { return m_data-i; };
// size_t Add(const TYPE newElement);
// TYPE AddNew();
// size_t Inserts(const TYPE &newElement, size_t pos, size_t count);
void CheckSize(size_t nNewSize);
void CheckSize(size_t nNewSize, size_t nGrowBy);
size_t AddUninitialized(size_t count); // add count uninitialzed elements
size_t Add(const TYPE newElement, size_t count = 1);
size_t AddArray(const TYPE *newElements, size_t count = 1);
size_t Insert(const TYPE newElement, size_t pos, size_t count = 1);
void Remove(const TYPE *Element);
void Remove(const TYPE &Element);
void RemoveAtIndex(size_t nIndex);
void RemoveAtIndex(int nIndex);
void setEmpty();
bool isEmpty() const { return size() == 0; }
size_t indexOf(TYPE& e) const;
bool contains(TYPE& e) const { return indexOf(e) != MAX_XSIZE; } //logically it should be named as Contains(e)
};
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//
// XArray
//
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
template<class TYPE>
size_t XArray<TYPE>::indexOf(TYPE& e) const
{
size_t i;
for ( i=0 ; i<size() ; i+=1 ) {
if ( ElementAt(i) == e ) return i;
}
return MAX_XSIZE;
}
///* Constructeur */
//template<class TYPE>
//void XArray<TYPE>::Init()
//{
// m_data = nullptr;
// m_allocatedSize = 0;
// m_len = 0;
// _GrowBy = XArrayGrowByDefault;
//}
/* Constructeur */
template<class TYPE>
XArray<TYPE>::XArray(const XArray<TYPE> &anArray) : m_data(0), m_len(0), m_allocatedSize(0)
{
// Init();
AddArray(anArray.data(), anArray.size());
}
/* operator = */
template<class TYPE>
const XArray<TYPE> &XArray<TYPE>::operator =(const XArray<TYPE> &anArray)
{
if ( anArray.length() > 0 )
{
CheckSize(anArray.length(), 0);
memcpy(m_data, anArray.m_data, anArray.m_len * sizeof(TYPE));
m_len = anArray.m_len;
}
else
{
setEmpty();
}
//
//
//size_t ui;
//
// setEmpty();
// for ( ui=0 ; ui<anArray.length() ; ui+=1 ) Add(anArray[ui] );
return *this;
}
/* Destructeur */
template<class TYPE>
XArray<TYPE>::~XArray()
{
//printf("XArray Destructor\n");
if ( m_data ) free(m_data);
}
/* CheckSize() // nNewSize is number of TYPE, not in bytes */
template<class TYPE>
void XArray<TYPE>::CheckSize(size_t nNewSize, size_t nGrowBy)
{
//XArray_DBG("CheckSize: m_len=%d, m_size=%d, nGrowBy=%d, nNewSize=%d\n", m_len, m_size, nGrowBy, nNewSize);
if ( nNewSize > m_allocatedSize ) {
nNewSize += nGrowBy;
m_data = (TYPE *)Xrealloc((void *)m_data, nNewSize * sizeof(TYPE), m_allocatedSize * sizeof(TYPE) );
if ( !m_data ) {
panic("XArray<TYPE>::CheckSize(nNewSize=%zu, nGrowBy=%zu) : Xrealloc(%zu, %lu, %" PRIuPTR ") returned NULL. System halted\n", nNewSize, nGrowBy, m_allocatedSize, nNewSize*sizeof(TYPE), (uintptr_t)m_data);
}
// memset(&_Data[_Size], 0, (nNewSize-_Size) * sizeof(TYPE)); // Could help for debugging, but zeroing in not needed.
m_allocatedSize = nNewSize;
}
}
/* CheckSize() */
template<class TYPE>
void XArray<TYPE>::CheckSize(size_t nNewSize)
{
CheckSize(nNewSize, XArrayGrowByDefault);
}
/* SetLength (size_t i) */
template<class TYPE>
void XArray<TYPE>::setSize(size_t l)
{
CheckSize(l, 0); // be sure the size is allocated
m_len = l;
#ifdef DEBUG
if(m_len > m_allocatedSize) {
panic("XArray::SetLength(size_t) -> _Len > _Size");
}
#endif
}
/* ElementAt() */
template<class TYPE>
TYPE &XArray<TYPE>::ElementAt(size_t index)
{
// #ifdef _DEBUG
if ( index >= m_len ) {
panic("XArray::ElementAt(size_t) -> Operator [] : index > m_len");
}
// #endif
return m_data[index];
}
/* ElementAt() */
template<class TYPE>
const TYPE& XArray<TYPE>::ElementAt(size_t index) const
{
// #ifdef _DEBUG
if ( index >= m_len ) {
panic("XArray::ElementAt(size_t) const -> Operator [] : index > m_len");
}
// #endif
return m_data[index];
}
/* ElementAt() */
template<class TYPE>
TYPE &XArray<TYPE>::ElementAt(int index)
{
// #ifdef _DEBUG
if ( index < 0 ) {
panic("XArray::ElementAt(int) -> Operator [] : index < 0");
}
if ( (unsigned int)index >= m_len ) { // cast safe, index > 0
panic("XArray::ElementAt(int) -> Operator [] : index > m_len");
}
// #endif
return m_data[index];
}
/* ElementAt() */
template<class TYPE>
const TYPE& XArray<TYPE>::ElementAt(int index) const
{
// #ifdef _DEBUG
if ( index < 0 ) {
panic("XArray::ElementAt(int) const -> Operator [] : index < 0");
}
if ( (unsigned int)index >= m_len ) { // cast ok as index > 0. Ideally cast would be like '(unsigned __typeof__(index))'
panic("XArray::ElementAt(int) const -> Operator [] : index > m_len");
}
// #endif
return m_data[index];
}
/* Add(size_t) */
template<class TYPE>
size_t XArray<TYPE>::AddUninitialized(size_t count)
{
CheckSize(m_len+count);
m_len += count;
return m_len-count;
}
/* Add(TYPE, size_t) */
template<class TYPE>
size_t XArray<TYPE>::Add(const TYPE newElement, size_t count)
{
// XArray_DBG("size_t XArray<TYPE>::Add(const TYPE newElement, size_t count) -> Enter. count=%d _Len=%d _Size=%d\n", count, m_len, m_size);
size_t i;
CheckSize(m_len+count);
for ( i=0 ; i<count ; i++ ) {
m_data[m_len+i] = newElement;
}
m_len += count;
return m_len-count;
}
/* Add(TYPE *, size_t) */
template<class TYPE>
size_t XArray<TYPE>::AddArray(const TYPE *newElements, size_t count)
{
size_t i;
CheckSize(m_len+count);
for ( i=0 ; i<count ; i++ ) {
m_data[m_len+i] = newElements[i];
}
m_len += count;
return m_len-count;
}
/* Insert(TYPE &, size_t, size_t) */
template<class TYPE>
size_t XArray<TYPE>::Insert(const TYPE newElement, size_t pos, size_t count)
{
size_t i;
if ( pos < m_len ) {
CheckSize(m_len+count);
memmove(&m_data[pos], &m_data[pos+count], (m_len-pos)*sizeof(TYPE));
for ( i=0 ; i<count ; i++ ) {
m_data[pos+i] = newElement;
}
m_len += count;
return pos;
}else{
return Add(newElement, count);
}
}
/* Remove(size_t) */
template<class TYPE>
void XArray<TYPE>::RemoveAtIndex(size_t nIndex)
{
if ( nIndex < m_len ) {
if ( nIndex<m_len-1 ) memmove(&m_data[nIndex], &m_data[nIndex+1], (m_len-nIndex-1)*sizeof(TYPE));
m_len -= 1;
return;
}
#if defined(_DEBUG) && defined(TRACE)
TRACE("XArray::Remove(size_t) -> nIndex > m_len\n");
#endif
}
/* Remove(int) */
template<class TYPE>
void XArray<TYPE>::RemoveAtIndex(int nIndex)
{
#if defined(__XTOOLS_CHECK_OVERFLOW__)
if ( nIndex < 0 ) {
panic("XArray<TYPE>::RemoveAtIndex(int nIndex) : BUG nIndex (%d) is < 0. System halted\n", nIndex);
}
#endif
RemoveAtIndex( (size_t)nIndex ); // Check of nIndex is made in Remove(size_t nIndex)
return;
}
/* Remove(TYPE) */
template<class TYPE>
void XArray<TYPE>::Remove(const TYPE &Element)
{
size_t i;
for ( i=0 ; i<m_len ; i+= 1) {
if ( m_data[i] == Element ) {
Remove(i);
return ;
}
}
#if defined(_DEBUG) && defined(TRACE)
TRACE("XArray::Remove(const TYPE &) -> Element not found\n");
#endif
}
/* Remove(TYPE *) */
template<class TYPE>
void XArray<TYPE>::Remove(const TYPE *Element)
{
Remove(*Element);
}
/* Empty() */
template<class TYPE>
void XArray<TYPE>::setEmpty()
{
//printf("XArray Empty\n");
m_len = 0;
}
#endif