///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifndef OdVector_H_INCLUDED
|
#define OdVector_H_INCLUDED
|
|
#include <new>
|
|
#include "TD_PackPush.h"
|
|
#include "OdArrayMemAlloc.h"
|
#include "OdAlloc.h"
|
|
template <class T, class A = OdObjectsAllocator<T>, class Mm = OdrxMemoryManager> class OdVector;
|
|
/** \details
|
This template class implements dynamic Array objects within Teigha.
|
|
\remarks
|
Methods are provided to access Array elements via both array indices and array pointers (iterators).
|
|
Some definitions are in order:
|
|
1. Logical Length or Size -- The number of entries in the array. Initially zero.
|
2. Physical Length -- The maximum Logical Length of the array before it automatically grows.
|
3. Grow Length -- The number of entries by which the Physical Length will grow as required.
|
|
\sa
|
Db
|
|
<group Other_Classes>
|
*/
|
template <class T, class A, class Mm> class OdVector
|
{
|
public:
|
typedef typename A::size_type size_type;
|
typedef T* iterator;
|
typedef const T* const_iterator;
|
// compatibility with OdArray
|
typedef T value_type;
|
typedef const T& const_reference;
|
typedef T& reference;
|
|
private:
|
static T* allocate(size_type physicalLength);
|
|
void release();
|
|
void reallocate(size_type physicalLength, bool isUseRealloc = false, bool isForcePhysicalLength = false);
|
|
bool isValid(size_type index) const;
|
void assertValid(size_type index) const;
|
|
static void riseError(OdResult res);
|
|
const_iterator begin_const() const;
|
iterator begin_non_const();
|
const_iterator end_const() const;
|
iterator end_non_const();
|
|
public:
|
/** \param physicalLength [in] Initial physical length.
|
\param growLength [in] Initial grow length.
|
*/
|
explicit OdVector(size_type physicalLength, int growLength = 8);
|
OdVector();
|
OdVector(const OdVector& vec);
|
|
~OdVector();
|
OdVector& operator=(const OdVector& vec);
|
|
/** \details
|
Returns an iterator that references the first element in this Array object.
|
*/
|
iterator begin();
|
const_iterator begin() const;
|
iterator end();
|
const_iterator end() const;
|
|
/** \details
|
Inserts an element, number of elements, or range of elements, into this Array object.
|
|
\param before [in] Position where first element is to be inserted.
|
\param first [in] Position of first element to be inserted.
|
\param afterLast [in] Position of first element after the last element to be inserted.
|
|
\remarks
|
The range of elements may be from another Array object.
|
*/
|
void insert(iterator before, const_iterator first, const_iterator afterLast);
|
|
/** \param numElem [in] Number of elements to insert.
|
\param value [in] Value to insert.
|
*/
|
iterator insert(iterator before, size_type numElem, const T& value);
|
iterator insert(iterator before, const T& value = T());
|
|
/** \details
|
Inserts the specified value into this Array object at the specified index.
|
|
\param index [in] Array index.
|
\param value [in] Value to insert.
|
|
\remarks
|
0 <= index <= length()
|
|
Elements starting at index will have their indices incremented.
|
|
Returns a reference to this Array object.
|
*/
|
OdVector& insertAt(size_type index, const T& value);
|
|
/** \details
|
Removes the element at the specified index from this Array object.
|
|
\param index [in] Array index.
|
|
\remarks
|
0 <= index < length()
|
|
Elements starting at index+1 will have their indices decremented.
|
|
Returns a reference to this Array object.
|
*/
|
OdVector& removeAt(size_type index);
|
|
/** \details
|
Removes the specified elements from this Array object.
|
|
\param startIndex [in] Start index.
|
\param endIndex [in] End index.
|
|
\remarks
|
Elements from startIndex through endIndex inclusive will be removed.
|
|
Returns a reference to this Array object.
|
*/
|
OdVector& removeSubArray(size_type startIndex, size_type endIndex);
|
|
/** \details
|
Removes the element with the specified value from this Array object.
|
|
\param value [in] Value for which to search.
|
\param startIndex [in] Starting index of search.
|
|
\remarks
|
Removes the first occurance of value starting at startIndex.
|
|
Returns true if and only if an element was removed.
|
*/
|
bool remove(const T& value, size_type startIndex = 0);
|
|
/** \details
|
Specifies the logical length for this Array object.
|
\param logicalLength [in] Logical length.
|
\param value [in] Value for the elements added to obtain the new logical length.
|
*/
|
void resize(size_type logicalLength, const T& value);
|
void resize(size_type logicalLength);
|
|
/** \details
|
Returns the logical length of this Array object.
|
*/
|
size_type size() const;
|
|
/** \details
|
Returns true if and only if this Array is empty.
|
*/
|
bool empty() const;
|
|
/** \details
|
Returns the physical length of this Array object.
|
*/
|
size_type capacity() const;
|
|
/** \details
|
Sets the physical length of this Array object to the specified
|
reserve length if the reserve length is greater than its physical length.
|
|
\param reserveLength [in] Minimum physical length.
|
*/
|
void reserve(size_type reserveLength);
|
|
/** \details
|
Assigns the specified range of elements to this Array object.
|
|
\param first [in] Position of first element to be assigned.
|
\param afterLast [in] Position of first element after the last element to be assigned.
|
|
\remarks
|
After this Array object is cleared, this function assigns the specified range of elements from
|
another Array object.
|
*/
|
void assign(const_iterator first, const_iterator afterLast);
|
|
/** \details
|
Removes the specified element or range of elements from this Array object.
|
|
\param first [in] Position of first element to be assigned.
|
\param afterLast [in] Position of first element after the last element to be assigned.
|
*/
|
iterator erase(iterator first, iterator afterLast);
|
|
/** \param where [in] Element to remove.
|
*/
|
iterator erase(iterator where);
|
|
/** \details
|
Removes all elements from this Array object.
|
*/
|
void clear();
|
|
/** \details
|
Appends an element to the end of this Array object.
|
*/
|
void push_back(const T& value);
|
|
/** \details
|
Returns true if and only if this Array object contains ths specified value.
|
|
\param value [in] Value for which to search.
|
\param startIndex [in] Starting index of search.
|
*/
|
bool contains(const T& value, size_type startIndex = 0) const;
|
|
/** \details
|
Returns the number of elements in this Array object.
|
*/
|
size_type length() const;
|
|
/** \details
|
Returns true if and only if this Array is empty.
|
*/
|
bool isEmpty() const;
|
|
/** \details
|
Returns the logical length of this Array object.
|
*/
|
size_type logicalLength() const;
|
|
/** \details
|
Returns the physical length of this Array object.
|
*/
|
size_type physicalLength() const;
|
|
/** \details
|
Returns the grow length of this Array object.
|
*/
|
int growLength() const;
|
|
/** \details
|
Returns the data buffer of this Array object.
|
*/
|
const T* asArrayPtr() const;
|
|
/** \details
|
Returns the data buffer of this Array object.
|
*/
|
const T* getPtr() const;
|
|
T* asArrayPtr();
|
|
/** \remarks
|
For convenient access to the data.
|
*/
|
const T& operator[](size_type index) const;
|
T& operator[](size_type index);
|
|
/** \details
|
Returns the element of this Array object at the specified index.
|
\param arrayIndex [in] Array index.
|
*/
|
T& at(size_type index);
|
const T& at(size_type index) const;
|
|
/** \details
|
Sets the element of this Array object at the specified index.
|
\param arrayIndex [in] Array index.
|
\param value [in] Value.
|
*/
|
OdVector& setAt(size_type index, const T& value);
|
|
/** \details
|
Returns the element of this Array object at the specified position.
|
\param arrayIndex [in] Array index.
|
*/
|
const T& getAt(size_type index) const;
|
|
/** \details
|
Returns the first element of this Array object.
|
*/
|
T& first();
|
const T& first() const;
|
|
/** \details
|
Returns the last element of this Array object.
|
*/
|
T& last();
|
const T& last() const;
|
|
size_type append(const T& value);
|
iterator append();
|
|
/** \details
|
Appends the specified value or Array object to the end of this Array object.
|
|
\param vec [in] Array to append.
|
\param value [in] Value to append.
|
|
\remarks
|
If called with otherArray, returns a reference to this Array object.
|
|
If called with value, returns the index of the new last element.
|
|
If called with no arguments, returns an interator (pointer) to the first element
|
after the last element in the array.
|
*/
|
OdVector& append(const OdVector& vec);
|
|
/** \details
|
Removes the first element in this Array object.
|
*/
|
OdVector& removeFirst();
|
|
/** \details
|
Removes the last element in this Array object.
|
*/
|
OdVector& removeLast();
|
|
bool operator==(const OdVector& vec) const;
|
|
/** \details
|
Sets all the elements in this Array object to the specified value.
|
\param value [in] Value to assign.
|
*/
|
OdVector& setAll(const T& value);
|
|
/** \details
|
Returns true if and only if this Array object contains ths specified value.
|
|
\param value [in] Value for which to search.
|
\param index [out] Receives the index of the found value.
|
\param startIndex [in] Starting index of search.
|
|
\remarks
|
Returns the index at which the element was found.
|
*/
|
bool find(const T& value, size_type& index, size_type startIndex = 0) const;
|
|
/** \details
|
Sets the logical length of this Array object.
|
\param logicalLength [in] Logical length.
|
\remarks
|
The physical length is increased as required.
|
*/
|
OdVector& setLogicalLength(size_type logicalLength);
|
|
/** \details
|
Sets the physical length of this Array object.
|
\param physicalLength [in] Physical length.
|
\remarks
|
The logical length is decreased as required.
|
*/
|
OdVector& setPhysicalLength(size_type physicalLength);
|
|
/** \details
|
Sets the grow length of this Array object.
|
\param growLength [in] Grow length.
|
*/
|
OdVector& setGrowLength(int growLength);
|
|
/** \details
|
Reverses the order of the elements in this Array object.
|
*/
|
OdVector& reverse();
|
|
/** \details
|
Swaps the specified elements in this Array object.
|
\param firstIndex [in] Index of first element.
|
\param secondIndex [in] Index of second element.
|
*/
|
OdVector& swap(size_type firstIndex, size_type secondIndex);
|
|
private:
|
T* m_pData;
|
size_type m_physicalLength;
|
size_type m_logicalLength;
|
int m_growLength;
|
};
|
|
|
#define VEC_SIZE_TYPE typename OdVector<T, A, Mm>::size_type
|
#define VEC_ITERATOR typename OdVector<T, A, Mm>::iterator
|
#define VEC_CONST_ITERATOR typename OdVector<T, A, Mm>::const_iterator
|
|
|
template<class T, class A, class Mm>
|
inline OdVector<T, A, Mm>::OdVector(VEC_SIZE_TYPE physicalLength, int growLength)
|
: m_pData(NULL), m_physicalLength(physicalLength), m_logicalLength(0)
|
, m_growLength(growLength)
|
{
|
if(m_growLength == 0)
|
{
|
ODA_FAIL();
|
m_growLength = -200;
|
}
|
if (m_physicalLength)
|
{
|
m_pData = allocate(m_physicalLength);
|
}
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>::OdVector()
|
: m_pData(NULL), m_physicalLength(0), m_logicalLength(0), m_growLength(-200)
|
{
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>::OdVector(const OdVector<T, A, Mm>& vec)
|
: m_pData(NULL), m_physicalLength(vec.m_physicalLength)
|
, m_logicalLength(vec.m_logicalLength), m_growLength(vec.m_growLength)
|
{
|
if(m_physicalLength > 0)
|
{
|
m_pData = allocate(m_physicalLength);
|
|
A::copy(m_pData, vec.m_pData, m_logicalLength);
|
}
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>::~OdVector()
|
{
|
release();
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::operator=(const OdVector<T, A, Mm>& vec)
|
{
|
if(this != &vec)
|
{
|
if(m_physicalLength < vec.m_logicalLength)
|
{
|
release();
|
|
m_pData = allocate(vec.m_logicalLength);
|
m_physicalLength = vec.m_logicalLength;
|
}
|
|
m_logicalLength = vec.m_logicalLength;
|
|
A::copy(m_pData, vec.m_pData, m_logicalLength);
|
}
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline T* OdVector<T, A, Mm>::allocate(VEC_SIZE_TYPE physicalLength)
|
{
|
ODA_ASSERT(physicalLength != 0);
|
const VEC_SIZE_TYPE numByte = physicalLength*sizeof(T);
|
|
ODA_ASSERT(numByte >= physicalLength); // size_type overflow
|
|
T* pData = ((numByte >= physicalLength)
|
? reinterpret_cast<T*>(Mm::Alloc(numByte))
|
: NULL);
|
|
if(pData == NULL)
|
throw OdError(eOutOfMemory);
|
|
return pData;
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::release()
|
{
|
if(m_pData != NULL)
|
{
|
A::destroy(m_pData, m_logicalLength);
|
|
Mm::Free(m_pData);
|
m_pData = NULL;
|
m_physicalLength = 0;
|
}
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::reallocate(VEC_SIZE_TYPE physicalLength, bool isUseRealloc, bool isForcePhysicalLength)
|
{
|
T* pOldData = m_pData;
|
VEC_SIZE_TYPE newPhysicalLength = physicalLength;
|
|
if(!isForcePhysicalLength)
|
{
|
if(m_growLength > 0)
|
{
|
newPhysicalLength = ((newPhysicalLength + m_growLength - 1)/m_growLength) * m_growLength;
|
}
|
else
|
{
|
newPhysicalLength = m_logicalLength + (-m_growLength)*m_logicalLength/100;
|
|
if(newPhysicalLength < physicalLength)
|
newPhysicalLength = physicalLength;
|
}
|
}
|
|
if(isUseRealloc && A::useRealloc() && m_logicalLength > 0 && m_pData != NULL)
|
{
|
m_pData = reinterpret_cast<T*>(Mm::Realloc(pOldData, newPhysicalLength*sizeof(T), m_physicalLength*sizeof(T)));
|
|
if (!m_pData)
|
throw OdError(eOutOfMemory);
|
|
m_physicalLength = newPhysicalLength;
|
|
if(physicalLength < m_logicalLength)
|
m_logicalLength = physicalLength;
|
}
|
else
|
{
|
T* pNewData = allocate(newPhysicalLength);
|
const VEC_SIZE_TYPE newLogicalLength = odmin(m_logicalLength, physicalLength);
|
|
A::constructn(pNewData, pOldData, newLogicalLength);
|
|
release();
|
|
m_pData = pNewData;
|
m_physicalLength = newPhysicalLength;
|
m_logicalLength = newLogicalLength;
|
}
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::isValid(VEC_SIZE_TYPE index) const
|
{
|
// index is unsigned here, no need >= 0 check
|
return (index < m_logicalLength);
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::assertValid(VEC_SIZE_TYPE index) const
|
{
|
if(!isValid(index))
|
{
|
ODA_FAIL();
|
throw OdError_InvalidIndex();
|
}
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::riseError(OdResult res)
|
{
|
ODA_FAIL();
|
throw OdError(res);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_CONST_ITERATOR OdVector<T, A, Mm>::begin_const() const
|
{
|
return begin();
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::begin_non_const()
|
{
|
return begin();
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_CONST_ITERATOR OdVector<T, A, Mm>::end_const() const
|
{
|
return end();
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::end_non_const()
|
{
|
return end();
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::begin()
|
{
|
return (!isEmpty() ? m_pData : NULL);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_CONST_ITERATOR OdVector<T, A, Mm>::begin() const
|
{
|
return (!isEmpty() ? m_pData : NULL);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::end()
|
{
|
return (!isEmpty() ? m_pData + m_logicalLength : NULL);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_CONST_ITERATOR OdVector<T, A, Mm>::end() const
|
{
|
return (!isEmpty() ? m_pData + m_logicalLength : NULL);
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::insert(VEC_ITERATOR before, VEC_CONST_ITERATOR first, VEC_CONST_ITERATOR afterLast)
|
{
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
const VEC_SIZE_TYPE index = (VEC_SIZE_TYPE)(before - begin_const());
|
|
if(index <= m_logicalLength && afterLast >= first)
|
{
|
if(afterLast > first)
|
{
|
const VEC_SIZE_TYPE numElem = (VEC_SIZE_TYPE)(afterLast - first);
|
const VEC_SIZE_TYPE newLogicalLength = oldLogicalLength + numElem;
|
|
if(newLogicalLength > m_physicalLength)
|
reallocate(newLogicalLength, first < begin() || first >= end());
|
|
A::constructn(m_pData + oldLogicalLength, first, numElem);
|
|
m_logicalLength = newLogicalLength;
|
|
T* pData = m_pData + index;
|
|
if(index != oldLogicalLength)
|
A::move(pData + numElem, pData, oldLogicalLength - index);
|
|
A::copy(pData, first, numElem);
|
}
|
}
|
else
|
riseError(eInvalidInput);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::insert(VEC_ITERATOR before, VEC_SIZE_TYPE numElem, const T& value)
|
{
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
const VEC_SIZE_TYPE newLogicalLength = oldLogicalLength + numElem;
|
const VEC_SIZE_TYPE index = (VEC_SIZE_TYPE)(before - begin_const());
|
|
if(newLogicalLength > m_physicalLength)
|
reallocate(newLogicalLength, &value < begin() || &value >= end());
|
|
A::constructn(m_pData + oldLogicalLength, numElem, value);
|
|
m_logicalLength = newLogicalLength;
|
|
T* pData = m_pData + index;
|
|
if(index != oldLogicalLength)
|
A::move(pData + numElem, pData, oldLogicalLength - index);
|
|
while(numElem--)
|
pData[numElem] = value;
|
|
return (begin_non_const() + index);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::insert(VEC_ITERATOR before, const T& value)
|
{
|
const VEC_SIZE_TYPE index = (VEC_SIZE_TYPE)(before - begin_const());
|
|
insertAt(index, value);
|
|
return (begin_non_const() + index);
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::insertAt(VEC_SIZE_TYPE index, const T& value)
|
{
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
const VEC_SIZE_TYPE newLogicalLength = oldLogicalLength + 1;
|
|
if(index == oldLogicalLength)
|
resize(newLogicalLength, value);
|
else if(index < oldLogicalLength)
|
{
|
if(newLogicalLength > m_physicalLength)
|
reallocate(newLogicalLength, &value < begin() || &value >= end());
|
|
A::construct(m_pData + oldLogicalLength);
|
|
++m_logicalLength;
|
|
T* pData = m_pData + index;
|
|
A::move(pData + 1, pData, oldLogicalLength - index);
|
|
m_pData[index] = value;
|
}
|
else
|
riseError(eInvalidIndex);
|
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::removeAt(VEC_SIZE_TYPE index)
|
{
|
assertValid(index);
|
|
const VEC_SIZE_TYPE newLogicalLength = m_logicalLength - 1;
|
|
if(index < newLogicalLength)
|
{
|
T* pData = m_pData + index;
|
A::move(pData, pData + 1, newLogicalLength - index);
|
}
|
|
resize(newLogicalLength);
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::removeSubArray(VEC_SIZE_TYPE startIndex, VEC_SIZE_TYPE endIndex)
|
{
|
if(!isValid(startIndex) || startIndex > endIndex)
|
riseError(eInvalidIndex);
|
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
|
T* pData = m_pData;
|
|
++endIndex;
|
|
const VEC_SIZE_TYPE numElem = endIndex - startIndex;
|
|
A::move(pData + startIndex, pData + endIndex, oldLogicalLength - endIndex);
|
A::destroy(pData + oldLogicalLength - numElem, numElem);
|
|
m_logicalLength -= numElem;
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::remove(const T& value, VEC_SIZE_TYPE startIndex)
|
{
|
VEC_SIZE_TYPE index = 0;
|
if(find(value, index, startIndex))
|
{
|
removeAt(index);
|
return true;
|
}
|
return false;
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::resize(VEC_SIZE_TYPE logicalLength, const T& value)
|
{
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
const int lengthDiff = logicalLength - oldLogicalLength;
|
|
if(lengthDiff > 0)
|
{
|
if(logicalLength > m_physicalLength)
|
reallocate(logicalLength, &value < begin() || &value >= end());
|
|
A::constructn(m_pData + oldLogicalLength, lengthDiff, value);
|
}
|
else if(lengthDiff < 0)
|
A::destroy(m_pData + logicalLength, -lengthDiff);
|
|
m_logicalLength = logicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::resize(VEC_SIZE_TYPE logicalLength)
|
{
|
const VEC_SIZE_TYPE oldLogicalLength = m_logicalLength;
|
const int lengthDiff = logicalLength - oldLogicalLength;
|
|
if(lengthDiff > 0)
|
{
|
if(logicalLength > m_physicalLength)
|
reallocate(logicalLength, true);
|
A::constructn(m_pData + oldLogicalLength, lengthDiff);
|
}
|
else if(lengthDiff < 0)
|
A::destroy(m_pData + logicalLength, -lengthDiff);
|
|
m_logicalLength = logicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::size() const
|
{
|
return m_logicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::empty() const
|
{
|
return (m_logicalLength == 0);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::capacity() const
|
{
|
return m_physicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::reserve(VEC_SIZE_TYPE reserveLength)
|
{
|
if(m_physicalLength < reserveLength)
|
setPhysicalLength(reserveLength);
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::assign(VEC_CONST_ITERATOR first, VEC_CONST_ITERATOR afterLast)
|
{
|
erase(begin_non_const(), end_non_const());
|
|
insert(begin_non_const(), first, afterLast);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::erase(VEC_ITERATOR first, VEC_ITERATOR afterLast)
|
{
|
const VEC_SIZE_TYPE index = (VEC_SIZE_TYPE)(first - begin_const());
|
|
if(first != afterLast)
|
removeSubArray(index, (VEC_SIZE_TYPE)(afterLast - begin_const() - 1));
|
|
return (begin_non_const() + index);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::erase(VEC_ITERATOR it)
|
{
|
const VEC_SIZE_TYPE index = (VEC_SIZE_TYPE)(it - begin_const());
|
|
removeAt(index);
|
|
return (begin_non_const() + index);
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::clear()
|
{
|
erase(begin_non_const(), end_non_const());
|
}
|
|
template <class T, class A, class Mm>
|
inline void OdVector<T, A, Mm>::push_back(const T& value)
|
{
|
insertAt(m_logicalLength, value);
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::contains(const T& value, VEC_SIZE_TYPE startIndex) const
|
{
|
VEC_SIZE_TYPE index;
|
|
return find(value, index, startIndex);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::length() const
|
{
|
return m_logicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::isEmpty() const
|
{
|
return (m_logicalLength == 0);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::logicalLength() const
|
{
|
return m_logicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::physicalLength() const
|
{
|
return m_physicalLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline int OdVector<T, A, Mm>::growLength() const
|
{
|
return m_growLength;
|
}
|
|
template <class T, class A, class Mm>
|
inline const T* OdVector<T, A, Mm>::asArrayPtr() const
|
{
|
return m_pData;
|
}
|
|
template <class T, class A, class Mm>
|
inline const T* OdVector<T, A, Mm>::getPtr() const
|
{
|
return m_pData;
|
}
|
|
template <class T, class A, class Mm>
|
inline T* OdVector<T, A, Mm>::asArrayPtr()
|
{ // OdArray::asArrayPtr invokes non-const version of data() method which checks length and return null.
|
// Constant version of asArrayPtr and getPtr will return m_pData as is for OdArray too.
|
return (length()) ? m_pData : NULL;
|
}
|
|
template <class T, class A, class Mm>
|
inline const T& OdVector<T, A, Mm>::operator[](VEC_SIZE_TYPE index) const
|
{
|
assertValid(index);
|
return m_pData[index];
|
}
|
|
template <class T, class A, class Mm>
|
inline T& OdVector<T, A, Mm>::operator[](VEC_SIZE_TYPE index)
|
{
|
assertValid(index);
|
return m_pData[index];
|
}
|
|
template <class T, class A, class Mm>
|
inline T& OdVector<T, A, Mm>::at(VEC_SIZE_TYPE index)
|
{
|
assertValid(index);
|
return m_pData[index];
|
}
|
|
template <class T, class A, class Mm>
|
inline const T& OdVector<T, A, Mm>::at(VEC_SIZE_TYPE index) const
|
{
|
assertValid(index);
|
return m_pData[index];
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::setAt(VEC_SIZE_TYPE index, const T& value)
|
{
|
assertValid(index);
|
|
m_pData[index] = value;
|
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline const T& OdVector<T, A, Mm>::getAt(VEC_SIZE_TYPE index) const
|
{
|
assertValid(index);
|
return m_pData[index];
|
}
|
|
template <class T, class A, class Mm>
|
inline T& OdVector<T, A, Mm>::first()
|
{
|
return m_pData[0];
|
}
|
|
template <class T, class A, class Mm>
|
inline const T& OdVector<T, A, Mm>::first() const
|
{
|
return m_pData[0];
|
}
|
|
template <class T, class A, class Mm>
|
inline T& OdVector<T, A, Mm>::last()
|
{
|
return m_pData[m_logicalLength - 1];
|
}
|
|
template <class T, class A, class Mm>
|
inline const T& OdVector<T, A, Mm>::last() const
|
{
|
return m_pData[m_logicalLength - 1];
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_SIZE_TYPE OdVector<T, A, Mm>::append(const T& value)
|
{
|
insertAt(m_logicalLength, value);
|
return (m_logicalLength - 1);
|
}
|
|
template <class T, class A, class Mm>
|
inline VEC_ITERATOR OdVector<T, A, Mm>::append()
|
{
|
const VEC_SIZE_TYPE index = append(T());
|
return (begin_non_const() + index);
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::append(const OdVector<T, A, Mm>& vec)
|
{
|
insert(end_non_const(), vec.begin(), vec.end());
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::removeFirst()
|
{
|
return removeAt(0);
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::removeLast()
|
{
|
return removeAt(m_logicalLength - 1);
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::operator==(const OdVector<T, A, Mm>& vec) const
|
{
|
if(m_logicalLength == vec.m_logicalLength)
|
{
|
for(VEC_SIZE_TYPE i = 0; i < m_logicalLength; ++i)
|
{
|
if(m_pData[i] != vec.m_pData[i])
|
return false;
|
}
|
return true;
|
}
|
return false;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::setAll(const T& value)
|
{
|
for(VEC_SIZE_TYPE i = 0; i < m_logicalLength; ++i)
|
m_pData[i] = value;
|
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline bool OdVector<T, A, Mm>::find(const T& value, VEC_SIZE_TYPE& index, VEC_SIZE_TYPE startIndex) const
|
{
|
if(!isEmpty())
|
{
|
assertValid(startIndex);
|
|
for(VEC_SIZE_TYPE i = startIndex; i < m_logicalLength; ++i)
|
{
|
if(m_pData[i] == value)
|
{
|
index = i;
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::setLogicalLength(VEC_SIZE_TYPE logicalLength)
|
{
|
resize(logicalLength);
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::setPhysicalLength(VEC_SIZE_TYPE physicalLength)
|
{
|
if(physicalLength == 0)
|
{
|
release();
|
|
m_pData = NULL;
|
m_physicalLength = 0;
|
}
|
else if(physicalLength != m_physicalLength)
|
reallocate(physicalLength, true, true);
|
|
if(m_physicalLength < m_logicalLength)
|
m_logicalLength = m_physicalLength;
|
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::setGrowLength(int growLength)
|
{
|
if(growLength != 0)
|
m_growLength = growLength;
|
else
|
ODA_FAIL();
|
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::reverse()
|
{
|
if(!isEmpty())
|
{
|
T value;
|
VEC_ITERATOR it1 = begin_non_const();
|
VEC_ITERATOR it2 = end_non_const();
|
|
--it2;
|
|
while(it1 < it2)
|
{
|
value = *it1;
|
*it1 = *it2;
|
*it2 = value;
|
|
++it1;
|
--it2;
|
}
|
}
|
return *this;
|
}
|
|
template <class T, class A, class Mm>
|
inline OdVector<T, A, Mm>& OdVector<T, A, Mm>::swap(VEC_SIZE_TYPE firstIndex, VEC_SIZE_TYPE secondIndex)
|
{
|
if(!isValid(firstIndex) || !isValid(secondIndex))
|
riseError(eInvalidIndex);
|
|
if(firstIndex != secondIndex)
|
{
|
const T value = m_pData[firstIndex];
|
m_pData[firstIndex] = m_pData[secondIndex];
|
m_pData[secondIndex] = value;
|
}
|
|
return *this;
|
}
|
|
|
#include "TD_PackPop.h"
|
|
typedef OdVector<int, OdMemoryAllocator<int> > OdIntVector;
|
typedef OdVector<OdUInt32, OdMemoryAllocator<OdUInt32> > OdUInt32Vector;
|
typedef OdVector<OdInt32, OdMemoryAllocator<OdInt32> > OdInt32Vector;
|
typedef OdVector<OdUInt8, OdMemoryAllocator<OdUInt8> > OdUInt8Vector;
|
typedef OdVector<OdUInt64, OdMemoryAllocator<OdUInt64> > OdUInt64Vector;
|
#ifdef OD_GEPNT3D_H
|
typedef OdVector<OdGePoint3d, OdMemoryAllocator<OdGePoint3d> > OdGePoint3dVector;
|
#endif
|
#ifdef OD_GEVEC3D_H
|
typedef OdVector<OdGeVector3d, OdMemoryAllocator<OdGeVector3d> > OdGeVector3dVector;
|
#endif
|
|
#endif // OdVector_H_INCLUDED
|
