__ARRAY.cpp

Go to the documentation of this file.

#ifdef __DCL_INTERNAL__
 
#ifdef __COMPILE_StringArray__
    #define THIS_NAME               __szStringArray_cpp__
    #define THIS_VALUE              __T("dcl/__ARRAY.cpp/String")
    #define ARRAY_T                 StringArray
    #define ELEMENT_T               String
    #define CONST_ELEMENT_REF       const String&
    #define HAVE_CONSTRUCTOR        1
#elif defined(__COMPILE_ByteStringArray__)
    #define THIS_NAME               __szByteStringArray_cpp__
    #define THIS_VALUE              __T("dcl/__ARRAY.cpp/ByteString")
    #define ARRAY_T                 ByteStringArray
    #define ELEMENT_T               ByteString
    #define CONST_ELEMENT_REF       const ByteString&
    #define HAVE_CONSTRUCTOR        1
#elif defined(__COMPILE_PointerArray__)
    #define THIS_NAME               __szPointerArray_cpp__
    #define THIS_VALUE              __T("dcl/__ARRAY.cpp/void*")
    #define ARRAY_T                 PointerArray
    #define ELEMENT_T               void*
    #define CONST_ELEMENT_REF       const void*
    #define HAVE_CONSTRUCTOR        0
#elif defined(__COMPILE_StringStringArray__)
    #define THIS_NAME               __szStringStringArray_cpp__
    #define THIS_VALUE              __T("dcl/__ARRAY.cpp/StringString")
    #define ARRAY_T                 StringStringArray
    #define ELEMENT_T               StringString
    #define CONST_ELEMENT_REF       const StringString&
    #define HAVE_CONSTRUCTOR        1
#endif
 
#if __DCL_HAVE_THIS_FILE__
    static const char_t THIS_NAME[] = THIS_VALUE;
    #undef __THIS_FILE__
    #define __THIS_FILE__   THIS_NAME
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
    #undef __DCL_ALLOC_LEVEL
    #define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif

 
IMPLEMENT_CLASSINFO(ARRAY_T, Object)
 
String ARRAY_T::toString() const
{
    StringBuilder r = __T("{");
    for (ConstIterator it = begin(); it != end(); it++)
    {
        if (it != begin())
            r += __T(", ");
#ifdef __COMPILE_StringArray__
        r += __T("\"");
        r += String::escape((*it), (*it).length());
        r += __T("\"");
#elif defined(__COMPILE_ByteStringArray__)
        r += __T("\"");
        r += String::tryString((*it), 8);
        r += __T("\"");
#elif defined(__COMPILE_PointerArray__)
        r.format(__T("%p"), (*it));
#else
        r += (*it).toString();
#endif
    }
    r += __T("}");
    return r;
}
 
#undef constructElements
#undef destructElements
 
#if HAVE_CONSTRUCTOR
inline
void
ARRAY_T::constructElements(ELEMENT_T* _pElements, size_t _size)
{
    for(; _size; _size--, _pElements++)
    {
#if __DCL_HAVE_ALLOC_DEBUG
    #undef new
#endif
 
        new((void*)_pElements) ELEMENT_T;
 
#if __DCL_HAVE_ALLOC_DEBUG
    #define new __DCL_DEBUG_NEW
#endif
    }
}
 
inline
void
ARRAY_T::destructElements(ELEMENT_T* _pElements, size_t _size)
{
    for( ; _size; _size--, _pElements++)
    {
        _pElements->~ELEMENT_T();
    }
}
#else
    #define constructElements(_pElements, _size)
    #define destructElements(_pElements, _size)
#endif
 
ARRAY_T::ARRAY_T(size_t _size)
{
    __pData = NULL;
    resize(_size);
}
 
ARRAY_T::ARRAY_T(const ARRAY_T& _src)
{
    __pData = NULL;
    *this = _src;
}
 
ARRAY_T::~ARRAY_T()
{
    clear();
    free(__buf());
}
 
const
ARRAY_T&
ARRAY_T::operator=(const ARRAY_T& _src)
{
    if (&_src != this)
    {
        resize(_src.size());
        for(size_t i = 0; i < _src.size(); i++)
            __pData[i] = _src.__pData[i];
    }
    return *this;
}
 
void
ARRAY_T::clear()
{
    if (size() > 0)
    {
        destructElements(__pData, size());
        __size() = 0;
    }
}
 
void
ARRAY_T::shrink()
{
    if (size() <__maxSize())
    {
        Buffer* buf = (Buffer*) realloc(__buf(), sizeof(Buffer) + size() * sizeof(ELEMENT_T));
        // FIXME!
        // if (buf == NULL)
        //      throw new BadAllocException();
        __DCL_ASSERT(buf != NULL);
 
        buf->__maxSize = buf->__size;
        __pData = buf->data();
    }
}
 
