// wzarray.h

#ifndef _PROGRAMCOMMON_WZARRAY_H_
#define _PROGRAMCOMMON_WZARRAY_H_

#include "wztypedef.h"

//------------------------------------------------------------------------------
/**
    @class CWzArray
*/
template <class T>
class CWzArray
{
public:
    // »ý¼ºÀÚ/¼Ò¸êÀÚ
    CWzArray( void );
    CWzArray( const CWzArray<T>& rhs );
    ~CWzArray( void );

    // ¸ðµç µ¥ÀÌŸ ÃʱâÈ­
    void Clear( void );

    // µ¥ÀÌŸ °¹¼ö¸¸ ÃʱâÈ­
    void InvalidateAll( void );
    // ±âÁ¸ µ¥ÀÌŸ Á¦°Å ÈÄ ±âº» »çÀÌÁî·Î ÀçÇÒ´ç
    void InvalidateAndShrink( void );
    // ÇØ´ç À妽ººÎÅÍ ¸ðµç µ¥ÀÌŸ ¹«È¿È­
    void InvalidateFrom( int index );

    // ÇØ´ç »çÀÌÁŭ ¸Þ¸ð¸® È®º¸(2ÀÇ ½Â¼ö)
    void EnlargeSize( int size );

    // ÇØ´ç À妽º¿¡ µ¥ÀÌŸ ¼³Á¤
    void Set( int index, const T& data );
    // xxx: ³¡¿¡¼­ºÎÅÍ »õ index »çÀÌ´Â NULL·Î ÃʱâÈ­
    void SetE( int index, const T& data );
    // ÇØ´ç À妽ºÀÇ µ¥ÀÌŸ ¾ò±â
    T& Get( int index ) const;

    // ³¡¿¡ µ¥ÀÌŸ Ãß°¡
    int Add( const T& data );
    // ³¡¿¡ 3°³ µ¥ÀÌŸ Ãß°¡
    int Adds( const T& data1, const T& data2, const T& data3 );
    // ³¡¿¡ ÇØ´ç ¼ö¸¸Å­ µ¥ÀÌŸµé Ãß°¡
    int Adds( int cnt, const T* data );

    // ÇØ´ç À妽ºÀÇ µ¥ÀÌŸ Á¦°Å
    void Remove( int index );

    // µ¥ÀÌŸ ã±â(À妽º ¹Ýȯ)
    int Find( const T& data ) const;
    // Àüü µ¥ÀÌŸ ¼ö ¾ò±â
    int GetCount( void ) const;

    // µ¥ÀÌŸ ¹è¿­ Æ÷ÀÎÅÍ ¾ò±â
    T* GetBufferPtr( void ) const;

    // operator =
    CWzArray<T>& operator = ( const CWzArray<T>& rhs );

private:
    // ÇØ´ç À妽º¸¸Å­ ¸Þ¸ð¸® È®º¸
    void MakeSureDimensionSize( int index );
    // µ¥ÀÌŸ ÇØÁ¦
    void Release( void );

private:
    // xxx: ±¸Â÷ÇÏ°Ô ÀÌ·± º¯¼ö¸¦ ¸¸µé°í ½ÍÁø ¾ÊÁö¸¸
    // ±âÁ¸¿¡ ÀÌ¹Ì ¾²·¹±â °ªÀ» ¸®ÅÏÇØ¾ß ÇÏ´Â °æ¿ì°¡ Àֱ⠶§¹®¿¡
    // Â÷¶ó¸® ÀÌ ¹æ¹ýÀÌ ÁÁÀº °Í °°¾Æ ÀÌ·¸°Ô °£´Ù.
    static T m_dummyData;

private:
    int m_numData;
    int m_size;

    T* m_data;
};

template <class T>
T CWzArray<T>::m_dummyData;

