опубликован 25-01-2002 06:11 MSK            

class CSimpleStrArray
{
public:
int IndexOf(LPCSTR szString);
void Clear();
bool Contains(LPCSTR szString);
void RemoveAll();
CSimpleStrArray(int nNewSize = 0, int nGrowBy = 1);
virtual ~CSimpleStrArray();
void Add(LPCSTR szString);
void AddToBegin(LPCSTR szString);
bool SetSize(int nNewSize, int nGrowBy);
LPSTR operator[](int nIndex)
{
ASSERT(nIndex >= 0 && nIndex < m_nSize);
return m_szStrings[nIndex];
}

int GetUpperBound(){return m_nUpperBound;}
bool OneOfBeginsWith(const CString& str);

private:
CSimpleStrArray(const CSimpleStrArray&){}
operator = (const CSimpleStrArray&){}

TCHAR ** m_szStrings;
int m_nUpperBound, m_nSize, m_nGrowBy;
};

// Реализация

CSimpleStrArray::CSimpleStrArray(int nNewSize, int nGrowBy)
{
m_nUpperBound = -1;
m_szStrings = NULL;
SetSize(nNewSize, nGrowBy);
}

CSimpleStrArray::~CSimpleStrArray()
{
Clear();
}

void CSimpleStrArray::Add(LPCSTR szString)
{
m_nUpperBound++;

if(m_nUpperBound >= m_nSize)
{
TCHAR** szNewStrings = new TCHAR* [m_nSize + m_nGrowBy];
ASSERT(szNewStrings);

if(m_nSize)
{
CopyMemory(szNewStrings, m_szStrings, m_nSize * sizeof(TCHAR*));
}

delete [] m_szStrings;
m_nSize += m_nGrowBy;
m_szStrings = szNewStrings;
}

m_szStrings[m_nUpperBound] = new TCHAR[strlen(szString) + 1];
strcpy(m_szStrings[m_nUpperBound], szString);
}

void CSimpleStrArray::AddToBegin(LPCSTR szString)
{
TCHAR** szNewStrings = new TCHAR* [m_nSize + 1];
ASSERT(szNewStrings);
szNewStrings[0] = new TCHAR[strlen(szString) + 1];
strcpy(szNewStrings[0], szString);

if(m_nSize)
{
CopyMemory(szNewStrings + 1, m_szStrings, m_nSize * sizeof(TCHAR*));
}

delete[] m_szStrings;
m_szStrings = szNewStrings;
m_nSize++;
m_nUpperBound++;
}

void CSimpleStrArray::Clear()
{
for(int i = 0; i <= m_nUpperBound; i++)
{
delete[] m_szStrings[i];
}

delete[] m_szStrings;

m_nUpperBound = -1;
m_szStrings = NULL;
m_nSize = 0;
}

bool CSimpleStrArray::SetSize(int nNewSize, int nGrowBy)
{
ASSERT(nNewSize >= 0 && nGrowBy > 0);
ASSERT(m_szStrings == NULL);

if(nNewSize)
{
m_szStrings = new TCHAR* [nNewSize];
ASSERT(m_szStrings);
if(!m_szStrings) return false;
}

m_nSize = nNewSize;
m_nGrowBy = nGrowBy;
return true;

}

void CSimpleStrArray::RemoveAll()
{
for(int i = 0; i <= m_nUpperBound; i++)
{
delete[] m_szStrings[i];
}

delete[] m_szStrings;
m_nSize = 0;
m_nUpperBound = -1;
m_szStrings = NULL;
}

bool CSimpleStrArray::Contains(LPCSTR szString)
{
for(int i = 0; i <= m_nUpperBound; i++)
{
if(!lstrcmp(m_szStrings[i], szString)) return true;
}

return false;
}

// -1, åñëè íåò âõîæäåíèÿ

int CSimpleStrArray::IndexOf(LPCSTR szString)
{
for(int i = 0; i <= m_nUpperBound; i++)
{
if(!lstrcmp(m_szStrings[i], szString)) return i;
}

return -1;
}

bool CSimpleStrArray::OneOfBeginsWith(const CString &str)
{
static char szBuf[50];
int nLength;

for(int i = 0; i <= m_nUpperBound; i++)
{
nLength = lstrlen(m_szStrings[i]);
//TRACE("Äëèíà òðèãåðà = %d\n", nLength);
lstrcpyn(szBuf, str, (nLength < sizeof(szBuf) ? nLength + 1 : sizeof(szBuf)));