299 lines
8 KiB
C++
299 lines
8 KiB
C++
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// (c) 1998-1999 by Microsoft Corp.
|
|||
|
|
//
|
|||
|
|
// FLEXARRY.CPP
|
|||
|
|
//
|
|||
|
|
// CFlexArray implementation (non-arena).
|
|||
|
|
//
|
|||
|
|
// 15-Jul-97 raymcc Created.
|
|||
|
|
// 8-Jun-98 bobw cleaned up for WBEMPERF usage
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
|
|||
|
|
#include "wpheader.h"
|
|||
|
|
#include <stdio.h>
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::CFlexArray
|
|||
|
|
//
|
|||
|
|
// Constructs the array.
|
|||
|
|
//
|
|||
|
|
// Parameters:
|
|||
|
|
// <nSize> The starting preallocated size of the array.
|
|||
|
|
// <nGrowBy> The amount to grow by when the array fills up.
|
|||
|
|
//
|
|||
|
|
// Size() returns the number of elements in use, not the 'true' size.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CFlexArray::CFlexArray(
|
|||
|
|
int nSize,
|
|||
|
|
int nGrowBy
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
m_nExtent = nSize;
|
|||
|
|
m_nSize = 0;
|
|||
|
|
m_nGrowBy = nGrowBy;
|
|||
|
|
m_hHeap = GetProcessHeap(); // call this once and save heap handle locally
|
|||
|
|
|
|||
|
|
m_pArray = (void **) ALLOCMEM(m_hHeap, HEAP_ZERO_MEMORY, sizeof(void *) * nSize);
|
|||
|
|
|
|||
|
|
assert (m_pArray != NULL);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::~CFlexArray
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CFlexArray::~CFlexArray()
|
|||
|
|
{
|
|||
|
|
FREEMEM(m_hHeap, 0, m_pArray);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// Copy constructor.
|
|||
|
|
//
|
|||
|
|
// Copies the pointers, not their contents.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CFlexArray::CFlexArray(CFlexArray &Src)
|
|||
|
|
{
|
|||
|
|
m_pArray = 0;
|
|||
|
|
m_nSize = 0;
|
|||
|
|
m_nExtent = 0;
|
|||
|
|
m_nGrowBy = 0;
|
|||
|
|
|
|||
|
|
*this = Src;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// operator =
|
|||
|
|
//
|
|||
|
|
// Assignment operator.
|
|||
|
|
//
|
|||
|
|
// Arenas are not copied. This allows transfer of arrays between arenas.
|
|||
|
|
// Arrays are copied by pointer only.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
CFlexArray& CFlexArray::operator=(CFlexArray &Src)
|
|||
|
|
{
|
|||
|
|
m_nSize = Src.m_nSize;
|
|||
|
|
m_nExtent = Src.m_nExtent;
|
|||
|
|
m_nGrowBy = Src.m_nGrowBy;
|
|||
|
|
|
|||
|
|
FREEMEM (m_hHeap, 0, m_pArray);
|
|||
|
|
m_pArray = (void **) ALLOCMEM(m_hHeap, HEAP_ZERO_MEMORY, sizeof(void *) * m_nExtent);
|
|||
|
|
if (m_pArray) {
|
|||
|
|
memcpy(m_pArray, Src.m_pArray, sizeof(void *) * m_nExtent);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return *this;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::RemoveAt
|
|||
|
|
//
|
|||
|
|
// Removes the element at the specified location. Does not
|
|||
|
|
// actually delete the pointer. Shrinks the array over the top of
|
|||
|
|
// the 'doomed' element.
|
|||
|
|
//
|
|||
|
|
// Parameters:
|
|||
|
|
// <nIndex> The location of the element.
|
|||
|
|
//
|
|||
|
|
// Return value:
|
|||
|
|
// range_error The index is not legal.
|
|||
|
|
// no_error Success.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
int CFlexArray::RemoveAt(int nIndex)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
|
|||
|
|
if (nIndex >= m_nSize) {
|
|||
|
|
return range_error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (i = nIndex; i < m_nSize - 1; i++) {
|
|||
|
|
m_pArray[i] = m_pArray[i + 1];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_nSize--;
|
|||
|
|
m_pArray[m_nSize] = 0;
|
|||
|
|
|
|||
|
|
return no_error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::InsertAt
|
|||
|
|
//
|
|||
|
|
// Inserts a new element at the specified location. The pointer is copied.
|
|||
|
|
//
|
|||
|
|
// Parameters:
|
|||
|
|
// <nIndex> The 0-origin location at which to insert the new element.
|
|||
|
|
// <pSrc> The pointer to copy. (contents are not copied).
|
|||
|
|
//
|
|||
|
|
// Return value:
|
|||
|
|
// array_full
|
|||
|
|
// out_of_memory
|
|||
|
|
// no_error
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
int CFlexArray::InsertAt(int nIndex, void *pSrc)
|
|||
|
|
{
|
|||
|
|
void **pTmp; // pointer to new array
|
|||
|
|
int nReturn = no_error;
|
|||
|
|
LONG lOldSize;
|
|||
|
|
LONG lNewSize;
|
|||
|
|
|
|||
|
|
// If the array is full, we need to expand it.
|
|||
|
|
// ===========================================
|
|||
|
|
|
|||
|
|
if (m_nSize == m_nExtent) {
|
|||
|
|
if (m_nGrowBy == 0) {
|
|||
|
|
nReturn = array_full;
|
|||
|
|
} else {
|
|||
|
|
// compute sizes
|
|||
|
|
lOldSize = sizeof(void *) * m_nExtent;
|
|||
|
|
m_nExtent += m_nGrowBy;
|
|||
|
|
lNewSize = sizeof(void *) * m_nExtent;
|
|||
|
|
|
|||
|
|
// allocate new array
|
|||
|
|
pTmp = (void **) ALLOCMEM(m_hHeap, HEAP_ZERO_MEMORY, lNewSize);
|
|||
|
|
if (!pTmp) {
|
|||
|
|
nReturn = out_of_memory;
|
|||
|
|
} else {
|
|||
|
|
// move bits from old array to new array
|
|||
|
|
memcpy (pTmp, m_pArray, lOldSize);
|
|||
|
|
// toss old arrya
|
|||
|
|
FREEMEM (m_hHeap, 0, m_pArray);
|
|||
|
|
// save pointer to new array
|
|||
|
|
m_pArray = pTmp;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Special case of appending. This is so frequent
|
|||
|
|
// compared to true insertion that we want to optimize.
|
|||
|
|
// ====================================================
|
|||
|
|
|
|||
|
|
if (nReturn == no_error) {
|
|||
|
|
if (nIndex == m_nSize) {
|
|||
|
|
m_pArray[m_nSize++] = pSrc;
|
|||
|
|
} else {
|
|||
|
|
// If here, we are inserting at some random location.
|
|||
|
|
// We start at the end of the array and copy all the elements
|
|||
|
|
// one position farther to the end to make a 'hole' for
|
|||
|
|
// the new element.
|
|||
|
|
// ==========================================================
|
|||
|
|
|
|||
|
|
for (int i = m_nSize; i > nIndex; i--) {
|
|||
|
|
m_pArray[i] = m_pArray[i - 1];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_pArray[nIndex] = pSrc;
|
|||
|
|
m_nSize++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return nReturn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::DebugDump
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
void CFlexArray::DebugDump()
|
|||
|
|
{
|
|||
|
|
printf("----CFlexArray Debug Dump----\n");
|
|||
|
|
printf("m_pArray = 0x%p\n", m_pArray);
|
|||
|
|
printf("m_nSize = %d\n", m_nSize);
|
|||
|
|
printf("m_nExtent = %d\n", m_nExtent);
|
|||
|
|
printf("m_nGrowBy = %d\n", m_nGrowBy);
|
|||
|
|
|
|||
|
|
for (int i = 0; i < m_nExtent; i++)
|
|||
|
|
{
|
|||
|
|
if (i < m_nSize) {
|
|||
|
|
printf("![%d] = %p\n", i, m_pArray[i]);
|
|||
|
|
} else {
|
|||
|
|
printf("?[%d] = %p\n", i, m_pArray[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::Compress
|
|||
|
|
//
|
|||
|
|
// Removes NULL elements by moving all non-NULL pointers to the beginning
|
|||
|
|
// of the array. The array "Size" changes, but the extent is untouched.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
void CFlexArray::Compress()
|
|||
|
|
{
|
|||
|
|
int nLeftCursor = 0, nRightCursor = 0;
|
|||
|
|
|
|||
|
|
while (nLeftCursor < m_nSize - 1) {
|
|||
|
|
if (m_pArray[nLeftCursor]) {
|
|||
|
|
nLeftCursor++;
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
nRightCursor = nLeftCursor + 1;
|
|||
|
|
while (m_pArray[nRightCursor] == 0 && nRightCursor < m_nSize)
|
|||
|
|
nRightCursor++;
|
|||
|
|
if (nRightCursor == m_nSize)
|
|||
|
|
break; // Short circuit, no more nonzero elements.
|
|||
|
|
m_pArray[nLeftCursor] = m_pArray[nRightCursor];
|
|||
|
|
m_pArray[nRightCursor] = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
while (m_pArray[m_nSize - 1] == 0 && m_nSize > 0) m_nSize--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::Empty
|
|||
|
|
//
|
|||
|
|
// Clears the array of all pointers (does not deallocate them) and sets
|
|||
|
|
// its apparent size to zero.
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
// ok
|
|||
|
|
void CFlexArray::Empty()
|
|||
|
|
{
|
|||
|
|
FREEMEM(m_hHeap, 0, m_pArray);
|
|||
|
|
m_pArray = (void **) ALLOCMEM(m_hHeap, HEAP_ZERO_MEMORY, sizeof(void *) * m_nGrowBy);
|
|||
|
|
m_nSize = 0;
|
|||
|
|
m_nExtent = m_nGrowBy;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//***************************************************************************
|
|||
|
|
//
|
|||
|
|
// CFlexArray::UnbindPtr
|
|||
|
|
//
|
|||
|
|
// Empties the array and returns the pointer to the data it contained
|
|||
|
|
//
|
|||
|
|
//***************************************************************************
|
|||
|
|
|
|||
|
|
void** CFlexArray::UnbindPtr()
|
|||
|
|
{
|
|||
|
|
void** pp = m_pArray;
|
|||
|
|
Empty();
|
|||
|
|
return pp;
|
|||
|
|
}
|