_AcArray.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
template < typename Param1 > class AcArrayMemCopyReallocator;
template <class T> class AcArrayObjectCopyReallocator
{
public:
    typedef unsigned int size_type;
 
    static inline void copy(
        T* pDestination,
        const T* pSource,
        size_type numObjects)
    {
        while (numObjects--)
        {
            *pDestination = *pSource;
            pDestination++;
            pSource++;
        }
    }
 
    static inline void move(
        T* pDestination,
        const T* pSource,
        size_type numObjects)
    {
        if (pDestination <= pSource || pDestination >= pSource + numObjects)
        {
            copy(pDestination, pSource, numObjects);
        }
        else
        {
            while (numObjects--)
            {
                pDestination[numObjects] = pSource[numObjects];
            }
        }
    }
    static inline void construct(
        T* pObject)
    {
#ifdef new
#undef new
#endif
        ::new (pObject) T;
    }
    static inline void construct(
        T* pObject,
        const T& value)
    {
#ifdef new
#undef new
#endif
        ::new (pObject) T(value);
    }
    static inline void constructn(
        T* pDestination,
        size_type numObjects,
        const T& value)
    {
        while (numObjects--)
        {
            construct(pDestination + numObjects, value);
        }
    }
 
    static inline void constructn(
        T* pDestination,
        size_type numObjects)
    {
        while (numObjects--)
        {
            construct(pDestination + numObjects);
        }
    }
 
    static inline void constructn(
        T* pDestination,
        const T* pSource,
        size_type numObjects)
    {
        while (numObjects--)
        {
            construct(pDestination, *pSource);
            pDestination++;
            pSource++;
        }
    }
 
    static inline void destroy(
        T* pObject)
    {
        pObject->~T();
        pObject = 0;
    }
 
    static inline void destroy(
        T* objects,
        size_type numObjects)
    {
        while (numObjects--)
        {
            destroy(objects + numObjects);
        }
    }
 
    static inline bool useRealloc()
    {
        return true;
    }
};
class AcGePoint2d;
class AcGePoint3d;
 
struct AcImplArrayBuffer;
template <class T> class AcImplObjectsAllocator;
template <class T, class A> class AcImplArray;
 
template < typename Param1, typename Param2 = AcArrayMemCopyReallocator<Param1> >
class AcArray
{
public:
    Param1 & at(int index)
    {
        return(mpArray.at(index));
    }
 
    Param1 & first(void)
    {
        return(mpArray.first());
    }
 
    Param1* begin(void)
    {
        return(mpArray.begin());
    }
 
    const Param1* begin(void) const
    {
        return(mpArray.begin());
    }
 
    Param1* end(void)
    {
        return(mpArray.end());
    }
 
    const Param1* end(void) const
    {
        return(mpArray.end());
    }
 
    Param1 & last(void)
    {
        return(mpArray.last());
    }
 
    Param1 & operator[](int index)
    {
        return(mpArray[index]);
    }
 
    Param1 * asArrayPtr(void)
    {
        return(mpArray.asArrayPtr());
    }
 
    Param1 const & at(int index)const
    {
        return(mpArray.at(index));
    }
 
    Param1 const & first(void)const
    {
        return(mpArray.first());
    }
 
    Param1 const & last(void)const
    {
        return(mpArray.last());
    }
 
    Param1 const & operator[](int index)const
    {
        return(mpArray[index]);
    }
 
    Param1 const * asArrayPtr(void)const
    {
        return(mpArray.asArrayPtr());
    }
 
    AcArray(AcArray<Param1, Param2> const & source)
    {
        mpArray = source.mpArray;
    }
 
    AcArray()
    {
    }
 
    AcArray(int physicalLength) : mpArray(physicalLength)
    {
    }
 
    AcArray(int physicalLength, int growLength) : mpArray(physicalLength, growLength)
    {
    }
 
    ~AcArray(void)
    {
    }
 
