XStringArray.h

Go to the documentation of this file.

//! @file XStringArray.h
//! @brief CXStringArray class which is an array of CXString
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(CEXSTRINGARRAY_INCLUDE_H)
#define CEXSTRINGARRAY_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
/////////////////////////////////////////////////////////////
//! @class CXStringArray
//! @brief CXStringArray implement an array of CXString.
//!
//! @note Implementation consideration.\nThe array is not based CElementArray, because it stores CXString in m_pData but most of the calling methods uses LPCTSTR.\n
//! SetAt beneficiate of the implicit conversion from LPCTSTR to CXString (m_pData[i] = (LPCTSTR)string;\n
//! CElementArray::SetAt assumes that the element provide is based on the class store in m_pData, but cannot perform conversion from raw data to a given class.\n
//! Using CElementArray would involves to convert any LPCTSTR to CXString which causes overhead.
//!
class DLL_TOOLSFUNCTION CXStringArray : public CXObject
{
    DECLARE_SERIAL_XOBJECT(CXStringArray)
public:
 
    // Construction
    CXStringArray();
 
    // Attributes
    int GetSize() const;
    bool IsEmpty() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);
 
    // Operations
        // Clean up
    void FreeExtra();
    void RemoveAll();
 
    // Accessing elements
    const CXString& GetAt(int nIndex) const;
    void SetAt(int nIndex, LPCTSTR newElement);
 
    void SetAt(int nIndex, const CXString& newElement);
 
    CXString& ElementAt(int nIndex);
 
    // Direct Access to the element data (may return NULL)
    const CXString* GetData() const;
    CXString* GetData();
 
    // Potentially growing the array
    void SetAtGrow(int nIndex, LPCTSTR newElement);
 
    void SetAtGrow(int nIndex, const CXString& newElement);
 
    int Add(LPCTSTR newElement);
 
    int Add(const CXString& newElement);
 
    int Append(const CXStringArray& src);
    void Copy(const CXStringArray& src);
 
    // overloaded operator helpers
    const CXString& operator[](int nIndex) const;
    CXString& operator[](int nIndex);
 
    // Operations that move elements around
    void InsertAt(int nIndex, LPCTSTR newElement, int nCount = 1);
 
    void InsertAt(int nIndex, const CXString& newElement, int nCount = 1);
 
    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, const CXStringArray* pNewArray);
 
    // Implementation
protected:
    CXString* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount
 
    void InsertEmpty(int nIndex, int nCount);
 
 
public:
    virtual ~CXStringArray();
 
    void Serialize(CXArchive&);
#ifdef _DEBUG
    void Dump() const;
#endif
 
protected:
    // local typedefs for class templates
    typedef CXString BASE_TYPE;
    typedef LPCTSTR BASE_ARG_TYPE;
};
 
 
inline int CXStringArray::GetSize() const
{
    return m_nSize;
}
 
inline bool CXStringArray::IsEmpty() const
{
    return m_nSize == 0;
}
 
inline int CXStringArray::GetUpperBound() const
{
    return m_nSize - 1;
}
 
inline void CXStringArray::RemoveAll()
{
    SetSize(0);
}
 
inline const CXString& CXStringArray::GetAt(int nIndex) const
{
    XASSERT(nIndex >= 0 && nIndex < m_nSize);
    if (nIndex < 0 || nIndex >= m_nSize)
        XThrowInvalidArgException();
    return m_pData[nIndex];
}
inline void CXStringArray::SetAt(int nIndex, LPCTSTR newElement)
{
    XASSERT(nIndex >= 0 && nIndex < m_nSize);
    if (nIndex < 0 || nIndex >= m_nSize)
        XThrowInvalidArgException();
    m_pData[nIndex] = newElement;
}
 
inline void CXStringArray::SetAt(int nIndex, const CXString& newElement)
{
    XASSERT(nIndex >= 0 && nIndex < m_nSize);
    if (nIndex < 0 || nIndex >= m_nSize)
        XThrowInvalidArgException();
    m_pData[nIndex] = newElement;
}
 
inline CXString& CXStringArray::ElementAt(int nIndex)
{
    XASSERT(nIndex >= 0 && nIndex < m_nSize);
    if (nIndex < 0 || nIndex >= m_nSize)
        XThrowInvalidArgException();
    return m_pData[nIndex];
}
 
inline const CXString* CXStringArray::GetData() const
{
    return (const CXString*)m_pData;
}
 
inline CXString* CXStringArray::GetData()
{
    return (CXString*)m_pData;
}
 
inline int CXStringArray::Add(LPCTSTR newElement)
{
    int nIndex = m_nSize;
    SetAtGrow(nIndex, newElement);
    return nIndex;
}
 
inline int CXStringArray::Add(const CXString& newElement)
{
    int nIndex = m_nSize;
    SetAtGrow(nIndex, newElement);
    return nIndex;
}
 
inline const CXString& CXStringArray::operator[](int nIndex) const
{
    return GetAt(nIndex);
}
 
inline CXString& CXStringArray::operator[](int nIndex)
{
    return ElementAt(nIndex);
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(CEXSTRINGARRAY_INCLUDE_H)