Array< ELEMENT > Class Template Reference

#include <ArrayT.h>

Inheritance diagram for Array< ELEMENT >:

Classes
struct	Buffer

Public Member Functions
virtual	~Array ()
	Array (size_t _size=0)
	Array (const Array< ELEMENT > &_src)
const Array< ELEMENT > &	operator= (const Array< ELEMENT > &_src)
ConstIterator	begin () const
ConstIterator	end () const
Iterator	begin ()
Iterator	end ()
void	clear ()
void	shrink ()
void	resize (size_t _size)
Iterator	insert (Iterator _pos, const ELEMENT &_element)
Array< ELEMENT > &	insert (size_t _index, const ELEMENT &_element)
Array< ELEMENT > &	add (const ELEMENT &_element)
Array< ELEMENT > &	add (const Array< ELEMENT > &_src)
Iterator	find (const ELEMENT &_element)
Iterator	erase (Iterator _pos)
Iterator	erase (Iterator _first, Iterator _last)
Array< ELEMENT > &	erase (size_t _index)
Array< ELEMENT > &	erase (size_t _index, size_t _size)
size_t	index (Iterator _pos) const
size_t	size () const
bool	isEmpty () const
ELEMENT &	operator[] (size_t _index)
ELEMENT	operator[] (size_t _index) const
ELEMENT *	data () const
size_t	size (ConstIterator _first, ConstIterator _last) const
size_t	size (Iterator _first, Iterator _last) const
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
Buffer *	__buf () const
size_t &	__size () const
size_t &	__maxSize () const
void	constructElements (ELEMENT *_pElements, size_t _size)
void	destructElements (ELEMENT *_pElements, size_t _size)
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Protected Attributes
ELEMENT *	__pData

Detailed Description

template<typename ELEMENT>
class Array< ELEMENT >

ELEMENT에 대한 배열을 표현한다.

Definition at line 41 of file ArrayT.h.

Constructor & Destructor Documentation

~Array()

template<typename ELEMENT>

Array< ELEMENT >::~Array ( )

virtual

Definition at line 324 of file ArrayT.h.

{
    clear();
    free(__buf());
}

Array() [1/2]

template<typename ELEMENT>

Array< ELEMENT >::Array

(

size_t

_size = 0

)

Definition at line 310 of file ArrayT.h.

{
    __pData = NULL;
    resize(_size);
}

Array() [2/2]

template<typename ELEMENT>

Array< ELEMENT >::Array

(

const Array< ELEMENT > &

_src

)

Definition at line 317 of file ArrayT.h.

{
    __pData = NULL;
    *this = _src;
}

Member Function Documentation

__buf()

template<typename ELEMENT>

Buffer * Array< ELEMENT >::__buf ( ) const

inlineprotected

Definition at line 99 of file ArrayT.h.

{ return (Buffer*) __pData - 1; }

__maxSize()

template<typename ELEMENT>

size_t & Array< ELEMENT >::__maxSize ( ) const

inlineprotected

Definition at line 101 of file ArrayT.h.

{ return __buf()->__maxSize; }

__size()

template<typename ELEMENT>

size_t & Array< ELEMENT >::__size ( ) const

inlineprotected

Definition at line 100 of file ArrayT.h.

{ return __buf()->__size; }

add() [1/2]

template<typename ELEMENT>

Array< ELEMENT > & Array< ELEMENT >::add

(

const Array< ELEMENT > &

_src

)

Definition at line 464 of file ArrayT.h.

{
    if (_src.size() > 0)
    {
        size_t newSize = size() + _src.size();
        if (__maxSize() < newSize)
        {
            Buffer* buf =  (Buffer*) realloc(__buf(), sizeof(Buffer) + newSize * sizeof(ELEMENT));
            // 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;
}

add() [2/2]

template<typename ELEMENT>

Array< ELEMENT > & Array< ELEMENT >::add ( const ELEMENT & _element )

inline

Definition at line 144 of file ArrayT.h.

{
    return insert(size(), _element);
}

begin() [1/2]

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::begin ( )

inline

Definition at line 128 of file ArrayT.h.

{
    return __pData;
}

begin() [2/2]

template<typename ELEMENT>

Array< ELEMENT >::ConstIterator Array< ELEMENT >::begin ( ) const

inline

Definition at line 112 of file ArrayT.h.

{
    return (const ELEMENT*) __pData;
}

clear()

template<typename ELEMENT>

void Array< ELEMENT >::clear

(

)

Definition at line 346 of file ArrayT.h.

{
    if (size() > 0)
    {
        destructElements(__pData, size());
        __size() = 0;
    }
}

constructElements()

template<typename ELEMENT>

void Array< ELEMENT >::constructElements ( ELEMENT * _pElements, size_t _size )

inlineprotected

Definition at line 282 of file ArrayT.h.

{
    for(; _size; _size--, _pElements++)
    {
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
#endif
 
        new((void*)_pElements) ELEMENT;
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
    }
}

data()

template<typename ELEMENT>

ELEMENT * Array< ELEMENT >::data ( ) const

inline

Definition at line 231 of file ArrayT.h.

{
    return __pData;
}

destructElements()

template<typename ELEMENT>

void Array< ELEMENT >::destructElements ( ELEMENT * _pElements, size_t _size )

inlineprotected

Definition at line 301 of file ArrayT.h.

{
    for( ; _size; _size--, _pElements++)
    {
        _pElements->~ELEMENT();
    }
}

end() [1/2]

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::end ( )

inline

Definition at line 136 of file ArrayT.h.

{
    return __pData + size();
}

end() [2/2]

template<typename ELEMENT>

Array< ELEMENT >::ConstIterator Array< ELEMENT >::end ( ) const

inline

Definition at line 120 of file ArrayT.h.

{
    return (const ELEMENT*) __pData + size();
}

erase() [1/4]

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::erase ( Iterator _first, Iterator _last )

inline

Definition at line 168 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(begin() <= _first);
    __DCL_ASSERT_PARAM(_last <= end());
    erase(_first - begin(), _last - _first);
    return _first;
}

erase() [2/4]

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::erase ( Iterator _pos )

inline

Definition at line 152 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(begin() <= _pos);
    __DCL_ASSERT_PARAM(_pos < end());
#if 0
    erase(_pos - begin(), 1);
    return _pos;
#endif
    size_t index = _pos - begin();
    erase(index, 1);
    return __pData + index;
}