    bool contains(Param1 const &value, int start = 0)const
    {
        return(mpArray.contains(value, start));
    }
 
    bool find(Param1 const &value, int &index, int start = 0)const
    {
        unsigned int uIndex;
        bool result = mpArray.find(value, uIndex, start);
        if (result && uIndex < INT_MAX)
        {
            index = uIndex;
            return(result);
        }
        else
        {
            return(false);
        }
    }
 
    bool isEmpty(void)const
    {
        return(mpArray.isEmpty());
    }
 
    bool operator==(AcArray<Param1, Param2> const &array)const
    {
        return(mpArray.operator==(array.mpArray));
    }
 
    bool remove(Param1 const &value, int start = 0)
    {
        return(mpArray.remove(value, start));
    }
 
    AcArray<Param1, Param2> & append(AcArray<Param1, Param2> const &array)
    {
        mpArray.append(array.mpArray);
        return(*this);
    }
 
    AcArray<Param1, Param2> & insertAt(int index, Param1 const &value)
    {
        mpArray.insertAt(index, value);
        return(*this);
    }
 
    AcArray<Param1, Param2> & operator=(AcArray<Param1, Param2> const &array)
    {
        mpArray.operator=(array.mpArray);
        return(*this);
    }
 
    AcArray<Param1, Param2> & removeAll(void)
    {
        mpArray.clear();
        return(*this);
    }
 
    AcArray<Param1, Param2> & removeAt(int index)
    {
        mpArray.removeAt(index);
        return(*this);
    }
 
    AcArray<Param1, Param2> & removeFirst(void)
    {
        mpArray.removeFirst();
        return(*this);
    }
 
    AcArray<Param1, Param2> & removeLast(void)
    {
        mpArray.removeLast();
        return(*this);
    }
 
    AcArray<Param1, Param2> & removeSubArray(int start, int end)
    {
        mpArray.removeSubArray(start, end);
        return(*this);
    }
 
    AcArray<Param1, Param2> & reverse(void)
    {
        mpArray.reverse();
        return(*this);
    }
 
    AcArray<Param1, Param2> & setAll(Param1 const &value)
    {
        mpArray.setAll(value);
        return(*this);
    }
 
    AcArray<Param1, Param2> & setAt(int index, Param1 const &value)
    {
        mpArray.setAt(index, value);
        return(*this);
    }
 
    AcArray<Param1, Param2> & setGrowLength(int growLength)
    {
        mpArray.setGrowLength(growLength);
        return(*this);
    }
 
    AcArray<Param1, Param2> & setLogicalLength(int logicalLength)
    {
        mpArray.setLogicalLength(logicalLength);
        return(*this);
    }
 
    AcArray<Param1, Param2> & setPhysicalLength(int physicalLength)
    {
        mpArray.setPhysicalLength(physicalLength);
        return(*this);
    }
 
    AcArray<Param1, Param2> & swap(int first, int second)
    {
        mpArray.swap(first, second);
        return(*this);
    }
 
    int append(Param1 const &value)
    {
        return(mpArray.append(value));
    }
 
    int find(Param1 const &value)const
    {
        unsigned int uIndex;
        int index;
        bool result = mpArray.find(value, uIndex, 0);
        if (result && uIndex < INT_MAX)
        {
            index = uIndex;
            return(index);
        }
        else
        {
            return(-1);
        }
    }
 
    int findFrom(Param1 const &value, int start)const
    {
        unsigned int uIndex;
        int index;
        bool result = mpArray.find(value, uIndex, start);
        if (uIndex < INT_MAX)
        {
            index = uIndex;
            return(index);
        }
        else
        {
            return(-1);
        }
    }
 
    int growLength(void)const
    {
        return(mpArray.growLength());
    }
 
    int length(void)const
    {
        return(mpArray.length());
    }
 
    int logicalLength(void)const
    {
        return(mpArray.logicalLength());
    }
 
