diff options
Diffstat (limited to 'wia/ProdScan/BasicArray.h')
| -rw-r--r-- | wia/ProdScan/BasicArray.h | 381 |
1 files changed, 381 insertions, 0 deletions
diff --git a/wia/ProdScan/BasicArray.h b/wia/ProdScan/BasicArray.h new file mode 100644 index 00000000..8894dabc --- /dev/null +++ b/wia/ProdScan/BasicArray.h @@ -0,0 +1,381 @@ +/************************************************************************** +* +* Copyright � Microsoft Corporation +* +* File Title: BasicArray.h +* +* Project: Production Scanner Driver Sample +* +* Description: Contains the class declaration of the CBasicDynamicArray class. +* +***************************************************************************/ + +#ifndef __SIMARRAY_H_INCLUDED +#define __SIMARRAY_H_INCLUDED + +template<class T> +class CBasicDynamicArray +{ +private: + + int m_nSize; + int m_nMaxSize; + int m_nGrowSize; + T *m_pArray; + + enum + { + eGrowSize = 10 // The number of items to add each time the array grows. + }; + +public: + + CBasicDynamicArray(void) + : m_nSize(0), + m_nMaxSize(0), + m_nGrowSize(eGrowSize), + m_pArray(NULL) + {} + + CBasicDynamicArray( + int nInitialSize, + int nGrowSize = 0) + : m_nSize(0), + m_nMaxSize(0), + m_nGrowSize(nGrowSize ? nGrowSize : eGrowSize), + m_pArray(NULL) + { + GrowTo(nInitialSize); + } + + CBasicDynamicArray( + const CBasicDynamicArray<T> &other) + : m_nSize(0), + m_nMaxSize(0), + m_nGrowSize(eGrowSize), + m_pArray(NULL) + { + Append(other); + } + + ~CBasicDynamicArray( + void) + { + Destroy(); + } + + CBasicDynamicArray& + operator=( + const CBasicDynamicArray &other) + { + if (this != &other) + { + Destroy(); + Append(other); + } + return *this; + } + + void + Destroy( + void) + { + if (m_pArray) + { + delete[] m_pArray; + m_pArray = NULL; + } + m_nSize = m_nMaxSize = 0; + } + + void + Append( + const CBasicDynamicArray &other) + { + if (GrowTo(m_nSize + other.Size())) + { + for (int i = 0; i < other.Size(); i++) + { + Append(other[i]); + } + } + } + + int + Append( + const T &element) + { + int nResult = -1; + if (GrowTo(m_nSize + 1)) + { + m_pArray[m_nSize] = element; + nResult = m_nSize; + m_nSize++; + } + return nResult; + } + + int + Insert( + const T &element, + int nIndex) + { + // + // Make sure we can accomodate this new item: + // + if (GrowTo(m_nSize + 1)) + { + // + // Make sure the item is within the range we've allocated: + // + if ((nIndex >= 0) && (nIndex <= m_nSize)) + { + // + // Make room for the new item by moving all items above up by one slot: + // + for (int i = Size(); i > nIndex; i--) + { + m_pArray[i] = m_pArray[i-1]; + } + + // + // Save the new item: + // + m_pArray[nIndex] = element; + + // + // We're now one larger: + // + m_nSize++; + + // + // Return the index of the slot we used: + // + return nIndex; + } + } + + // + // Return an error + // + return -1; + } + + void + Delete( + int nItem) + { + if ((nItem >= 0) && (nItem < m_nSize) && (m_pArray)) + { + T *pTmpArray = new T[m_nMaxSize]; + if (pTmpArray) + { + T *pSrc = NULL, *pTgt = NULL; + pSrc = m_pArray; + pTgt = pTmpArray; + + for (int i = 0; i < m_nSize; i++) + { + if (i != nItem) + { + *pTgt = *pSrc; + pTgt++; + } + pSrc++; + } + delete[] m_pArray; + m_pArray = pTmpArray; + m_nSize--; + } + } + } + + bool + GrowTo( + int nSize) + { + // + // If the array is already large enough, just return true: + // + if (nSize < m_nMaxSize) + { + return true; + } + + // + // Save old size, in case we can't allocate a new array: + // + int nOldMaxSize = m_nMaxSize; + + // + // Find the correct size to grow to: + // + while (m_nMaxSize < nSize) + { + m_nMaxSize += m_nGrowSize; + } + + // + // Allocate the array: + // + T *pTmpArray = new T[m_nMaxSize]; + if (pTmpArray) + { + // + // Copy the old array over: + // + for (int i = 0; i < m_nSize; i++) + { + pTmpArray[i] = m_pArray[i]; + } + + // + // Delete the old array: + // + if (m_pArray) + { + delete[] m_pArray; + } + + // + // Assign the new array to the old one and return true: + // + m_pArray = pTmpArray; + return true; + } + else + { + // + // If we couldn't allocate the new array, restore the maximum size and return false: + // + m_nMaxSize = nOldMaxSize; + return false; + } + } + + // + // Simple swap: + // + void + Swap( + T& a, + T& b) + { + T t = a; + a = b; + b = t; + } + + int + Find( + const T& element) const + { + for (int i = 0; i < m_nSize; i++) + { + if (m_pArray[i] == element) + { + return i; + } + } + return -1; + } + + bool + operator==( + const CBasicDynamicArray &other) + { + if (Size() != other.Size()) + { + return false; + } + + for (int i = 0; i < Size(); i++) + { + if (!(m_pArray[i] == other[i])) + { + return false; + } + } + return true; + } + + bool + Contains( + const T& element) + { + return (Find(element) >= 0); + } + + void + Size( + int nSize) + { + m_nSize = nSize; + } + + void + MaxSize( + int nMaxSize) + { + m_nMaxSize = nMaxSize; + } + + void + GrowSize( + int nGrowSize) + { + m_nGrowSize = nGrowSize; + } + + int + Size( + void) const + { + return m_nSize; + } + + int + MaxSize( + void) const + { + return m_nMaxSize; + } + + int + GrowSize( + void) const + { + return m_nGrowSize; + } + + T* + GetBuffer( + int nSize) + { + return GrowTo(nSize) ? m_pArray : NULL; + } + + const T* + Array( + void) const + { + return m_pArray; + } + + const T& + operator[]( + int nIndex) const + { + return m_pArray[nIndex]; + } + + T& + operator[]( + int nIndex) + { + return m_pArray[nIndex]; + } +}; + +#endif + |