//------------------------------------------------------------------------------
/**
    »ý¼ºÀÚ¿¡¼­ ¹º°¡¸¦ »ý¼ºÇÑ´Ù´Â °ÍÀÌ ÁÁ¾Æ º¸ÀÌÁö´Â ¾ÊÁö¸¸
    ±âÁ¸¿¡ ÀÌ¹Ì ±×·¸°Ô ½á ¿Ô±â ¶§¹®¿¡ ±×³É °£´Ù.
*/
template <class T>
CWzArray<T>::CWzArray( void )
: m_numData( 0 )
, m_size( 16 )
{
    m_data = new T[m_size];
    WzAssert( m_data );

    memset(m_data, 0, sizeof( T ) * m_size);
    memset(&(CWzArray<T>::m_dummyData), 0, sizeof( T ));

}

//------------------------------------------------------------------------------
/**
*/
template <class T>
CWzArray<T>::CWzArray( const CWzArray<T>& rhs )
: m_numData( 0 )
, m_size( 0 )
, m_data( NULL )
{
    *this = rhs;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
CWzArray<T>::~CWzArray( void )
{
    Release();
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::Release( void )
{
    if( m_data )
    {
        delete [] m_data;
        m_data = NULL;
    }

    m_size = 0;
    m_numData = 0;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::Clear( void )
{
    WzAssert( m_data );

    memset( m_data, 0, sizeof( T ) * m_size );

    m_numData = 0;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::InvalidateAll( void )
{
    m_numData = 0;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::InvalidateAndShrink( void )
{
    Release();

    m_numData = 0;
    m_size = 16;
    m_data = new T[m_size];

    memset(m_data, 0, sizeof( T ) * m_size);

    WzAssert( m_data );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::InvalidateFrom( int index )
{
    m_numData = min( index, m_numData );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::MakeSureDimensionSize( int index )
{
    if( index >= m_size )
    {   
        // ³ÑÃÆÀ¸¸é Å©±â¸¦ ´Ã·ÁÁØ´Ù.
        int newSize = ( m_size > 0 ? m_size * 2 : 16 );
        while( newSize <= index )
        {
            newSize *= 2;
        }

        // »õ·Î¿î »çÀÌÁŭ Àӽà ¹öÆÛ »ý¼º
        T* tmpBuf = new T[newSize];
        WzAssert( tmpBuf );

        memset(tmpBuf, 0, sizeof( T ) * newSize);

        // ±âÁ¸ µ¥ÀÌŸ°¡ ÀÖ´Â °æ¿ì º¹»ç
        if( m_data )
        {
            memcpy( tmpBuf, m_data, sizeof( T ) * m_size );
            delete [] m_data;
        }

        m_data = tmpBuf;
        m_size = newSize;
    }
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::EnlargeSize( int size )
{
    MakeSureDimensionSize( size );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::Set( int index, const T& data )
{
    MakeSureDimensionSize( index );

    WzAssert( m_data );

    m_data[index] = data;
    m_numData = max( index + 1, m_numData );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::SetE( int index, const T& data )
{
    // ±âÁ¸ µ¥ÀÌŸ ¼ö ÀúÀå
    int prevNum = m_numData;
    WzAssert( prevNum >= 0 );

    // µ¥ÀÌŸ ¼³Á¤
    Set( index, data );

    // »õ index°¡ ±âÁ¸ µ¥ÀÌŸ ¼öº¸´Ù Å« °æ¿ì
    if( index > prevNum )
    {
        // Áß°£À» NULL·Î ¼³Á¤
        for( int i = prevNum; i < index; ++i )
        {
            m_data[i] = NULL;
        }
    }
}

//------------------------------------------------------------------------------
/**
    xxx : indexÀÇ À¯È¿ ¹üÀ§´Â ¾îµð¼­ºÎÅÍ ¾îµð±îÁöÀΰ¡?

    1. (0 ~ m_numData) : À¯Àú°¡ °ªÀ» ¼³Á¤ÇÑ °÷±îÁö
    2. (0 ~ m_size) : ¹öÆÛ Å©±â±îÁö
    
    ÀÏ´Ü 1¹øÀÇ °æ¿ì ¿£Áø ³»ºÎ¿¡¼­ ¿Àµ¿ÀÛÇÏ´Â ¹Ù¶÷¿¡ ±âÁ¸µ¥·Î 2¹øÀ¸·Î üũÇß´Ù.
*/
template <class T>
T& CWzArray<T>::Get( int index ) const
{
    // WzAssert( index >= 0 && index < m_numData );

    // TODO: À߸øµÈ Object°¡ À־ °è¼Ó WzAssert °¡ ¹ß»ýÇÏ¿© ÀÏ´Ü ¸·¾ÆµÎ¾úÀ½(³ªÁß¿¡ Ç®¾îÁÖ¼¼¿ä by kiki)
    // WzAssert( index >= 0 && index < m_size );

    // if( index >= 0 && index < m_numData )
    if( index >= 0 && index < m_size )
    {
        WzAssert( m_data );

        return m_data[index];
    }

    // WZLOG( WZWAR, "CWzArray::Get() - ½ÇÆÐ!! ¾²·¹±â µ¥ÀÌŸ ¹Ýȯ (À妽º:%d, µ¥ÀÌŸ¼ö:%d)", index, m_numData );
    WZLOG( WZWAR, "CWzArray::Get() - ½ÇÆÐ!! ¾²·¹±â µ¥ÀÌŸ ¹Ýȯ (À妽º:%d, ¹öÆÛÅ©±â:%d)", index, m_size );

    return m_dummyData;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
int CWzArray<T>::Add( const T& data )
{
    Set( m_numData, data );

    return ( m_numData - 1 );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
int CWzArray<T>::Adds( const T& data1, const T& data2, const T& data3 )
{
    MakeSureDimensionSize( m_numData + 2 );

    WzAssert( m_data );

    T* refData = &m_data[m_numData];
    WzAssert( refData );

    refData[0] = data1;
    refData[1] = data2;
    refData[2] = data3;

    m_numData += 3;

    return ( m_numData - 1 );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
int CWzArray<T>::Adds( int cnt, const T* data )
{
    WzAssert( data );

    MakeSureDimensionSize( m_numData + cnt - 1 );

    WzAssert( m_data );

    T* refData = &m_data[m_numData];
    WzAssert( refData );

    for( int i = 0; i < cnt; ++i )
    {
        refData[i] = data[i];
    }

    m_numData += cnt;

    return ( m_numData - 1 );
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
int CWzArray<T>::Find( const T& data ) const
{
    WzAssert( m_data );

    for( int i = 0; i < m_numData; ++i )
    {
        if( m_data[i] == data )
        {
            return i;
        }
    }

    return -1;
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
void CWzArray<T>::Remove( int index )
{
    WzAssert( index >= 0 && index < m_numData );

    if( index >= 0 && index < m_numData )
    {
        WzAssert( m_data );

        memmove( m_data + index, m_data + index + 1, sizeof( T ) * ( m_numData - index - 1 ) );
        --m_numData;
    }
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
int CWzArray<T>::GetCount( void ) const
{ 
    return m_numData; 
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
T* CWzArray<T>::GetBufferPtr( void ) const
{ 
    return m_data; 
}

//------------------------------------------------------------------------------
/**
*/
template <class T>
CWzArray<T>& CWzArray<T>::operator = ( const CWzArray<T>& rhs )
{
    if( &rhs == this )
    {
        return *this;
    }

    Release();

    int size = ( rhs.m_size > 0 ? rhs.m_size : 16 );
    WzAssert( rhs.m_numData <= size );

    m_data = new T[size];
    WzAssert( m_data );

    memset(m_data, 0, sizeof( T ) * size);

    memcpy( m_data, rhs.m_data, sizeof( T ) * rhs.m_numData );

    m_size = size;
    m_numData = rhs.m_numData;

    return *this;
}

#endif // _PROGRAMCOMMON_WZARRAY_H_