    int physicalLength(void)const
    {
        return(mpArray.physicalLength());
    }
 
protected:
    bool isValid(int index)const
    {
        return(mpArray.isValid(index));
    }
 
protected:
    AcImplArray< Param1, Param2 > mpArray;
};
 
//---------------------------------------------------------------------------------------------------------------------
 
template <class T> class AcArrayMemCopyReallocator
{
public:
    typedef unsigned int size_type;
 
    static inline void copy(T* pDestination, const T* pSource, size_type numObjects)
    {
        while (numObjects--)
        {
            *pDestination = *pSource;
            pDestination++;
            pSource++;
        }
    }
 
    static inline void move(T* pDestination, const T* pSource, size_type numObjects)
    {
        if (pDestination <= pSource || pDestination >= pSource + numObjects)
        {
            copy(pDestination, pSource, numObjects);
        }
        else
        {
            while (numObjects--)
            {
                pDestination[numObjects] = pSource[numObjects];
            }
        }
    }
 
    static inline void construct(T* pObject)
    {
#ifdef new
#undef new
#endif
        ::new (pObject) T;
    }
    static inline void construct(T* pObject, const T& value)
    {
#ifdef new
#undef new
#endif
        ::new (pObject) T(value);
    }
 
    static inline void constructn(T* pDestination, size_type numObjects, const T& value)
    {
        while (numObjects--)
        {
            construct(pDestination + numObjects, value);
        }
    }
    static inline void constructn(T* pDestination, size_type numObjects)
    {
        while (numObjects--)
        {
            construct(pDestination + numObjects);
        }
    }
    static inline void constructn(T* pDestination, const T* pSource, size_type numObjects)
    {
        while (numObjects--)
        {
            construct(pDestination, *pSource);
            pDestination++;
            pSource++;
        }
    }
 
    static inline void destroy(T* pObject)
    {
        pObject->~T();
        pObject = 0;
    }
    static inline void destroy(T* objects, size_type numObjects)
    {
        while (numObjects--)
        {
            destroy(objects + numObjects);
        }
    }
 
    static inline bool useRealloc()
    {
        return false;
    }
};
 
struct ARX_API AcImplArrayBuffer
{
    typedef unsigned int size_type;
 
    //mutable AcImplRefCounter m_nRefCounter;
    mutable int m_nRefCounter;
    int mGrowLen;
    size_type mPhysicalLen;
    size_type mLogicalLen;
 
    ARX_API_STATIC static AcImplArrayBuffer g_empty_array_buffer;
};
 