void
ARRAY_T::resize(size_t _size)
{
    if (__pData != NULL)
    {
        if (size() == _size)
            return;
 
        if (size() > _size)
        {
            destructElements(__pData + _size, size() - _size);
            __size() = _size;
            return;
        }
    }
 
    if (__pData == NULL || __maxSize() < _size)
    {
        Buffer* buf = NULL;
        if (__pData == NULL)
        {
            buf = (Buffer*) malloc(sizeof(Buffer) + _size * sizeof(ELEMENT_T));
            // FIXME!
            // if (buf == NULL)
            //      throw new BadAllocException();
            __DCL_ASSERT(buf != NULL);
 
            buf->__size = 0;
        }
        else
        {
            buf = (Buffer*) realloc(__buf(), sizeof(Buffer) + _size * sizeof(ELEMENT_T));
            // FIXME!
            // if (buf == NULL)
            //      throw new BadAllocException();
            __DCL_ASSERT(buf != NULL);
        }
 
        buf->__maxSize = _size;
        __pData = buf->data();
        memset((void*)(__pData + buf->__size), 0, (_size - buf->__size) * sizeof(ELEMENT_T));
    }
 
    constructElements(__pData + size(), _size - size());
    __size() = _size;
}
 
ARRAY_T::Iterator
ARRAY_T::insert(Iterator _pos, CONST_ELEMENT_REF _element)
{
    __DCL_ASSERT_PARAM(begin() <= _pos);
    __DCL_ASSERT_PARAM(_pos <= end());
 
    size_t index = _pos - __pData;
    insert(index, _element);
    return __pData + index + 1;
}
 
ARRAY_T&
ARRAY_T::insert(size_t _index, CONST_ELEMENT_REF _element)
{
    __DCL_ASSERT_HANDLE(__pData != NULL);
    __DCL_ASSERT_PARAM(_index <= size());
 
    size_t newSize = size() + 1;
    if (__maxSize() < newSize)
    {
        Buffer* buf =  (Buffer*) realloc(__buf(), sizeof(Buffer) + newSize * sizeof(ELEMENT_T)); 
        // FIXME!
        // if (buf == NULL)
        //      throw new BadAllocException();
        __DCL_ASSERT(buf != NULL);
 
        buf->__maxSize = newSize;
        __pData = buf->data();
 
        if (_index < buf->__size)
            memmove((void*)(__pData + _index + 1), (const void*)(__pData + _index),
                sizeof(ELEMENT_T) * (buf->__size - _index));
    }
 
    constructElements(__pData + _index, 1);
    __size() = newSize;
    __pData[_index] = (ELEMENT_T) _element;
    return *this;
}
 
ARRAY_T&
ARRAY_T::add(const ARRAY_T& _src)
{
    if (_src.size() > 0)
    {
        size_t newSize = size() + _src.size();
        if (__maxSize() < newSize)
        {
            Buffer* buf =  (Buffer*) realloc(__buf(), sizeof(Buffer) + newSize * sizeof(ELEMENT_T));
            // FIXME!
            // if (buf == NULL)
            //      throw new BadAllocException();
            __DCL_ASSERT(buf != NULL);
 
            __pData = buf->data();
        }
 
        constructElements(__pData + size(), _src.size());
        for(size_t i = 0; i < _src.size(); i++)
            __pData[size() + i] = _src.__pData[i];
 
        __maxSize() = __size() = newSize;
    }
    return *this;
}
 
ARRAY_T::Iterator
ARRAY_T::find(CONST_ELEMENT_REF _element)
{
    Iterator it = begin();
    for ( ; it != end(); it++)
    {
        if (*it == _element)
            break;
    }
    return it;
}
 
ARRAY_T&
ARRAY_T::erase(size_t _index, size_t _size)
{
    __DCL_ASSERT_PARAM(_index + _size <= size());
    if (_size > 0)
    {
        destructElements(__pData + _index, _size);
        if (_index + _size < size())
            memmove((void*)(__pData + _index), (const void*)(__pData + _index + _size),
                 (size() -  (_index  + _size)) * sizeof(ELEMENT_T));
        __size() -= _size;
    }
    return *this;
}
 
#if __DCL_HAVE_THIS_FILE__
    #undef __THIS_FILE__
    #define __THIS_FILE__   __T(__FILE__)
#endif
 
#undef THIS_NAME
#undef THIS_VALUE
#undef ARRAY_T
#undef ELEMENT_T
#undef CONST_ELEMENT_REF
#undef HAVE_CONSTRUCTOR
 
#endif      // __DCL_INTERNAL__