erase() [3/4]

template<typename ELEMENT>

Array< ELEMENT > & Array< ELEMENT >::erase ( size_t _index )

inline

Definition at line 179 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(_index < size());
    return erase(_index, 1);
}

erase() [4/4]

template<typename ELEMENT>

Array< ELEMENT > & Array< ELEMENT >::erase	(	size_t	_index,
		size_t	_size )

Definition at line 504 of file ArrayT.h.

{
    __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));
        __size() -= _size;
    }
    return *this;
}

find()

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::find

(

const ELEMENT &

_element

)

Definition at line 491 of file ArrayT.h.

{
    Iterator it = begin();
    for ( ; it != end(); it++)
    {
        if (*it == _element)
            break;
    }
    return it;
}

index()

template<typename ELEMENT>

size_t Array< ELEMENT >::index ( Iterator _pos ) const

inline

Definition at line 188 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(__pData <= _pos);
    return _pos - __pData;
}

insert() [1/2]

template<typename ELEMENT>

Array< ELEMENT >::Iterator Array< ELEMENT >::insert	(	Iterator	_pos,
		const ELEMENT &	_element )

Definition at line 422 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(begin() <= _pos);
    __DCL_ASSERT_PARAM(_pos <= end());
 
    size_t index = _pos - __pData;
    insert(index, _element);
    return __pData + index + 1;
}

insert() [2/2]

template<typename ELEMENT>

Array< ELEMENT > & Array< ELEMENT >::insert	(	size_t	_index,
		const ELEMENT &	_element )

Definition at line 434 of file ArrayT.h.

{
    __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)); 
        // 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) * (buf->__size - _index));
    }
 
    constructElements(__pData + _index, 1);
    __size() = newSize;
    __pData[_index] = (ELEMENT) _element;
    return *this;
}

isEmpty()

template<typename ELEMENT>

bool Array< ELEMENT >::isEmpty ( ) const

inline

Definition at line 205 of file ArrayT.h.

{
    return size() == 0;
}

operator=()

template<typename ELEMENT>

const Array< ELEMENT > & Array< ELEMENT >::operator=

(

const Array< ELEMENT > &

_src

)

Definition at line 333 of file ArrayT.h.

{
    if (&_src != this)
    {
        resize(_src.size());
        for(size_t i = 0; i < _src.size(); i++)
            __pData[i] = _src.__pData[i];
    }
    return *this;
}

operator[]() [1/2]

template<typename ELEMENT>

ELEMENT & Array< ELEMENT >::operator[] ( size_t _index )

inline

Definition at line 213 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(_index < size());
    return __pData[_index];
}

operator[]() [2/2]

template<typename ELEMENT>

ELEMENT Array< ELEMENT >::operator[] ( size_t _index ) const

inline

Definition at line 222 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(_index < size());
    return __pData[_index];
}

resize()

template<typename ELEMENT>

void Array< ELEMENT >::resize

(

size_t

_size

)

Definition at line 374 of file ArrayT.h.

{
    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));
            // FIXME!
            // if (buf == NULL)
            //      throw new BadAllocException();
            __DCL_ASSERT(buf != NULL);
 
            buf->__size = 0;
        }
        else
        {
            buf = (Buffer*) realloc(__buf(), sizeof(Buffer) + _size * sizeof(ELEMENT));
            // 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));
    }
 
    constructElements(__pData + size(), _size - size());
    __size() = _size;
}

shrink()

template<typename ELEMENT>

void Array< ELEMENT >::shrink

(

)

Definition at line 357 of file ArrayT.h.

{
    if (size() <__maxSize())
    {
        Buffer* buf = (Buffer*) realloc(__buf(), sizeof(Buffer) + size() * sizeof(ELEMENT));
        // FIXME!
        // if (buf == NULL)
        //      throw new BadAllocException();
        __DCL_ASSERT(buf != NULL);
 
        buf->__maxSize = buf->__size;
        __pData = buf->data();
    }
}

size() [1/3]

template<typename ELEMENT>

size_t Array< ELEMENT >::size ( ) const

inline

Definition at line 197 of file ArrayT.h.

{
    return __buf()->__size;;
}

size() [2/3]

template<typename ELEMENT>

size_t Array< ELEMENT >::size ( ConstIterator _first, ConstIterator _last ) const

inline

Definition at line 239 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(_first <= _last);
    return _last - _first;
}

size() [3/3]

template<typename ELEMENT>

size_t Array< ELEMENT >::size ( Iterator _first, Iterator _last ) const

inline

Definition at line 248 of file ArrayT.h.

{
    __DCL_ASSERT_PARAM(_first <= _last);
    return _last - _first;
}

Member Data Documentation

__pData

template<typename ELEMENT>

ELEMENT* Array< ELEMENT >::__pData

protected

Definition at line 90 of file ArrayT.h.

---

The documentation for this class was generated from the following file:

• ArrayT.h