template <class T, class A> class AcImplArray
{
public:
    typedef typename A::size_type size_type;
    typedef T* iterator;
    typedef const T* const_iterator;
 
    struct Buffer : AcImplArrayBuffer
    {
        T* data() const { return (T*)(this + 1); }
 
        static Buffer* allocate(size_type nLength2Allocate, int nGrowBy)
        {
            size_type nBytes2Allocate = sizeof(Buffer) + nLength2Allocate * sizeof(T);
            //ODA_ASSERT(nBytes2Allocate > nLength2Allocate); // size_type overflow
            if (nBytes2Allocate > nLength2Allocate)
            {
                Buffer* pBuffer = (Buffer*)malloc(nBytes2Allocate);
                if (pBuffer)
                {
                    pBuffer->m_nRefCounter = 1;
                    pBuffer->mGrowLen = nGrowBy;
                    pBuffer->mPhysicalLen = nLength2Allocate;
                    pBuffer->mLogicalLen = 0;
                    return pBuffer;
                }
            }
            throw 6;
        }
 
        static Buffer* _default()
        {
            return (Buffer*)&g_empty_array_buffer;
        }
        void release()
        {
            //ODA_ASSERT(m_nRefCounter);
            if ((--m_nRefCounter) == 0 && this != _default())
            {
                A::destroy(data(), mLogicalLen);
                free(this);
            }
        }
        void addref() const { ++m_nRefCounter; }
    };
    class reallocator
    {
        Buffer* m_pBuffer;
        bool _may_use_realloc;
    public:
        inline reallocator(bool may_use_realloc = false) : _may_use_realloc(may_use_realloc)
        {
            if (!_may_use_realloc)
            {
                m_pBuffer = Buffer::_default();
                m_pBuffer->addref();
            }
        }
        inline void reallocate(AcImplArray* pArray, size_type nNewLen)
        {
            if (!pArray->referenced())
            {
                if (nNewLen > pArray->physicalLength())
                {
                    if (!_may_use_realloc)
                    {
                        m_pBuffer->release();
                        m_pBuffer = pArray->buffer();
                        m_pBuffer->addref(); // save buffer to ensure copy from itself would work (e.g insertAt)
                    }
                    pArray->copy_buffer(nNewLen, _may_use_realloc);
                }
            }
            else
            {
                pArray->copy_buffer(nNewLen);
            }
        }
        inline ~reallocator()
        {
            if (!_may_use_realloc) m_pBuffer->release();
        }
    };
    friend class reallocator;
    const_iterator begin_const() const
    {
        return begin();
    }
    iterator begin_non_const()
    {
        return begin();
    }
    const_iterator end_const()
    {
        return end();
    }
    iterator end_non_const()
    {
        return end();
    }
    void copy_before_write(size_type len, bool may_use_realloc = false)
    {
        if (referenced())
            copy_buffer(len);
        else if (len > physicalLength())
            copy_buffer(len, may_use_realloc);
    }
    void copy_if_referenced()
    {
        if (referenced())
        {
            copy_buffer(physicalLength());
        }
    }
    void copy_buffer(size_type len, bool may_use_realloc = false, bool force_size = false)
    {
        Buffer* pOldBuffer = buffer();
        int nGrowBy = pOldBuffer->mGrowLen;
        size_type len2 = len;
        if (!force_size)
        {
            if (nGrowBy > 0)
            {
                len2 += nGrowBy;
                len2 = ((--len2) / nGrowBy) * nGrowBy;
            }
            else
            {
                len2 = pOldBuffer->mLogicalLen;
                len2 = len2 + -nGrowBy * len2 / 100;
                if (len2 < len)
                {
                    len2 = len;
                }
            }
        }
        if (may_use_realloc && A::useRealloc() && !empty())
        {
            Buffer* pNewBuffer = reinterpret_cast<Buffer*>(realloc(pOldBuffer, len2 * sizeof(T) + sizeof(Buffer)));
            pNewBuffer->mPhysicalLen = len2;
            pNewBuffer->mLogicalLen = ( pNewBuffer->mLogicalLen < len ) ? pNewBuffer->mLogicalLen : len;
            m_pData = pNewBuffer->data();
        }
        else
        {
            Buffer* pNewBuffer = Buffer::allocate(len2, nGrowBy);
            len = ( pOldBuffer->mLogicalLen < len ) ? pOldBuffer->mLogicalLen : len;
            A::constructn(pNewBuffer->data(), pOldBuffer->data(), len);
            pNewBuffer->mLogicalLen = len;
            m_pData = pNewBuffer->data();
            pOldBuffer->release();
        }
    }
    inline void assertValid(size_type index) const
    {
        if (!isValid(index))
        {
            //throw;
        }
    }
 
    static inline void rise_error(int e)
    {
        throw e;
    }
 
public:
    // STL-like interface
 
    iterator begin()
    {
        if (!empty())
        {
            copy_if_referenced();
            return data();
        }
        return 0;
    }
    const_iterator begin() const
    {
        if (!empty())
        {
            return data();
        }
        return 0;
    }
 
    iterator end()
    {
        if (!empty())
        {
            copy_if_referenced();
            return data() + length();
        }
        return 0;
    }
    const_iterator end() const
    {
        if (!empty())
        {
            return data() + length();
        }
        return 0;
    }
 
    void insert(iterator before, const_iterator first, const_iterator afterLast)
    {
        size_type len = length();
        size_type index = (size_type)(before - begin_const());
        if (index <= len && afterLast >= first)
        {
            if (afterLast > first)
            {
                size_type num2copy = (size_type)(afterLast - first);
                reallocator r(first < begin() || first >= end());
                r.reallocate(this, len + num2copy);
                A::constructn(m_pData + len, first, num2copy);
                buffer()->mLogicalLen = len + num2copy;
                T* pDestination = m_pData + index;
                if (index != len)
                {
                    A::move(pDestination + num2copy, pDestination, len - index);
                }
                A::copy(pDestination, first, (size_type)(afterLast - first));
            }
        }
        else
        {
            rise_error(3);
        }
    }
 
    void resize(size_type logicalLength, const T& value)
    {
        size_type len = length();
        int d = logicalLength - len;
        if (d > 0)
        {
            reallocator r(m_pData > &value || &value > (m_pData + len));
            r.reallocate(this, logicalLength);
            A::constructn(m_pData + len, d, value);
        }
        else if (d < 0)
        {
            d = -d;
            if (!referenced())
            {
                A::destroy(m_pData + logicalLength, d);
            }
            else
            {
                copy_buffer(logicalLength);
            }
        }
        buffer()->mLogicalLen = logicalLength;
    }
 
    void resize(size_type logicalLength)
    {
        size_type len = length();
        int d = logicalLength - len;
        if (d > 0)
        {
            copy_before_write(len + d, true);
            A::constructn(m_pData + len, d);
        }
        else if (d < 0)
        {
            d = -d;
            if (!referenced())
            {
                A::destroy(m_pData + logicalLength, d);
            }
            else
            {
                copy_buffer(logicalLength);
            }
        }
        buffer()->mLogicalLen = logicalLength;
    }
 
    size_type size() const
    {
        return buffer()->mLogicalLen;
    }
 
    bool empty() const
    {
        return size() == 0;
    }
 
    size_type capacity() const
    {
        return buffer()->mPhysicalLen;
    }
 
    void reserve(size_type reserveLength)
    {
        if (physicalLength() < reserveLength)
        {
            setPhysicalLength(reserveLength);
        }
    }
 
    void assign(const_iterator first, const_iterator afterLast)
    {
        erase(begin_non_const(), end_non_const());
        insert(begin_non_const(), first, afterLast);
    }
 
    iterator erase(iterator first, iterator afterLast)
    {
        size_type i = (size_type)(first - begin_const());
        if (first != afterLast)
        {
            removeSubArray(i, (size_type)(afterLast - begin_const() - 1));
        }
        return begin_non_const() + i;
    }
 
    iterator erase(iterator where)
    {
        size_type i = where - begin_const();
        removeAt(i);
        return begin_non_const() + i;
    }
 
    void clear()
    {
        erase(begin_non_const(), end_non_const());
    }
 
    void push_back(const T& value)
    {
        insertAt(length(), value);
    }
 
    iterator insert(iterator before, size_type numElements, const T& value)
    {
        size_type len = length();
        size_type index = before - begin_const();
        reallocator r(m_pData > &value || &value > (m_pData + len));
        r.reallocate(this, len + numElements);
        A::constructn(m_pData + len, numElements, value);
        buffer()->mLogicalLen = len + numElements;
        T* pData = data();
        pData += index;
        if (index != len)
        {
            A::move(pData + numElements, pData, len - index);
        }
        while (numElements--)
        {
            pData[numElements] = value;
        }
        return begin_non_const() + index;
    }
 
    iterator insert(iterator before, const T& value = T())
    {
        size_type index = before - begin_const();
        insertAt(index, value);
        return (begin_non_const() + index);
    }
 
    // ARX-like interface
 
    bool contains(const T& value, size_type start = 0) const
    {
        size_type dummy;
        return find(value, dummy, start);
    }
 
    size_type length() const
    {
        return buffer()->mLogicalLen;
    }
 
    bool isEmpty() const
    {
        return length() == 0;
    }
 
    size_type logicalLength() const
    {
        return length();
    }
 
    size_type physicalLength() const
    {
        return buffer()->mPhysicalLen;
    }
 
    int growLength() const
    {
        return buffer()->mGrowLen;
    }
 
    const T* asArrayPtr() const
    {
        return data();
    }
 
    const T* getPtr() const
    {
        return data();
    }
 
    T* asArrayPtr()
    {
        copy_if_referenced();
        return data();
    }
 
    const T& operator [](size_type index) const
    {
        assertValid(index);
        return m_pData[index];
    }
    T& operator [](size_type index)
    {
        assertValid(index);
        copy_if_referenced();
        return m_pData[index];
    }
 
    T& at(size_type arrayIndex)
    {
        assertValid(arrayIndex);
        copy_if_referenced();
        return m_pData[arrayIndex];
    }
    const T& at(size_type arrayIndex) const
    {
        assertValid(arrayIndex);
        return m_pData[arrayIndex];
    }
 
    AcImplArray& setAt(size_type arrayIndex, const T& value)
    {
        assertValid(arrayIndex);
        copy_if_referenced();
        m_pData[arrayIndex] = value;
        return *this;
    }
 
    const T& getAt(size_type arrayIndex) const
    {
        assertValid(arrayIndex);
        return m_pData[arrayIndex];
    }
 
    T& first()
    {
        return *begin();
    }
    const T& first() const
    {
        return *begin();
    }
 
    T& last()
    {
        return at(length() - 1);
    }
    const T& last() const
    {
        return at(length() - 1);
    }
 
    size_type append(const T& value)
    {
        insertAt(length(), value);
        return length() - 1;
    }
 
    iterator append()
    {
        size_type i = append(T());
        return begin_non_const() + i;
    }
 
    AcImplArray& removeFirst()
    {
        return removeAt(0);
    }
 
    AcImplArray& removeLast()
    {
        return removeAt(length() - 1);
    }
 
    AcImplArray& setGrowLength(int growLength)
    {
        if (growLength != 0)
        {
            copy_if_referenced();
            buffer()->mGrowLen = growLength;
        }
        else
        {
            //ODA_FAIL();
        }
        return *this;
    }
 
    explicit AcImplArray(size_type physicalLength, int growLength = 8) : m_pData(0)
    {
        if (growLength == 0)
        {
            growLength = 8;
        }
        m_pData = Buffer::allocate(physicalLength, growLength)->data();
        reallocator r(false);
        r.reallocate(this, 1);
    }
 
    AcImplArray() : m_pData(Buffer::_default()->data())
    {
        buffer()->addref();
        reallocator r(false);
        r.reallocate(this, 1);
    }
 
    AcImplArray(const AcImplArray& source) : m_pData((T*)source.data())
    {
        buffer()->addref();
        reallocator r(false);
        r.reallocate(this, 1);
    }
 
    ~AcImplArray()
    {
        buffer()->release();
    }
 
    AcImplArray& operator =(const AcImplArray& source)
    {
        source.buffer()->addref();
        buffer()->release();
        m_pData = source.m_pData;
        return *this;
    }
 
    bool operator ==(const AcImplArray& array) const
    {
        if (length() == array.length())
        {
            for (size_type i = 0; i < length(); i++)
            {
                if (at(i) != array[i])
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
 
    AcImplArray& setAll(const T& value)
    {
        copy_if_referenced();
        T* pData = data();
        size_type n = length();
        while (n)
        {
            pData[--n] = value;
        }
        return *this;
    }
 
    AcImplArray& append(const AcImplArray& otherArray)
    {
        insert(end_non_const(), otherArray.begin(), otherArray.end());
        return *this;
    }
 
    AcImplArray& insertAt(size_type arrayIndex, const T& value)
    {
        size_type len = length();
        if (arrayIndex == len)
        {
            resize(len + 1, value);
        }
        else if (arrayIndex < len)
        {
            T temp(value);
            reallocator r(m_pData > &value || &value > (m_pData + len));
            r.reallocate(this, len + 1);
            A::construct(m_pData + len);
            ++(buffer()->mLogicalLen);
            A::move(m_pData + arrayIndex + 1, m_pData + arrayIndex, len - arrayIndex);
            m_pData[arrayIndex] = temp;
        }
        else
        {
            //rise_error(24);
            return *this;
        }
        return *this;
    }
 
    AcImplArray& removeAt(size_type arrayIndex)
    {
        if (!isValid(arrayIndex))
            return *this;
        size_type len = length();
        if (arrayIndex < --len)
        {
            copy_if_referenced();
            T* pData = data();
            A::move(pData + arrayIndex, pData + arrayIndex + 1, len - arrayIndex);
        }
        resize(len);
 
        return *this;
    }
 
    AcImplArray& removeSubArray(size_type startIndex, size_type endIndex)
    {
        if (!isValid(startIndex) || startIndex > endIndex)
        {
            //rise_error(24);
            return *this;
        }
        size_type len = length();
        copy_if_referenced();
        T* pData = data();
        if (endIndex > len - 1)
            endIndex = len - 1;
        ++endIndex;
        size_type n2remove = endIndex - startIndex;
        A::move(pData + startIndex, pData + endIndex, len - endIndex);
        A::destroy(pData + len - n2remove, n2remove);
        buffer()->mLogicalLen -= n2remove;
        return *this;
    }
 
    bool find(const T& value, size_type& findIndex, size_type start = 0) const
    {
        if (!empty())
        {
            if (start >= length())
                return false;
 
            size_type len = length();
            const T* pData = data();
            for (size_type i = start; i < len; ++i)
            {
                if (pData[i] == value)
                {
                    findIndex = i;
                    return true;
                }
            }
        }
        return false;
    }
 
    AcImplArray& setLogicalLength(size_type logLength)
    {
        resize(logLength);
        return *this;
    }
 
    AcImplArray& setPhysicalLength(size_type physLength)
    {
        if (physLength == 0)
        {
            *this = AcImplArray<T, A>();
        }
        else if (physLength != physicalLength())
        {
            copy_buffer(physLength, true, true);
        }
        return *this;
    }
 
    AcImplArray& reverse()
    {
        if (!empty())
        {
            copy_if_referenced();
            T tmp;
            iterator iter1 = begin_non_const();
            iterator iter2 = end_non_const();
            --iter2;
            while (iter1 < iter2)
            {
                tmp = *iter1;
                *iter1 = *iter2;
                *iter2 = tmp;
                ++iter1;
                --iter2;
            }
        }
        return *this;
    }
 
    AcImplArray& swap(size_type firstIndex, size_type secondIndex)
    {
        if (!isValid(firstIndex) || !isValid(secondIndex))
        {
            rise_error(24);
        }
        if (firstIndex != secondIndex)
        {
            const T tmp = at(firstIndex);
            at(firstIndex) = at(secondIndex);
            at(secondIndex) = tmp;
        }
        return *this;
    }
 
    bool remove(const T& value, size_type start = 0)
    {
        size_type i = 0;
        if (find(value, i, start))
        {
            removeAt(i);
            return true;
        }
        return false;
    }
 
    T* m_pData;
 
    bool isValid(size_type i) const
    {
        return (i >= 0 && i < length());
    }
 
    T* data()
    {
        return (length() ? m_pData : 0);
    }
 
    const T* data() const
    {
        return m_pData;
    }
 
    Buffer* buffer() const
    {
        return (reinterpret_cast<Buffer*>(const_cast<AcImplArray*>(this)->m_pData) - 1);
    }
    bool referenced() const
    {
        return (buffer()->m_nRefCounter > 1);
    }
};