/*++
Copyright (c) 1998-1999 Microsoft Corporation
Module Name:
utils.h
Abstract:
Author:
mquinton 06-30-98
Notes:
Revision History:
--*/
#ifndef __UTILS_H__
#define __UTILS_H__
#ifdef TRACELOG
#include <rtutils.h>
//#include <windef.h>
//#include <winnt.h>
extern BOOL g_bLoggingEnabled;
#define MAXDEBUGSTRINGLENGTH 1024
#define TL_ERROR ((DWORD)0x00010000 | TRACE_USE_MASK)
#define TL_WARN ((DWORD)0x00020000 | TRACE_USE_MASK)
#define TL_INFO ((DWORD)0x00040000 | TRACE_USE_MASK)
#define TL_TRACE ((DWORD)0x00080000 | TRACE_USE_MASK)
#define TL_EVENT ((DWORD)0x00100000 | TRACE_USE_MASK)
BOOL TRACELogRegister(LPCTSTR szName);
void TRACELogDeRegister();
void TRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR DbgMessage, IN ...);
void TRACELogPrint(IN DWORD dwDbgLevel, HRESULT hr, IN LPCSTR lpszFormat, IN ...);
extern char *TraceLevel(DWORD dwDbgLevel);
extern void TAPIFormatMessage(HRESULT hr, LPVOID lpMsgBuf);
#define TRACELOGREGISTER(arg) TRACELogRegister(arg)
#define TRACELOGDEREGISTER() g_bLoggingEnabled?TRACELogDeRegister():0
#define LOG(arg) g_bLoggingEnabled?TRACELogPrint arg:0
#define STATICLOG(arg) g_bLoggingEnabled?StaticTRACELogPrint arg:0
extern char sg_szTraceName[100];
extern DWORD sg_dwTracingToDebugger;
extern DWORD sg_dwDebuggerMask;
extern DWORD sg_dwTraceID;
#define DECLARE_DEBUG_ADDREF_RELEASE(x) \
void LogDebugAddRef(DWORD dw) \
{ TRACELogPrint(TL_INFO, "%s::AddRef() = %d - this %lx", _T(#x), dw, this); } \
void LogDebugRelease(DWORD dw) \
{ TRACELogPrint(TL_INFO, "%s::Release() = %d - this %lx", _T(#x), dw, this); }
#define DECLARE_TRACELOG_CLASS(x) \
void TRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR lpszFormat, IN ...) \
{ \
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
va_list arglist; \
\
if ( ( sg_dwTracingToDebugger > 0 ) && \
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
{ \
SYSTEMTIME SystemTime; \
GetLocalTime(&SystemTime); \
\
wsprintfA(szTraceBuf, \
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] (%p) %s::", \
sg_szTraceName, \
SystemTime.wHour, \
SystemTime.wMinute, \
SystemTime.wSecond, \
SystemTime.wMilliseconds, \
GetCurrentThreadId(), \
TraceLevel(dwDbgLevel), \
this, \
_T(#x)); \
\
va_list ap; \
va_start(ap, lpszFormat); \
\
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
lpszFormat, \
ap \
); \
\
lstrcatA (szTraceBuf, "\n"); \
\
OutputDebugStringA (szTraceBuf); \
\
va_end(ap); \
} \
\
if (sg_dwTraceID != INVALID_TRACEID) \
{ \
wsprintfA(szTraceBuf, "[%s] (%p) %s::%s", TraceLevel(dwDbgLevel), this, _T(#x), lpszFormat); \
\
va_start(arglist, lpszFormat); \
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
va_end(arglist); \
} \
} \
\
void TRACELogPrint(IN DWORD dwDbgLevel,IN HRESULT hr, IN LPCSTR lpszFormat, IN ...) \
{ \
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
LPVOID lpMsgBuf = NULL; \
va_list arglist; \
\
TAPIFormatMessage(hr, &lpMsgBuf); \
\
if ( ( sg_dwTracingToDebugger > 0 ) && \
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
{ \
SYSTEMTIME SystemTime; \
GetLocalTime(&SystemTime); \
\
wsprintfA(szTraceBuf, \
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] (%p) %s::", \
sg_szTraceName, \
SystemTime.wHour, \
SystemTime.wMinute, \
SystemTime.wSecond, \
SystemTime.wMilliseconds, \
GetCurrentThreadId(), \
TraceLevel(dwDbgLevel), \
this, \
_T(#x) \
); \
\
va_list ap; \
va_start(ap, lpszFormat); \
\
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
lpszFormat, \
ap \
); \
\
wsprintfA(&szTraceBuf[lstrlenA(szTraceBuf)], \
" Returned[%lx] %s\n", \
hr, \
lpMsgBuf); \
\
OutputDebugStringA (szTraceBuf); \
\
va_end(ap); \
} \
\
if (sg_dwTraceID != INVALID_TRACEID) \
{ \
wsprintfA(szTraceBuf, "[%s] (%p) %s::%s Returned[%lx] %s", TraceLevel(dwDbgLevel), this, _T(#x), lpszFormat,hr, lpMsgBuf ); \
\
va_start(arglist, lpszFormat); \
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
va_end(arglist); \
} \
\
if(lpMsgBuf != NULL) \
{ \
LocalFree( lpMsgBuf ); \
} \
} \
\
static void StaticTRACELogPrint(IN DWORD dwDbgLevel, IN LPCSTR lpszFormat, IN ...) \
{ \
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
va_list arglist; \
\
if ( ( sg_dwTracingToDebugger > 0 ) && \
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
{ \
SYSTEMTIME SystemTime; \
GetLocalTime(&SystemTime); \
\
wsprintfA(szTraceBuf, \
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] %s::", \
sg_szTraceName, \
SystemTime.wHour, \
SystemTime.wMinute, \
SystemTime.wSecond, \
SystemTime.wMilliseconds, \
GetCurrentThreadId(), \
TraceLevel(dwDbgLevel), \
_T(#x)); \
\
va_list ap; \
va_start(ap, lpszFormat); \
\
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
lpszFormat, \
ap \
); \
\
lstrcatA (szTraceBuf, "\n"); \
\
OutputDebugStringA (szTraceBuf); \
\
va_end(ap); \
} \
\
if (sg_dwTraceID != INVALID_TRACEID) \
{ \
wsprintfA(szTraceBuf, "[%s] %s::%s", TraceLevel(dwDbgLevel), _T(#x), lpszFormat); \
\
va_start(arglist, lpszFormat); \
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
va_end(arglist); \
} \
} \
\
static void StaticTRACELogPrint(IN DWORD dwDbgLevel,IN HRESULT hr, IN LPCSTR lpszFormat, IN ...) \
{ \
char szTraceBuf[MAXDEBUGSTRINGLENGTH + 1]; \
LPVOID lpMsgBuf = NULL; \
va_list arglist; \
\
TAPIFormatMessage(hr, &lpMsgBuf); \
\
if ( ( sg_dwTracingToDebugger > 0 ) && \
( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) \
{ \
SYSTEMTIME SystemTime; \
GetLocalTime(&SystemTime); \
\
wsprintfA(szTraceBuf, \
"%s:[%02u:%02u:%02u.%03u,tid=%x:] [%s] %s::", \
sg_szTraceName, \
SystemTime.wHour, \
SystemTime.wMinute, \
SystemTime.wSecond, \
SystemTime.wMilliseconds, \
GetCurrentThreadId(), \
TraceLevel(dwDbgLevel), \
_T(#x) \
); \
\
va_list ap; \
va_start(ap, lpszFormat); \
\
_vsnprintf(&szTraceBuf[lstrlenA(szTraceBuf)], \
MAXDEBUGSTRINGLENGTH - lstrlenA(szTraceBuf), \
lpszFormat, \
ap \
); \
\
wsprintfA(&szTraceBuf[lstrlenA(szTraceBuf)], \
" Returned[%lx] %s\n", \
hr, \
lpMsgBuf); \
\
OutputDebugStringA (szTraceBuf); \
\
va_end(ap); \
} \
\
if (sg_dwTraceID != INVALID_TRACEID) \
{ \
wsprintfA(szTraceBuf, "[%s] %s::%s Returned[%lx] %s", TraceLevel(dwDbgLevel), _T(#x), lpszFormat,hr, lpMsgBuf ); \
\
va_start(arglist, lpszFormat); \
TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); \
va_end(arglist); \
} \
\
if(lpMsgBuf != NULL) \
{ \
LocalFree( lpMsgBuf ); \
} \
}
#else // TRACELOG not defined
#define TRACELOGREGISTER(arg)
#define TRACELOGDEREGISTER()
#define LOG(arg)
#define STATICLOG(arg)
#define DECLARE_DEBUG_ADDREF_RELEASE(x)
#define DECLARE_TRACELOG_CLASS(x)
#endif // TRACELOG
class CAsyncRequestReply
{
private:
HANDLE hRepliedSemaphore;
DWORD dwID;
BOOL bReply;
HRESULT hResult;
public:
DECLARE_TRACELOG_CLASS(CAsyncRequestReply)
CAsyncRequestReply(DWORD id, BOOL b, HRESULT hr)
{
if( (hRepliedSemaphore = CreateSemaphore(NULL,0,1,NULL)) == NULL )
{
LOG((TL_INFO, "create CAsyncRequest - CreateSemaphore failed"));
hResult = E_OUTOFMEMORY;
}
else
{
dwID = id;
bReply = b;
hResult = hr;
LOG((TL_INFO, "create CAsyncRequest %d ",dwID));
}
}
~CAsyncRequestReply()
{
LOG((TL_INFO, "delete CAsyncRequest %d ",dwID));
if( NULL != hRepliedSemaphore )
{
CloseHandle(hRepliedSemaphore);
}
}
inline DWORD getID() {return dwID;};
inline BOOL IsReply() {return bReply;};
inline HRESULT getResult() {return hResult;};
inline void setResult(HRESULT hr) {hResult = hr;};
HRESULT wait()
{
LOG((TL_INFO, "wait CAsyncRequest %d ",dwID));
extern DWORD gdwTapi2AsynchronousCallTimeout;
DWORD rc = WaitForSingleObject(hRepliedSemaphore, gdwTapi2AsynchronousCallTimeout);
switch (rc)
{
case WAIT_ABANDONED:
LOG((TL_ERROR, "wait CAsyncRequest %d WaitForSingle object returned WAIT_ABANDONED",dwID));
hResult = TAPIERR_REQUESTFAILED;
break;
case WAIT_OBJECT_0:
break;
case WAIT_TIMEOUT:
LOG((TL_WARN, "wait CAsyncRequest %d WaitForSingle object returned WAIT_TIMEOUT",dwID));
// -1 won't overlap with any value that may be returned from tapi2 calls.
hResult = -1;
break;
case WAIT_FAILED:
{
DWORD nLastError = GetLastError();
LOG((TL_ERROR, "wait CAsyncRequest %d WaitForSingle object returned WAIT_FAILED, LastError = %d", dwID, nLastError));
hResult = TAPIERR_REQUESTFAILED;
break;
}
default:
break;
}
return hResult;
}
void signal()
{
LOG((TL_INFO, "signal CAsyncRequest %d ",dwID));
ReleaseSemaphore(hRepliedSemaphore, 1, NULL);
}
};
typedef list<CAsyncRequestReply *> RequestReplyList;
class CAsyncReplyList
{
public:
DECLARE_TRACELOG_CLASS(CAsyncReplyList)
private:
RequestReplyList replyList;
CRITICAL_SECTION csReply;
CAsyncRequestReply *find(DWORD dwID)
{
RequestReplyList::iterator i;
CAsyncRequestReply *pResult = NULL;
// walk list searching for match
i = replyList.begin();
// iterate over current replies
while ( i != replyList.end() )
{
// found it
if ((*i)->getID() == dwID )
{
pResult = *i;
break;
}
i++;
}
//returning pointer to matching entry or NULL
return pResult;
}
public:
CAsyncReplyList() {InitializeCriticalSection( &csReply );};
~CAsyncReplyList()
{
FreeList();
DeleteCriticalSection( &csReply );
}
void FreeList()
{
RequestReplyList::iterator i;
EnterCriticalSection( &csReply );
// walk list deleting entries
i = replyList.begin();
while ( i != replyList.end() )
delete *i++;
replyList.clear();
LeaveCriticalSection( &csReply );
};
void remove(CAsyncRequestReply *a)
{
EnterCriticalSection( &csReply );
replyList.remove(a);
LeaveCriticalSection( &csReply );
}
CAsyncRequestReply *addRequest(DWORD id)
{
CAsyncRequestReply *pReply;
EnterCriticalSection( &csReply );
// Check list to see if we're already on the list ( i.e. the response LINE_REPLY got here before us)
pReply = find(id);
if (pReply == NULL || !pReply->IsReply())
{
// No so we got here before the reply, create a new request entry on the list
pReply = new CAsyncRequestReply(id, FALSE, 0);
if (NULL == pReply)
{
LOG((TL_ERROR, "Could not alloc for CAsyncRequestReply"));
}
else if( pReply->getResult() == E_OUTOFMEMORY )
{
delete pReply;
pReply = NULL;
LOG((TL_ERROR, "addRequest - Create Semaphore failed"));
}
else
{
try
{
replyList.push_back(pReply);
}
catch(...)
{
delete pReply;
pReply = NULL;
LOG((TL_ERROR, "addRequest- failed - because of alloc failure"));
}
}
}
// Else, the reply comes before me, remove it from the list
else
{
replyList.remove (pReply);
}
LeaveCriticalSection( &csReply );
return pReply;
}
CAsyncRequestReply *addReply(DWORD id, HRESULT hr)
{
CAsyncRequestReply *pReply;
EnterCriticalSection( &csReply );
// Check list to see if we have a matching entry
pReply = find(id);
if (pReply == NULL || pReply->IsReply())
{
// No so we got here before the request returned, create a new entry on the list
pReply = new CAsyncRequestReply(id, TRUE, hr);
if (NULL == pReply)
{
LOG((TL_ERROR, "Could not alloc for CAsyncRequestReply"));
}
else if( pReply->getResult() == E_OUTOFMEMORY )
{
delete pReply;
pReply = NULL;
LOG((TL_ERROR, "addReply - Create Semaphore failed"));
}
else
{
try
{
replyList.push_back(pReply);
}
catch(...)
{
delete pReply;
pReply = NULL;
LOG((TL_ERROR, "addReply- failed - because of alloc failure"));
}
}
}
else
{
// Use the existing entry, set its return code & signal to the waiting request code
pReply->setResult(hr);
replyList.remove (pReply);
}
LeaveCriticalSection( &csReply );
return pReply;
}
};
////////////////////////////////////////////////////////////////////
//
// Class CRetryQueue
// Maintains queue of Async messages for retry.
// Typically these relate to calls not yet entered in the call hash-
// table, such that findCallObject failed. These are reprocessed
// once the call is entered & the ghAsyncRetryQueueEvent event is
// signalled.
//
// Added criticalsection - thread safe now
//
////////////////////////////////////////////////////////////////////
class CRetryQueue
{
typedef struct _tagRetryQueueEntry
{
DWORD dwRetryCount;
PASYNCEVENTMSG pMessage;
} RETRY_QUEUE_ENTRY, *PRETRY_QUEUE_ENTRY;
typedef list<RETRY_QUEUE_ENTRY *> RetryQueueListType;
#define MAX_REQUEUE_TRIES 3
private:
RetryQueueListType m_RetryQueueList;
CRITICAL_SECTION m_cs;
//
// is the queue open for new entries?
//
BOOL m_bAcceptNewEntries;
private:
//
// requeue the entry that failed processing. don't do this if the queue is
// closed.
//
void RequeueEvent(PRETRY_QUEUE_ENTRY pQueueEntry);
public:
DECLARE_TRACELOG_CLASS(CRetryQueue)
CRetryQueue()
:m_bAcceptNewEntries(FALSE)
{
InitializeCriticalSection( &m_cs );
}
~CRetryQueue();
void Lock(){ EnterCriticalSection( &m_cs ); }
void Unlock(){ LeaveCriticalSection( &m_cs ); }
BOOL QueueEvent(PASYNCEVENTMSG pEvent);
BOOL DequeueEvent(PRETRY_QUEUE_ENTRY * ppEvent);
void ProcessQueue();
void RemoveNewCallHub(DWORD);
inline BOOL ItemsInQueue()
{
BOOL bReturn;
Lock();
bReturn = !m_RetryQueueList.empty();
Unlock();
return bReturn;
}
//
// after this function returns, the queue will accept new entries
//
void OpenForNewEntries();
//
// new entries will be denied after this function returns
//
void CloseForNewEntries();
};
#define MAXCACHEENTRIES 5
#define BUFFERTYPE_ADDRCAP 1
#define BUFFERTYPE_LINEDEVCAP 2
#define BUFFERTYPE_PHONECAP 3
typedef struct
{
UINT_PTR pObject;
LPVOID pBuffer;
} CACHEENTRY;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// CStructCache
//
// A simple class to cache TAPI structures in tapi3.dll
//
// This implementation has an array of CACHEENTRY structures. Each
// CACHEENTRY structure has 2 member:
// pObject - the object that currently owns the buffer
// pBuffer - the buffer
//
// The array is a fixed size, which is set when the class is initialized
// The memory for the buffers is allocated during initialization as
// well. It is possible that a buffer gets realloced (replaced)
// at some time.
//
// This implementation assumes that the object that owns the buffer
// uses it's critical sections correctly. That is, it is locked when
// SetXxxBuffer is called, and it is locked when getting and using
// a buffer If not, the buffer can disapper from the object at any time.
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class CStructCache
{
private:
CRITICAL_SECTION m_cs;
DWORD m_dwType;
DWORD m_dwMaxEntries;
DWORD m_dwUsedEntries;
CACHEENTRY m_aEntries[MAXCACHEENTRIES];
public:
DECLARE_TRACELOG_CLASS(CStructCache)
CStructCache()
{
int iCount;
InitializeCriticalSection( &m_cs );
for( iCount=0; iCount<MAXCACHEENTRIES; iCount++)
{
m_aEntries[iCount].pObject = NULL;
m_aEntries[iCount].pBuffer = NULL;
}
m_dwType = 0;
m_dwMaxEntries = 0;
m_dwUsedEntries = 0;
}
~CStructCache()
{
DeleteCriticalSection( &m_cs );
}
void Lock()
{
EnterCriticalSection( &m_cs );
}
void Unlock()
{
LeaveCriticalSection( &m_cs );
}
HRESULT Initialize( DWORD dwMaxEntries, DWORD dwSize, DWORD dwType );
HRESULT Shutdown();
HRESULT GetBuffer( UINT_PTR pNewObject, LPVOID * ppReturnStruct );
HRESULT SetBuffer( UINT_PTR pObject, LPVOID pNewStruct );
HRESULT InvalidateBuffer( UINT_PTR pObject );
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// CArray - based on from CSimpleArray from atl
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
template <class T>
class CTObjectArray
{
private:
T * m_aT;
int m_nSize;
int m_nUsed;
public:
DECLARE_TRACELOG_CLASS(CTObjectArray)
CTObjectArray() : m_aT(NULL), m_nSize(0), m_nUsed(0){}
~CTObjectArray()
{}
int GetSize() const
{
return m_nUsed;
}
BOOL Add(T& t)
{
if(m_nSize == m_nUsed)
{
T * aT;
int nNewSize;
nNewSize = (m_nSize == 0) ? 1 : (m_nSize * 2);
aT = (T*) ClientAlloc (nNewSize * sizeof(T));
if(aT == NULL)
{
return FALSE;
}
CopyMemory(
aT,
m_aT,
m_nUsed * sizeof(T)
);
ClientFree( m_aT );
m_aT = aT;
m_nSize = nNewSize;
}
m_aT[m_nUsed] = t;
t->AddRef();
m_nUsed++;
return TRUE;
}
BOOL Remove(T& t)
{
int nIndex = Find(t);
if(nIndex == -1)
return FALSE;
return RemoveAt(nIndex);
}
BOOL RemoveAt(int nIndex)
{
m_aT[nIndex]->Release();
if(nIndex != (m_nUsed - 1))
{
MoveMemory(
(void*)&m_aT[nIndex],
(void*)&m_aT[nIndex + 1],
(m_nUsed - (nIndex + 1)) * sizeof(T)
);
}
m_nUsed--;
return TRUE;
}
void Shutdown()
{
if( NULL != m_aT )
{
int index;
for (index = 0; index < m_nUsed; index++)
{
m_aT[index]->Release();
}
ClientFree(m_aT);
m_aT = NULL;
m_nUsed = 0;
m_nSize = 0;
}
}
T& operator[] (int nIndex) const
{
_ASSERTE(nIndex >= 0 && nIndex < m_nUsed);
return m_aT[nIndex];
}
int Find(T& t) const
{
for(int i = 0; i < m_nUsed; i++)
{
if(m_aT[i] == t)
return i;
}
return -1; // not found
}
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// CArray - based on from CSimpleArray from atl
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
template <class T>
class CTArray
{
private:
T * m_aT;
int m_nSize;
int m_nUsed;
public:
DECLARE_TRACELOG_CLASS(CTArray)
CTArray() : m_aT(NULL), m_nSize(0), m_nUsed(0){}
~CTArray()
{}
int GetSize() const
{
return m_nUsed;
}
BOOL Add(T& t)
{
if(m_nSize == m_nUsed)
{
T * aT;
int nNewSize;
nNewSize = (m_nSize == 0) ? 1 : (m_nSize * 2);
aT = (T*) ClientAlloc (nNewSize * sizeof(T));
if(aT == NULL)
{
return FALSE;
}
CopyMemory(
aT,
m_aT,
m_nUsed * sizeof(T)
);
ClientFree( m_aT );
m_aT = aT;
m_nSize = nNewSize;
}
m_aT[m_nUsed] = t;
m_nUsed++;
return TRUE;
}
BOOL Remove(T& t)
{
int nIndex = Find(t);
if(nIndex == -1)
return FALSE;
return RemoveAt(nIndex);
}
BOOL RemoveAt(int nIndex)
{
if(nIndex != (m_nUsed - 1))
{
MoveMemory(
(void*)&m_aT[nIndex],
(void*)&m_aT[nIndex + 1],
(m_nUsed - (nIndex + 1)) * sizeof(T)
);
}
m_nUsed--;
return TRUE;
}
void Shutdown()
{
if( NULL != m_aT )
{
int index;
ClientFree(m_aT);
m_aT = NULL;
m_nUsed = 0;
m_nSize = 0;
}
}
T& operator[] (int nIndex) const
{
_ASSERTE(nIndex >= 0 && nIndex < m_nUsed);
return m_aT[nIndex];
}
int Find(T& t) const
{
for(int i = 0; i < m_nUsed; i++)
{
if(m_aT[i] == t)
return i;
}
return -1; // not found
}
};
#endif // __UTILS_H__