void VArray<TYPE, ARG_TYPE>::InsertAt(int nStartIndex, VArray* pNewArray) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(pNewArray != NULL); VASSERT(V_IS_VALID_PTR(this)); VASSERT(nStartIndex >= 0); if (pNewArray->GetSize() > 0) { InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize()); for (int i = 0; i < pNewArray->GetSize(); i++) SetAt(nStartIndex + i, pNewArray->GetAt(i)); } }
void VArray<TYPE, ARG_TYPE>::InsertAt(int nIndex, ARG_TYPE newElement, int nCount /*=1*/) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(nIndex >= 0); ///< will expand to meet need VASSERT(nCount > 0); ///< zero or negative size not allowed if (nIndex >= m_nSize) { // adding after the end of the array SetSize(nIndex + nCount, -1); ///< grow so nIndex is valid } else { // inserting in the middle of the array int nOldSize = m_nSize; SetSize(m_nSize + nCount, -1); ///< grow it to new size // destroy intial data before copying over it VDestructElements<TYPE>(&m_pData[nOldSize], nCount); // shift old data up to fill gap memmove(&m_pData[nIndex+nCount], &m_pData[nIndex], (nOldSize-nIndex) * sizeof(TYPE)); // re-init slots we copied from VConstructElementsZeroInit<TYPE>(&m_pData[nIndex], nCount); } // insert new value in the gap VASSERT(nIndex + nCount <= m_nSize); while (nCount--) m_pData[nIndex++] = newElement; }
void VArray<TYPE, ARG_TYPE>::Copy(const VArray& src) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(this != &src); ///< cannot append to itself SetSize(src.m_nSize); VCopyElements<TYPE>(m_pData, src.m_pData, src.m_nSize); }
void VArray<TYPE, ARG_TYPE>::SetAtGrow(int nIndex, ARG_TYPE newElement) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(nIndex >= 0); if (nIndex >= m_nSize) SetSize(nIndex+1, -1); m_pData[nIndex] = newElement; }
int VArray<TYPE, ARG_TYPE>::Append(const VArray& src) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(this != &src); ///< cannot append to itself int nOldSize = m_nSize; SetSize(m_nSize + src.m_nSize); VCopyElements<TYPE>(m_pData + nOldSize, src.m_pData, src.m_nSize); return nOldSize; }
VArray<TYPE, ARG_TYPE>::~VArray() { VASSERT(V_IS_VALID_PTR(this)); if (m_pData != NULL) { VDestructElements<TYPE>(m_pData, m_nSize); delete[] (BYTE*)m_pData; } }
void VArray<TYPE, ARG_TYPE>::RemoveAtSwapWithLast(int nIndex) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(nIndex >= 0); VASSERT(nIndex < m_nSize); VDestructElements<TYPE>(&m_pData[nIndex], 1); memcpy(&m_pData[nIndex], &m_pData[m_nSize-1], sizeof(TYPE)); --m_nSize; }
void VArray<TYPE, ARG_TYPE>::RemoveAt(int nIndex, int nCount) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(nIndex >= 0); VASSERT(nCount >= 0); VASSERT(nIndex + nCount <= m_nSize); // just remove a range int nMoveCount = m_nSize - (nIndex + nCount); VDestructElements<TYPE>(&m_pData[nIndex], nCount); if (nMoveCount) memmove(&m_pData[nIndex], &m_pData[nIndex + nCount], nMoveCount * sizeof(TYPE)); m_nSize -= nCount; }
void VArray<TYPE, ARG_TYPE>::Swap(VArray& other) { VASSERT(V_IS_VALID_PTR(this)); TYPE* pData = m_pData; int nSize = m_nSize; int nMaxSize = m_nMaxSize; int nGrowBy = m_nGrowBy; m_pData = other.m_pData; m_nSize = other.m_nSize; m_nMaxSize = other.m_nMaxSize; m_nGrowBy = other.m_nGrowBy; other.m_pData = pData; other.m_nSize = nSize; other.m_nMaxSize = nMaxSize; other.m_nGrowBy = nGrowBy; }
void VArray<TYPE, ARG_TYPE>::FreeExtra() { VASSERT(V_IS_VALID_PTR(this)); if (m_nSize != m_nMaxSize) { // shrink to desired size TYPE* pNewData = NULL; if (m_nSize != 0) { pNewData = (TYPE*) new BYTE[m_nSize * sizeof(TYPE)]; // copy new data from old memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); } // get rid of old stuff (note: no destructors called) delete[] (BYTE*)m_pData; m_pData = pNewData; m_nMaxSize = m_nSize; } }
void VArray<TYPE, ARG_TYPE>::SetSize(int nNewSize, int nGrowBy, bool bDeallocateIfEmpty) { VASSERT(V_IS_VALID_PTR(this)); VASSERT(nNewSize >= 0); if (nGrowBy != -1) m_nGrowBy = nGrowBy; ///< set new size if (nNewSize == 0 && bDeallocateIfEmpty) { // shrink to nothing if (m_pData != NULL) { VDestructElements<TYPE>(m_pData, m_nSize); delete[] (BYTE*)m_pData; m_pData = NULL; } m_nSize = m_nMaxSize = 0; } else if (m_pData == NULL && nNewSize > 0) { // Construct first array. m_nMaxSize = hkvMath::Max(nGrowBy, nNewSize); m_pData = (TYPE*) new BYTE[m_nMaxSize * sizeof(TYPE)]; VConstructElementsZeroInit<TYPE>(m_pData, nNewSize); m_nSize = nNewSize; } else if (nNewSize <= m_nMaxSize) { // it fits if (nNewSize > m_nSize) { // initialize the new elements VConstructElementsZeroInit<TYPE>(&m_pData[m_nSize], nNewSize-m_nSize); } else if (m_nSize > nNewSize) { // destroy the old elements VDestructElements<TYPE>(&m_pData[nNewSize], m_nSize-nNewSize); } m_nSize = nNewSize; } else { nGrowBy = m_nGrowBy; if (nGrowBy == 0) { // otherwise, grow array by 1.5 of previous size (minimal growth = 4) nGrowBy = m_nMaxSize / 2 < 4 ? 4 : m_nMaxSize / 2; } int nNewMax = m_nMaxSize + nGrowBy; if (nNewSize > nNewMax) { nNewMax = nNewSize; } VASSERT(nNewMax >= m_nMaxSize); ///< no wrap around TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)]; // copy new data from old memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); // construct remaining elements VASSERT(nNewSize > m_nSize); VConstructElementsZeroInit<TYPE>(&pNewData[m_nSize], nNewSize-m_nSize); // get rid of old stuff (note: no destructors called) delete[] (BYTE*)m_pData; m_pData = pNewData; m_nSize = nNewSize; m_nMaxSize = nNewMax; } }