/*++ Copyright (c) 1997 Microsoft Corporation Module Name: stistr.h Abstract: Lightweight string classes: definition. Supports both UNICODE and single-byte character strings Author: Vlad Sadovsky (vlads) 26-Jan-1997 (Lifted from another C++ project with some modifications and adjustments) Revision History: 26-Jan-1997 VladS created 20-Apr-1999 VladS redesigned to inherit from ATL Cstring class --*/ #ifndef _STRING_H_ #define _STRING_H_ #ifndef USE_OLD_STI_STRINGS class StiCString : public CString { friend class RegEntry; public: StiCString() { CString::CString(); } ~StiCString() { } VOID CopyString(LPCTSTR lpszT) { AssignCopy(lstrlen(lpszT),lpszT); } }; class STRArray : public CSimpleArray { public: STRArray() { } ~STRArray() { // Free all allocated strings for(int i = 0; i < m_nSize; i++) { if(m_aT[i] != NULL) { delete m_aT[i]; m_aT[i] = NULL; } } } BOOL Add( LPCTSTR lpszT ) { StiCString *pNew; pNew = new StiCString; if (pNew) { pNew->CopyString(lpszT); return Add(pNew); } return FALSE; } BOOL Add( StiCString* pstr ) { StiCString *pNew; pNew = new StiCString; if (pNew) { *pNew = *pstr; return CSimpleArray::Add(pNew); } return FALSE; } }; VOID TokenizeIntoStringArray( STRArray& array, LPCTSTR lpstrIn, TCHAR tcSplitter ); #else // // // # include // // Maximum number of characters a loadable string resource can be // # define STR_MAX_RES_SIZE ( 260) class STR; // // If an application defines STR_MODULE_NAME, it will be used // as the default module name on string loads // #ifndef STR_MODULE_NAME #define STR_MODULE_NAME NULL #endif // // These are the characters that are considered to be white space // #define ISWHITE( ch ) ((ch) == L'\t' || (ch) == L' ' || (ch) == L'\r') #define ISWHITEA( ch ) ((ch) == '\t' || (ch) == ' ' || (ch) == '\r') class STR : public BUFFER { friend class RegEntry; public: STR() { _fUnicode = FALSE; _fValid = TRUE; } STR( const CHAR * pchInit ); STR( const WCHAR * pwchInit ); STR( const STR & str ); //STR( UINT dwSize ); BOOL Append( const CHAR * pchInit ); BOOL Append( const WCHAR * pwchInit ); BOOL Append( const STR & str ); BOOL Copy( const CHAR * pchInit ); BOOL Copy( const WCHAR * pwchInit ); BOOL Copy( const STR & str ); BOOL Resize( UINT cbNewReqestedSize ); // // Loads a string from this module's string resource table // BOOL LoadString( IN DWORD dwResID,IN LPCTSTR lpszModuleName = STR_MODULE_NAME); BOOL LoadString( IN DWORD dwResID,IN HMODULE hModule); // // Loads a string with insert params from this module's .mc resource // table. Pass zero for the resource ID to use *this. // BOOL FormatStringV( IN LPCTSTR lpszModuleName, ... ); BOOL FormatString( IN DWORD dwResID, IN LPCTSTR apszInsertParams[], IN LPCTSTR lpszModuleName = STR_MODULE_NAME); // // Returns the number of bytes in the string excluding the terminating // NULL // UINT QueryCB( VOID ) const { return IsUnicode() ? ::wcslen((WCHAR *)QueryStrW()) * sizeof(WCHAR) : ::strlen((CHAR *) QueryStrA()); } // // Returns the number of characters in the string excluding the terminating // NULL // UINT QueryCCH( VOID ) const { return IsUnicode() ? ::wcslen((WCHAR *)QueryStrW()) : ::strlen((CHAR *) QueryStrA()); } // // Makes a Widechar copy of the stored string in given buffer // BOOL CopyToBuffer( WCHAR * lpszBuffer, LPDWORD lpcch) const; // // Makes a schar copy of the stored string in given buffer // BOOL CopyToBufferA( CHAR * lpszBuffer, LPDWORD lpcch) const; // // In-place conversion // BOOL ConvertToW(VOID); BOOL ConvertToA(VOID); // // If the string buffer is empty, returns the empty string, otherwise // returns a pointer to the buffer // #if 1 CHAR * QueryStrA( VOID ) const; WCHAR * QueryStrW( VOID ) const; #else // // _pszEmptyString doesn't get imported corectly, results in unresolved // externals // CHAR * QueryStrA( VOID ) const { return (QueryPtr() ? (CHAR *) QueryPtr() : (CHAR *) _pszEmptyString); } WCHAR * QueryStrW( VOID ) const { return (QueryPtr() ? (WCHAR *) QueryPtr() : (WCHAR *) _pszEmptyString); } #endif //!DBG #ifdef UNICODE WCHAR * QueryStr( VOID ) const { return QueryStrW(); } #else CHAR * QueryStr( VOID ) const { return QueryStrA(); } #endif BOOL IsUnicode( VOID ) const { return _fUnicode; } VOID SetUnicode( BOOL fUnicode ) { _fUnicode = fUnicode; } BOOL IsValid( VOID ) const { return _fValid; } // // Checks and returns TRUE if this string has no valid data else FALSE // BOOL IsEmpty( VOID) const { //return ( *QueryStr() == '\0'); } if (!QuerySize() || !QueryPtr()) { return TRUE; } LPBYTE pb = (BYTE *)QueryPtr(); return (_fUnicode) ? ((WCHAR)*pb==L'\0') : ((CHAR)*pb=='\0') ; } // // Makes a clone of the current string in the string pointer passed in. // BOOL Clone( OUT STR * pstrClone) const { if ( pstrClone == NULL) { SetLastError( ERROR_INVALID_PARAMETER); return ( FALSE); } else { return ( pstrClone->Copy( *this)); } } // STR::Clone() // // Useful operators // operator const TCHAR *() const { return QueryStr(); } const inline STR& operator =(LPCSTR lpstr) { Copy(lpstr); return *this; } const inline STR& operator =(LPCWSTR lpwstr) { Copy(lpwstr); return *this; } const inline STR& operator =(STR& cs) { Copy(cs);return *this; } const inline STR& operator +=(LPCSTR lpstr) { Append(lpstr);return *this; } const inline STR& operator +=(LPCWSTR lpwstr) { Append(lpwstr);return *this; } const inline STR& operator +=(STR& cs) { Append(cs);return *this; } private: // // TRUE if the string has already been mapped to Unicode // FALSE if the string is in Latin1 // BOOL _fUnicode; BOOL _fValid; // // Returned when our buffer is empty // static WCHAR _pszEmptyString[]; VOID AuxInit( PBYTE pInit, BOOL fUnicode ); BOOL AuxAppend( PBYTE pInit, UINT cbStr, BOOL fAddSlop = TRUE ); }; class STRArray { STR *m_pcsContents, m_csEmpty; unsigned m_ucItems, m_ucMax, m_uGrowBy; void Grow(); public: STRArray(UINT uGrowBy = 10); ~STRArray(); UINT Count() const { return m_ucItems; } void Add(LPCSTR lpstrNew); void Add(LPCWSTR lpstrNew); STR& operator[](UINT u) { return u < m_ucItems ? m_pcsContents[u] : m_csEmpty; } void Tokenize(LPCTSTR lpstrIn, TCHAR tcSplitter); }; #endif #endif // !_STRING_H_