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;
|
||
}
|