See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  INI File Class
  Submitted by



Here is a very simple way to use *.ini file : A CIniFile class. A CIniFile object can load/save *.ini files and supports all features you may need when using *.ini files. I found that very usefull (and the teams i'm working with also think so)

A will be happy to have your comments about the way i am coding. I am also looking for tips in order to make this class better (more safe and faster).

Antoine Villepreux (france)

Currently browsing [inifile.zip] (62,782 bytes) - [Cpp version/CIniFile.cpp] - (42,442 bytes)


//-----------------------------------------------------------------------------
// File name    : CIniFile.cpp
// Author       : AV (Antoine Villepreux)
// date         : 20/11/2000
// Description  : CIniFile class implementation
//              : Easy IniFile object management
//-----------------------------------------------------------------------------


//----------------------------------------------------------------------------- // Macros //----------------------------------------------------------------------------- #define M_MODULE_BGN #define M_MODULE_END

#define M_INCLUDES_BGN #define M_INCLUDES_END

#define M_INIFILE_FN_BGN #define M_INIFILE_FN_END

//----------------------------------------------------------------------------- M_MODULE_BGN("CIniFile.cpp")

//----------------------------------------------------------------------------- // Includes //----------------------------------------------------------------------------- M_INCLUDES_BGN("CIniFile.cpp")

#include "Common.h" #include "CIniFile.h" // #include "CCrypto.h" #include "float.h" #include "limits.h"

M_INCLUDES_END("CIniFile.cpp")

//----------------------------------------------------------------------------- #ifdef _DEBUG_NEW #undef new #define new DEBUG_NEW #undef THIS_FILE #define THIS_FILE __FILE__ #endif

//----------------------------------------------------------------------------- // Error constants //----------------------------------------------------------------------------- const CStdString CIniFile::ms_strError = "CINIFILE_ERROR_READING_KEY_OR_SECTION"; const int CIniFile::ms_iError = INT_MAX; const float CIniFile::ms_fError = FLT_MAX;

const CStdString CIniFile::ms_strErrorMsg[CIniFile::E_INI_ERROR_MESSAGES::E_ERROR_MESSAGES_COUNT] = {

"Error: Unable to open ini file", "Error: Unable to save ini file", "Error: Unable to locate specified section", "Error: Unable to locate specified key", "Warning: unknown extension" , "Warning: end string delimiter not found" };

//----------------------------------------------------------------------------- // Internal shortcuts constants //----------------------------------------------------------------------------- const CStdString CIniFile::ms_strComment [CIniFile::E_INI_COMMENTS ::E_COMMENTS_COUNT ] = { ";" , "//", "/*", "\t\t" }; const CStdString CIniFile::ms_strType [CIniFile::E_INI_TYPES ::E_TYPES_COUNT ] = { "%d" , "%f", "%s" }; const CStdString CIniFile::ms_strMarkup [CIniFile::E_INI_MARKUPS ::E_MARKUPS_COUNT ] = { "[" , "]" , "=" }; const CStdString CIniFile::ms_strTrim [CIniFile::E_INI_TRIM ::E_TRIM_COUNT ] = { " " , "\t" }; const CStdString CIniFile::ms_strExtension[CIniFile::E_INI_EXTENSIONS::E_EXTENSIONS_COUNT] = { ".ini", ".crk" };

const CStdString CIniFile::ms_strStringDelimiter = "\"";

//----------------------------------------------------------------------------- // Various defines //-----------------------------------------------------------------------------

#ifdef TO_BOOL #undef TO_BOOL #endif #define TO_BOOL(i) (((i)==0)?false:true)

#ifdef TO_INT #undef TO_INT #endif #define TO_INT(b) (((b))?1:0)

#define BREAKPOINT _asm int 3

//----------------------------------------------------------------------------- // CIniFile Implementation //-----------------------------------------------------------------------------

//----------------------------------------------------------------------------- // Name : CIniFile::CIniFile() // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Construct empty IniFile object //----------------------------------------------------------------------------- CIniFile::CIniFile() { M_INIFILE_FN_BGN(CIniFile::CIniFile())

SetReadableExtension (ms_strExtension[E_INI_EXTENSIONS::E_READABLE ]); SetEncryptedExtension(ms_strExtension[E_INI_EXTENSIONS::E_ENCRYPTED]);

m_bFastRead = false;

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : CIniFile::CIniFile(const CFilename & strFilename, bool bFastRead) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Construct IniFile object based on given file // : Optionnal fast read may be used if file doesn't contain any // : trailing spaces nor tabs //----------------------------------------------------------------------------- CIniFile::CIniFile(const CFilename & strFilename, bool bFastRead) { M_INIFILE_FN_BGN(CIniFile::CIniFile(const CFilename & strFilename))

SetReadableExtension (ms_strExtension[E_INI_EXTENSIONS::E_READABLE ]); SetEncryptedExtension(ms_strExtension[E_INI_EXTENSIONS::E_ENCRYPTED]);

Load(strFilename, bFastRead);

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : CIniFile::~CIniFile() // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Destruct IniFile object //----------------------------------------------------------------------------- CIniFile::~CIniFile() { M_INIFILE_FN_BGN(CIniFile::~CIniFile(bool bSave))

#ifdef INI_SAVE_ON_EXIT

Save(m_strPath);

#endif

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : bool CIniFile::Load(const CStdString& strFilename, bool bFastRead) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Load ini file from disk or from previous specified file // : Optionnal fast read may be used if file doesn't contain any // : trailing spaces nor tabs //----------------------------------------------------------------------------- bool CIniFile::Load(const CStdString& strFilename, bool bFastRead) { M_INIFILE_FN_BGN(bool CIniFile::Load(const CStdString& strFilename))

m_bFastRead = bFastRead;

if (strFilename != "") { m_strPath = strFilename; }

// Try reading readable ini file

if (m_strPath.GetLength() > m_strReadableExtension.GetLength()) if (!m_strReadableExtension.CompareNoCase(m_strPath.Right(m_strReadableExtension.GetLength()))) { // If *.ini doesn't exist change extension to crypted extension and try again

if (LoadReadableFile(m_strPath, true)) { return true; } else { m_strPath = m_strPath.Left(m_strPath.GetLength() - m_strReadableExtension.GetLength()) + m_strEncryptedExtension; } }

// Try reading crypted ini file if (m_strPath.GetLength() > m_strEncryptedExtension.GetLength()) if (!m_strEncryptedExtension.CompareNoCase(m_strPath.Right(m_strEncryptedExtension.GetLength()))) { return LoadReadableFile(m_strPath, false); }

// No recognized extension found // Try reading readable ini file

m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_UNKNOWN_EXTENSION];

if (LoadReadableFile()) { return true; } else { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_READ];

#ifdef WIN32 CStdString strMsg = m_strPath + " file not found !"; ::MessageBox(NULL,strMsg, m_strLastError, MB_OK); #endif

BREAKPOINT;

#ifdef INI_USE_EXEPTIONS

throw(strMsg.c_str());

#endif

return false; }

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::LoadReadableFile(const CStdString& strFilename, bool bIsReadable) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Internal function - file loading //----------------------------------------------------------------------------- bool CIniFile::LoadReadableFile(const CStdString& strFilename, bool bIsReadable) { M_INIFILE_FN_BGN(bool CIniFile::LoadReadableFile(const CStdString& strFilename, bool bIsReadable))

if (strFilename != "") m_strPath = strFilename;

// Open stream

std::ifstream inifile; inifile.open(m_strPath);

if (inifile.fail()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_READ]; return false; }

// Open stream Ok, parse file lines

CStdString strLine, strSection, strKey, strValue;

while (GetLine(inifile, strLine)) { if (! bIsReadable) { Decrypt(strLine); }

if (!m_bFastRead) { ManageComments(&strLine); }

if (strLine != "") { if ( strLine[0] == (ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN])[0] && strLine[strLine.GetLength()-1] == (ms_strMarkup[E_INI_MARKUPS::E_SECTION_END] )[0] ) { // Section found

strSection = strLine;

strSection.TrimLeft (ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN]); strSection.TrimRight(ms_strMarkup[E_INI_MARKUPS::E_SECTION_END]);

if (!m_bFastRead) { CleanString(&strSection); } } else { // Key found

strKey = strLine.Left (strLine.Find(ms_strMarkup[E_INI_MARKUPS::E_KEY])); strValue = strLine.Right(strLine.GetLength()-strKey.GetLength()-1);

if (!m_bFastRead) { CleanString(&strKey); CleanString(&strValue); }

strValue.TrimLeft(ms_strMarkup[E_INI_MARKUPS::E_KEY]); SetValue(strSection, strKey, strValue); } } }

inifile.close();

return true;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::Save(const CStdString& strFilename) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Save IniFile object to disk with specified filename //----------------------------------------------------------------------------- bool CIniFile::Save(const CStdString& strFilename) { M_INIFILE_FN_BGN(bool CIniFile::Save(const CStdString& strFilename))

if (strFilename != "") m_strPath = strFilename;

if (m_strPath.GetLength() > m_strReadableExtension.GetLength()) if (!m_strReadableExtension.CompareNoCase(m_strPath.Right(m_strReadableExtension.GetLength()))) { return SaveReadableFile(); } if (m_strPath.GetLength() > m_strEncryptedExtension.GetLength()) if (!m_strEncryptedExtension.CompareNoCase(m_strPath.Right(m_strEncryptedExtension.GetLength()))) { return SaveEncryptedFile(); }

m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_UNKNOWN_EXTENSION];

SaveReadableFile();

return false;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SaveReadableFile(const CStdString& strFilename) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - save readable file to disk //----------------------------------------------------------------------------- bool CIniFile::SaveReadableFile(const CStdString& strFilename) { M_INIFILE_FN_BGN(bool CIniFile::SaveReadableFile(const CStdString& strFilename))

if (strFilename != "") m_strPath = strFilename;

std::ofstream inifile; inifile.open(m_strPath);

for(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { inifile << "\n" << ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN] << (*m_itSection).first << ms_strMarkup[E_INI_MARKUPS::E_SECTION_END] << "\n";

for(m_itKey=((*m_itSection).second).begin(); m_itKey!=((*m_itSection).second).end(); m_itKey++) { inifile << (*m_itKey).first << ms_strMarkup[E_INI_MARKUPS::E_KEY] << (*m_itKey).second << "\n"; } }

inifile.close();

return true;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SaveEncryptedFile(const CStdString& strFilename) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - save crypted file to disk //----------------------------------------------------------------------------- bool CIniFile::SaveEncryptedFile(const CStdString& strFilename) { M_INIFILE_FN_BGN(bool CIniFile::SaveEncryptedFile(const CStdString& strFilename))

if (strFilename != "") m_strPath = strFilename;

std::ofstream inifile; inifile.open(m_strPath);

for(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { inifile << "\n" << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN]) << Encrypt((*m_itSection).first) << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_SECTION_END]) << "\n";

for(m_itKey=((*m_itSection).second).begin(); m_itKey!=((*m_itSection).second).end(); m_itKey++) { inifile << Encrypt((*m_itKey).first) << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_KEY]) << Encrypt((*m_itKey).second) << "\n"; } }

inifile.close();

return true;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : void CIniFile::Reset() // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Reset IniFile object - clears all sections and keys //----------------------------------------------------------------------------- void CIniFile::Reset() { M_INIFILE_FN_BGN(void CIniFile::Reset())

for(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { ((*m_itSection).second).clear(); }

m_data.clear();

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : unsigned int CIniFile::GetSectionCount() // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get number of sections //----------------------------------------------------------------------------- unsigned int CIniFile::GetSectionCount() { M_INIFILE_FN_BGN(unsigned int CIniFile::GetSectionCount())

return m_data.size();

M_INIFILE_FN_END

return 0; }

//----------------------------------------------------------------------------- // Name : unsigned int CIniFile::GetKeyCount(const CStdString& strSection) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get number of keys in specified section //----------------------------------------------------------------------------- unsigned int CIniFile::GetKeyCount(const CStdString& strSection) { M_INIFILE_FN_BGN(unsigned int CIniFile::GetKeyCount(const CStdString& strSection))

return m_data[strSection].size();

M_INIFILE_FN_END

return 0; }

//----------------------------------------------------------------------------- // Name : unsigned int CIniFile::GetKeyCount(unsigned int iSection) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get number of keys in i-th section //----------------------------------------------------------------------------- unsigned int CIniFile::GetKeyCount(unsigned int iSection) { M_INIFILE_FN_BGN(unsigned int CIniFile::GetKeyCount(unsigned int iSection))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

return (*m_itSection).second.size();

M_INIFILE_FN_END

return 0; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetSection(unsigned int iSection) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get name of i-th section //----------------------------------------------------------------------------- CStdString CIniFile::GetSection(unsigned int iSection) { M_INIFILE_FN_BGN(CStdString CIniFile::GetSection(unsigned int iSection))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

return (*m_itSection).first;

M_INIFILE_FN_END

return ms_strError; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetKey(unsigned int iSection, unsigned int iKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get name of i-th key from i-th section //----------------------------------------------------------------------------- CStdString CIniFile::GetKey(unsigned int iSection, unsigned int iKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetKey(unsigned int iSection, unsigned int iKey))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

m_itKey = (*m_itSection).second.begin(); std::advance(m_itKey, iKey);

return (*m_itKey).first;

M_INIFILE_FN_END

return ms_strError; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetKey(const CStdString& strSection, unsigned int iKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get name of i-th key from specified section //----------------------------------------------------------------------------- CStdString CIniFile::GetKey(const CStdString& strSection, unsigned int iKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetKey(unsigned int iSection, unsigned int iKey))

m_itKey = m_data[strSection].begin(); std::advance(m_itKey, iKey);

return (*m_itKey).first;

M_INIFILE_FN_END

return ms_strError; }

//----------------------------------------------------------------------------- // Name : int CIniFile::GetSection(const CStdString& strSection) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get id of specified section //----------------------------------------------------------------------------- int CIniFile::GetSection(const CStdString& strSection) { M_FN_BGN(int CIniFile::GetSection(const CStdString& strSection))

int iCurrentSection = 0;

for(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { if ((*m_itSection).first == strSection) { return iCurrentSection; }

iCurrentSection++; }

return -1;

M_FN_END

return -1; }

//----------------------------------------------------------------------------- // Name : int CIniFile::GetKey(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get id of specified key from specified section //----------------------------------------------------------------------------- int CIniFile::GetKey(const CStdString& strSection, const CStdString& strKey) { M_FN_BGN(int CIniFile::GetKey(const CStdString& strKey);)

int iCurrentKey = 0;

for(m_itKey=m_data[strSection].begin(); m_itKey!=m_data[strSection].end(); m_itKey++) { if ((*m_itKey).first == strKey) { return iCurrentKey; }

iCurrentKey++; }

return -1;

M_FN_END

return -1; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get string value from specified section/key //----------------------------------------------------------------------------- CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey))

if (!m_bFastRead) { if (m_data.find(strSection) == m_data.end()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_FIND_SECTION]; } else if (m_data[strSection].find(strKey) == m_data[strSection].end()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_FIND_KEY]; } else { return m_data[strSection][strKey]; }

#ifdef WIN32 ::MessageBox(NULL, m_strLastError, m_strPath, MB_ICONWARNING); #endif

#ifdef INI_USE_EXEPTIONS throw(ms_strError.c_str()); #endif

return ms_strError; }

return m_data[strSection][strKey];

M_INIFILE_FN_END

return ms_strError; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get string value from specified section/key //----------------------------------------------------------------------------- CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey))

return GetValue(strSection,strKey);

M_INIFILE_FN_END

return ms_strError; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get string value from specified section/key and return default value if section or key not found //----------------------------------------------------------------------------- CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault))

if (!m_bFastRead) { if ( (m_data.find(strSection) == m_data.end()) || (m_data[strSection].find(strKey) == m_data[strSection].end()) ) { return strDefault; } }

return GetValue(strSection,strKey);

M_INIFILE_FN_END

return strDefault; }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get string value from specified section/key and return default value if section or key not found //----------------------------------------------------------------------------- CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault))

return GetValue(strSection,strKey,strDefault);

M_INIFILE_FN_END

return strDefault; }

//----------------------------------------------------------------------------- // Name : int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get integer value from specified section/key //----------------------------------------------------------------------------- int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey))

return atoi(GetValue(strSection,strKey).c_str());

M_INIFILE_FN_END

return ms_iError; }

//----------------------------------------------------------------------------- // Name : int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey, const int & iDefault) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get integer value from specified section/key and return default value if section or key not found //----------------------------------------------------------------------------- int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey, const int & iDefault) { M_INIFILE_FN_BGN(int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey, const int & iDefault))

CStdString strDefault; strDefault.Format(ms_strType[CIniFile::E_INI_TYPES::E_INTEGER], iDefault);

return atoi(GetValue(strSection,strKey,strDefault).c_str());

M_INIFILE_FN_END

return iDefault; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get boolean value from specified section/key //----------------------------------------------------------------------------- bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey))

return TO_BOOL(GetValueI(strSection,strKey));

M_INIFILE_FN_END

return TO_BOOL(ms_iError); }

//----------------------------------------------------------------------------- // Name : bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bDefault) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get boolean value from specified section/key and return default value if section or key not found //----------------------------------------------------------------------------- bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bDefault) { M_INIFILE_FN_BGN(bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bDefault))

return TO_BOOL(GetValueI(strSection,strKey,TO_INT(bDefault)));

M_INIFILE_FN_END

return TO_BOOL(bDefault); }

//----------------------------------------------------------------------------- // Name : float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get floating point value from specified section/key //----------------------------------------------------------------------------- float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey))

return (float)atof(GetValue(strSection,strKey).c_str());

M_INIFILE_FN_END

return ms_fError; }

//----------------------------------------------------------------------------- // Name : float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey, const float & fDefault) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get floating point value from specified section/key and return default value if section or key not found //----------------------------------------------------------------------------- float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey, const float & fDefault) { M_INIFILE_FN_BGN(float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey, const float & fDefault))

CStdString strDefault; strDefault.Format(ms_strType[CIniFile::E_INI_TYPES::E_FLOAT], fDefault);

return (float)atof(GetValue(strSection,strKey,strDefault).c_str());

M_INIFILE_FN_END

return fDefault; }

//----------------------------------------------------------------------------- // Name : void CIniFile::SetReadableExtension(const CStdString& ext) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Change readable exension //----------------------------------------------------------------------------- void CIniFile::SetReadableExtension(const CStdString& ext) { M_INIFILE_FN_BGN(void CIniFile::SetReadableExtension(const CStdString& ext))

m_strReadableExtension = ext;

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : void CIniFile::SetEncryptedExtension(const CStdString& ext) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Change crypted exension //----------------------------------------------------------------------------- void CIniFile::SetEncryptedExtension(const CStdString& ext) { M_INIFILE_FN_BGN(void CIniFile::SetEncryptedExtension(const CStdString& ext))

m_strEncryptedExtension = ext;

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::GetLastErrorMessage() // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Get last error message //----------------------------------------------------------------------------- CStdString CIniFile::GetLastErrorMessage() { M_INIFILE_FN_BGN(CStdString CIniFile::GetLastErrorMessage())

return m_strLastError;

M_INIFILE_FN_END

return "error in error handling !"; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool bCreate) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set string value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool bCreate) { M_INIFILE_FN_BGN(bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool bCreate))

if (m_data.find(strSection) == m_data.end()) { if (!bCreate) { return false; }

m_data.insert(CSection::value_type(strSection,CKey())); }

if (m_data[strSection].find(strKey) == m_data[strSection].end()) { if (!bCreate) { return false; }

m_data[strSection].insert(CKey::value_type(strKey,"")); }

m_data[strSection][strKey] = value; return true;

M_INIFILE_FN_END

return false;

}

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set string value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool create))

SetValue(strSection, strKey, value, create); return true;

M_INIFILE_FN_END

return false;

}

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const int & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set integer value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const int & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const int & value, bool create))

return SetValueI(strSection, strKey, value, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set boolean value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create))

return SetValueB(strSection, strKey, value, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const float & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set floating point value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const float & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const float & value, bool create))

return SetValueF(strSection, strKey, value, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValueI(const CStdString& strSection, const CStdString& strKey, const int & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set integer value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValueI(const CStdString& strSection, const CStdString& strKey, const int & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValueI(const CStdString& strSection, const CStdString& strKey, const int & value, bool create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_INTEGER],value); return SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValueB(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description :Set boolean value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValueB(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValueI(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_INTEGER],TO_INT(value)); return SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::SetValueF(const CStdString& strSection, const CStdString& strKey, const float & value, bool create) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Set floating point value to specified section/key. Possibility to create section/key if doesn't exist //----------------------------------------------------------------------------- bool CIniFile::SetValueF(const CStdString& strSection, const CStdString& strKey, const float & value, bool create) { M_INIFILE_FN_BGN(bool CIniFile::SetValueF(const CStdString& strSection, const CStdString& strKey, const float & value, bool create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_FLOAT],value); return SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::Delete(const CStdString& strSection, const CStdString& strKey) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Delete section/key //----------------------------------------------------------------------------- bool CIniFile::Delete(const CStdString& strSection, const CStdString& strKey) { M_INIFILE_FN_BGN(bool CIniFile::Delete(const CStdString& strSection, const CStdString& strKey))

m_data[strSection].erase(strKey);

return true;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : bool CIniFile::Delete(const CStdString& strSection) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : Delete section //----------------------------------------------------------------------------- bool CIniFile::Delete(const CStdString& strSection) { M_INIFILE_FN_BGN(bool CIniFile::Delete(const CStdString& strSection))

m_data.erase(strSection);

return true;

M_INIFILE_FN_END

return false; }

//----------------------------------------------------------------------------- // Name : std::istream & CIniFile::GetLine(std::istream & is, CStdString& str) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - get line from stream //----------------------------------------------------------------------------- std::istream & CIniFile::GetLine(std::istream & is, CStdString& str) { M_INIFILE_FN_BGN(std::istream & CIniFile::GetLine(std::istream & is, CStdString& str))

char buf[INI_LINE_MAX_LENGTH]; is.getline(buf, INI_LINE_MAX_LENGTH); str = buf; return is;

M_INIFILE_FN_END

return is; }

//----------------------------------------------------------------------------- // Name : void CIniFile::CleanString(CStdString * pString) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - clean given string (removes trailing characters) //----------------------------------------------------------------------------- void CIniFile::CleanString(CStdString * pString) { M_INIFILE_FN_BGN(void CIniFile::CleanString(CStdString * pString))

int iOldLength = pString->GetLength();

do for(unsigned int iTrim=0; iTrim<E_INI_TRIM::E_TRIM_COUNT; iTrim++) { iOldLength = pString->GetLength();

pString->TrimLeft (ms_strTrim[iTrim]); pString->TrimRight(ms_strTrim[iTrim]); } while(pString->GetLength() != iOldLength);

pString->TrimLeft (ms_strStringDelimiter); pString->TrimRight(ms_strStringDelimiter);

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::ManageComments(CStdString * pString) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - removes (and retrieve) comment from string //----------------------------------------------------------------------------- CStdString CIniFile::ManageComments(CStdString * pString) { M_INIFILE_FN_BGN(CStdString CIniFile::ManageComments(CStdString * pString))

// First, look for string delimiters

int iDelimiterBegin = pString->Find (ms_strStringDelimiter[0]); int iDelimiterEnd = pString->ReverseFind(ms_strStringDelimiter[0]);

if (iDelimiterEnd < iDelimiterBegin) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_END_DELIMITER]; }

// then manage comments

CStdString strComment = "";

int iPrevPos, iPos, iLength=pString->GetLength();

iPrevPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_0]); if ((iPrevPos<0)||((iPrevPos>iDelimiterBegin)&&(iPrevPos<iDelimiterEnd))) iPrevPos = iLength;

iPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_1]); if ((iPos<0)||((iPos>iDelimiterBegin)&&(iPos<iDelimiterEnd))) iPos = iLength;

iPos = (iPrevPos<iPos) ? iPrevPos : iPos;

iPrevPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_2]); if ((iPrevPos<0)||((iPrevPos>iDelimiterBegin)&&(iPrevPos<iDelimiterEnd))) iPrevPos = iLength;

iPos = (iPrevPos<iPos) ? iPrevPos : iPos;

if (iPos>=0) { strComment = pString->Right(iLength-iPos); *pString = pString->Left (iPos);

pString->TrimRight(); pString->TrimRight(ms_strComment[E_INI_COMMENTS::E_SPACING]); }

return strComment;

M_INIFILE_FN_END

return ""; }

//----------------------------------------------------------------------------- // Name : void CIniFile::Decrypt(CStdString& str) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - decrypt string (uses CCrypto) //----------------------------------------------------------------------------- void CIniFile::Decrypt(CStdString& str) { M_INIFILE_FN_BGN(void CIniFile::Decrypt(CStdString& str))

// CCrypto::Decrypt(&str);

M_INIFILE_FN_END }

//----------------------------------------------------------------------------- // Name : CStdString CIniFile::Encrypt(const CStdString& str) // Author : AV (Antoine Villepreux) // Date : 20/11/2000 // Description : internal function - encrypt string (uses CCrypto) //----------------------------------------------------------------------------- CStdString CIniFile::Encrypt(const CStdString& str) { M_INIFILE_FN_BGN(CStdString CIniFile::Encrypt(const CStdString& str))

CStdString strTmp = str;

// CCrypto::Encrypt(&strTmp);

return strTmp;

M_INIFILE_FN_END return ""; }

//-----------------------------------------------------------------------------

M_MODULE_END("CIniFile.cpp")

Currently browsing [inifile.zip] (62,782 bytes) - [Cpp version/CIniFile.h] - (7,482 bytes)


//------------------------------------------------------------------------------
// File name   : CIniFile.h
// Author      : Microïds - Antoine Villepreux
// Description : CIniFile class definition
// Purpose     : Easy *.ini files management
//------------------------------------------------------------------------------

#ifndef CINIFILE_H
#define CINIFILE_H

//------------------------------------------------------------------------------ // Precompiler options //------------------------------------------------------------------------------ #define INI_USE_EXEPTIONS #define INI_CASE_INENSITIVE #undef INI_SAVE_ON_EXIT

//------------------------------------------------------------------------------ // Includes //------------------------------------------------------------------------------ #include <map> #include <fstream> #include "CStdString.h"

//------------------------------------------------------------------------------ // CIniFile defines //------------------------------------------------------------------------------ #define INI_LINE_MAX_LENGTH 1024

//------------------------------------------------------------------------------ // CFilename definition //------------------------------------------------------------------------------ #define CFilename CStdString

//------------------------------------------------------------------------------ // CIniFile definition //------------------------------------------------------------------------------ class CIniFile { public: // created in memory, no load from disk CIniFile(); CIniFile(const CFilename &, bool bFastRead = false); virtual ~CIniFile();

// I/O - extension sensitive bool Load(const CFilename & filename = "", bool bFastRead = false); bool Save(const CFilename & filename = "");

// Clear all void Reset();

// Errors that 'GetValue' functions may return if key or section doesn't exist static const CStdString ms_strError; static const int ms_iError; static const float ms_fError;

// Get/Set values CStdString GetValue (const CStdString& strSection, const CStdString& strKey); // #ifdef INI_USE_EXEPTIONS throw CStdString CStdString GetValueS(const CStdString& strSection, const CStdString& strKey); int GetValueI(const CStdString& strSection, const CStdString& strKey); bool GetValueB(const CStdString& strSection, const CStdString& strKey); float GetValueF(const CStdString& strSection, const CStdString& strKey);

// No error but default value returned if section/key doesn't exists - use at your own risk CStdString GetValue (const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault); CStdString GetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault); int GetValueI(const CStdString& strSection, const CStdString& strKey, const int & iDefault ); bool GetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bDefault ); float GetValueF(const CStdString& strSection, const CStdString& strKey, const float & fDefault );

// beware!! 'Save' After Setting values (to save to disk) bool SetValue (const CStdString& strSection, const CStdString& strKey, const CStdString& strValue, bool bCreate=true); bool SetValue (const CStdString& strSection, const CStdString& strKey, const int & iValue, bool bCreate=true); bool SetValue (const CStdString& strSection, const CStdString& strKey, const bool & bValue, bool bCreate=true); bool SetValue (const CStdString& strSection, const CStdString& strKey, const float & fValue, bool bCreate=true); bool SetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strValue, bool bCreate=true); bool SetValueI(const CStdString& strSection, const CStdString& strKey, const int & iValue, bool bCreate=true); bool SetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bValue, bool bCreate=true); bool SetValueF(const CStdString& strSection, const CStdString& strKey, const float & fValue, bool bCreate=true);

// Sections/Keys Deletion/Retrieval bool Delete(const CStdString& strSection); bool Delete(const CStdString& strSection, const CStdString& strKey);

unsigned int GetSectionCount(); unsigned int GetKeyCount(unsigned int iSection); unsigned int GetKeyCount(const CStdString& strSection);

CStdString GetSection(unsigned int iSection); CStdString GetKey (unsigned int iSection, unsigned int iKey); CStdString GetKey (const CStdString& strSection, unsigned int iKey);

int GetSection(const CStdString& strSection); int GetKey (const CStdString& strSection, const CStdString& strKey); // Extensions void SetReadableExtension (const CStdString&); void SetEncryptedExtension(const CStdString&);

// Error messages CStdString GetLastErrorMessage();

//------------------------------------------------------------------------------ // Private //------------------------------------------------------------------------------ protected:

enum E_INI_ERROR_MESSAGES { E_READ = 0, E_WRITE, E_FIND_SECTION, E_FIND_KEY, E_UNKNOWN_EXTENSION, E_END_DELIMITER, E_ERROR_MESSAGES_COUNT, };

enum E_INI_COMMENTS { E_0 = 0, E_1, E_2, E_SPACING, E_COMMENTS_COUNT };

enum E_INI_TYPES { E_INTEGER = 0, E_FLOAT, E_STRING, E_TYPES_COUNT };

enum E_INI_MARKUPS { E_SECTION_BEGIN = 0, E_SECTION_END, E_KEY, E_MARKUPS_COUNT };

enum E_INI_TRIM { E_TRIM_0 = 0, E_TRIM_1, E_TRIM_COUNT };

enum E_INI_EXTENSIONS { E_READABLE = 0, E_ENCRYPTED, E_EXTENSIONS_COUNT };

private:

// Constants static const CStdString ms_strErrorMsg []; static const CStdString ms_strComment []; static const CStdString ms_strType []; static const CStdString ms_strMarkup []; static const CStdString ms_strTrim []; static const CStdString ms_strExtension []; static const CStdString ms_strStringDelimiter;

// Data typedef std::map<CStdString, CStdString> CKey; typedef std::map<CStdString, CKey> CSection;

CSection m_data;

CSection::iterator m_itSection; CKey::iterator m_itKey;

// File CStdString m_strPath; std::istream & GetLine(std::istream&, CStdString&);

bool LoadReadableFile (const CFilename& strFilename = "", bool bIsReadable = true); bool SaveReadableFile (const CFilename& strFilename = ""); bool SaveEncryptedFile(const CFilename& strFilename = "");

// String format CStdString ManageComments(CStdString*); void CleanString(CStdString*);

// Encryption CStdString m_strEncryptedExtension; CStdString m_strReadableExtension;

void Decrypt(CStdString&); CStdString Encrypt(const CStdString&);

// Various CStdString m_strLastError; bool m_bFastRead; };

//------------------------------------------------------------------------------ // Inline functions //------------------------------------------------------------------------------ #endif // CIniFile

Currently browsing [inifile.zip] (62,782 bytes) - [Cpp version/CStdString.h] - (83,238 bytes)

// =============================================================================
//  FILE:  StdString.h
//  AUTHOR:	Joe O'Leary (with outside help noted in comments)
//  REMARKS:
//		This header file declares the CStdStr template.  This template derives
//		the Standard C++ Library basic_string<> template and add to it the
//		the following conveniences:
//			- The full MFC CString set of functions (including implicit cast)
//			- writing to/reading from COM IStream interfaces
//			- Functional objects for use in STL algorithms
//
//		From this template, we intstantiate two classes:  CStdStringA and
//		CStdStringW.  The name "CStdString" is just a #define of one of these,
//		based upone the _UNICODE macro setting
//
//		This header also declares our own version of the MFC/ATL UNICODE-MBCS
//		conversion macros.  Our version looks exactly like the Microsoft's to
//		facilitate portability.
//
//	NOTE:
//		If you you use this in an MFC or ATL build, you should include either
//		afx.h or atlbase.h first, as appropriate.
//
//	PEOPLE WHO HAVE CONTRIBUTED TO THIS CLASS:
//
//		Several people have helped me iron out problems and othewise improve
//		this class.  OK, this is a long list but in my own defense, this code
//		has undergone two major rewrites.  Many of the improvements became
//		necessary after I rewrote the code as a template.  Others helped me
//		improve the CString facade.
//
//		Anyway, these people are (in chronological order):
//
//			- Pete the Plumber (???)
//			- Julian Selman
//			- Chris (of Melbsys)
//			- Dave Plummer
//			- John C Sipos
//			- Chris Sells
//			- Nigel Nunn
//			- Fan Xia
//			- Matthew Williams
//			- Carl Engman
//			- Mark Zeren
//			- Craig Watson
//			- Rich Zuris
//			- Karim Ratib
//			- Chris Conti
//			- Baptiste Lepilleur
//			- Greg Pickles
//			- Jim Cline
//			- Jeff Kohn
//			- Todd Heckel
//			- Ullrich Pollähne
//			- Joe Vitaterna
//			- Joe Woodbury
//
//	REVISION HISTORY
//
//	  2000-JUL-11 - Joe Woodbury noted that the CString::Find docs don't match
//					what the CString::Find code really ends up doing.   I was
//					trying to match the docs.  Now I match the CString code
//				  - Joe also caught me truncating strings for GetBuffer() calls
//					when the supplied length was less than the current length.
//
//	  2000-MAY-25 - Better support for STLPORT's Standard library distribution
//				  - Got rid of the NSP macro - it interfered with Koenig lookup
//				  - Thanks to Joe Woodbury for catching a TrimLeft() bug that
//					I introduced in January.  Empty strings were not getting
//					trimmed
//
//	  2000-APR-17 - Thanks to Joe Vitaterna for pointing out that ReverseFind
//					is supposed to be a const function.
//
//	  2000-MAR-07 - Thanks to Ullrich Pollähne for catching a range bug in one
//					of the overloads of assign.
//
//    2000-FEB-01 - You can now use CStdString on the Mac with CodeWarrior!
//					Thanks to Todd Heckel for helping out with this.
//
//	  2000-JAN-23 - Thanks to Jim Cline for pointing out how I could make the
//					Trim() function more efficient.
//				  - Thanks to Jeff Kohn for prompting me to find and fix a typo
//					in one of the addition operators that takes _bstr_t.
//				  - Got rid of the .CPP file -  you only need StdString.h now!
//
//	  1999-DEC-22 - Thanks to Greg Pickles for helping me identify a problem
//					with my implementation of CStdString::FormatV in which
//					resulting string might not be properly NULL terminated.
//
//	  1999-DEC-06 - Chris Conti pointed yet another basic_string<> assignment
//					bug that MS has not fixed.  CStdString did nothing to fix
//					it either but it does now!  The bug was: create a string
//					longer than 31 characters, get a pointer to it (via c_str())
//					and then assign that pointer to the original string object.
//					The resulting string would be empty.  Not with CStdString!
//
//	  1999-OCT-06 - BufferSet was erasing the string even when it was merely
//					supposed to shrink it.  Fixed.  Thanks to Chris Conti.
//				  - Some of the Q172398 fixes were not checking for assignment-
//					to-self.  Fixed.  Thanks to Baptiste Lepilleur.
//
//	  1999-AUG-20 - Improved Load() function to be more efficient by using 
//					SizeOfResource().  Thanks to Rich Zuris for this.
//				  - Corrected resource ID constructor, again thanks to Rich.
//				  - Fixed a bug that occurred with UNICODE characters above
//					the first 255 ANSI ones.  Thanks to Craig Watson. 
//				  - Added missing overloads of TrimLeft() and TrimRight().
//					Thanks to Karim Ratib for pointing them out
//
//	  1999-JUL-21 - Made all calls to GetBuf() with no args check length first.
//
//	  1999-JUL-10 - Improved MFC/ATL independence of conversion macros
//				  - Added SS_NO_REFCOUNT macro to allow you to disable any
//					reference-counting your basic_string<> impl. may do.
//				  - Improved ReleaseBuffer() to be as forgiving as CString.
//					Thanks for Fan Xia for helping me find this and to
//					Matthew Williams for pointing it out directly.
//
//	  1999-JUL-06 - Thanks to Nigel Nunn for catching a very sneaky bug in
//					ToLower/ToUpper.  They should call GetBuf() instead of
//					data() in order to ensure the changed string buffer is not
//					reference-counted (in those implementations that refcount).
//
//	  1999-JUL-01 - Added a true CString facade.  Now you can use CStdString as
//					a drop-in replacement for CString.  If you find this useful,
//					you can thank Chris Sells for finally convincing me to give
//					in and implement it.
//				  - Changed operators << and >> (for MFC CArchive) to serialize
//					EXACTLY as CString's do.  So now you can send a CString out
//					to a CArchive and later read it in as a CStdString.   I have
//					no idea why you would want to do this but you can. 
//
//	  1999-JUN-21 - Changed the CStdString class into the CStdStr template.
//				  - Fixed FormatV() to correctly decrement the loop counter.
//					This was harmless bug but a bug nevertheless.  Thanks to
//					Chris (of Melbsys) for pointing it out
//				  - Changed Format() to try a normal stack-based array before
//					using to _alloca().
//				  - Updated the text conversion macros to properly use code
//					pages and to fit in better in MFC/ATL builds.  In other
//					words, I copied Microsoft's conversion stuff again. 
//				  - Added equivalents of CString::GetBuffer, GetBufferSetLength
//				  - new sscpy() replacement of CStdString::CopyString()
//				  - a Trim() function that combines TrimRight() and TrimLeft().
//
//	  1999-MAR-13 - Corrected the "NotSpace" functional object to use _istpace()
//					instead of _isspace()   Thanks to Dave Plummer for this.
//
//	  1999-FEB-26 - Removed errant line (left over from testing) that #defined
//					_MFC_VER.  Thanks to John C Sipos for noticing this.
//
//	  1999-FEB-03 - Fixed a bug in a rarely-used overload of operator+() that
//					caused infinite recursion and stack overflow
//				  - Added member functions to simplify the process of
//					persisting CStdStrings to/from DCOM IStream interfaces 
//				  - Added functional objects (e.g. StdStringLessNoCase) that
//					allow CStdStrings to be used as keys STL map objects with
//					case-insensitive comparison 
//				  - Added array indexing operators (i.e. operator[]).  I
//					originally assumed that these were unnecessary and would be
//					inherited from basic_string.  However, without them, Visual
//					C++ complains about ambiguous overloads when you try to use
//					them.  Thanks to Julian Selman to pointing this out. 
//
//	  1998-FEB-?? - Added overloads of assign() function to completely account
//					for Q172398 bug.  Thanks to "Pete the Plumber" for this
//
//	  1998-FEB-?? - Initial submission
//
// COPYRIGHT:
//		1999 Joseph M. O'Leary.  This code is free.  Use it anywhere you want.
//		Rewrite it, restructure it, whatever.  Please don't blame me if it makes
//		your $30 billion dollar satellite explode in orbit.  If you redistribute
//		it in any form, I'd appreciate it if you would leave this notice here.
//
//		If you find any bugs, please let me know:
//
//				jmoleary@earthlink.net
//				http://home.earthlink.net/~jmoleary
// =============================================================================

// Avoid multiple inclusion the VC++ way,
// Turn off browser references
// Turn off unavoidable compiler warnings

#if defined(_MSC_VER) && (_MSC_VER > 1100)
	#pragma once
	#pragma component(browser, off, references, "CStdString")
	#pragma warning (disable : 4290) // C++ Exception Specification ignored
	#pragma warning (disable : 4127) // Conditional expression is constant
	#pragma warning (disable : 4097) // typedef name used as synonym for class name

	// AV - 22/08/2000
	// To avoid "identifier was truncated to '255' characters in the debug information"
	#pragma warning (disable : 4786)

#endif

#ifndef STDSTRING_H #define STDSTRING_H

// MACRO: SS_NO_REFCOUNT: // turns off reference counting at the assignment level // I define this by default. comment it out if you don't want it. #define SS_NO_REFCOUNT

// In non-Visual C++ and/or non-Win32 builds, we can't use some cool stuff. #if !defined(_MSC_VER) || !defined(_WIN32) #define SS_ANSI #endif

// Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well #if defined (_UNICODE) && !defined (UNICODE) #define UNICODE #endif #if defined (UNICODE) && !defined (_UNICODE) #define _UNICODE #endif

// ----------------------------------------------------------------------------- // MIN and MAX. The Standard C++ template versions go by so many names (at // at least in the MS implementation) that you never know what's available // ----------------------------------------------------------------------------- template<class Type> inline const Type& SSMIN(const Type& arg1, const Type& arg2) { return arg2 < arg1 ? arg2 : arg1; } template<class Type> inline const Type& SSMAX(const Type& arg1, const Type& arg2) { return arg2 > arg1 ? arg2 : arg1; }

// If they have not #included W32Base.h (part of my W32 utility library) then // we need to define some stuff. Otherwise, this is all defined there. #if !defined(W32BASE_H)

// If they want us to use only standard C++ stuff (no Win32 stuff) #ifdef SS_ANSI

// On non-Win32 platforms, there is no TCHAR.H so define what we need #ifndef _WIN32

typedef const char* PCSTR; typedef char* PSTR; typedef const wchar_t* PCWSTR; typedef wchar_t* PWSTR; #ifdef UNICODE typedef wchar_t TCHAR; #else typedef char TCHAR; #endif typedef wchar_t OLECHAR;

#else

#include <TCHAR.H> #include <WTYPES.H> #ifndef STRICT #define STRICT #endif

#endif // #ifndef _WIN32

// Make sure ASSERT and verify are defined in an ANSI fashion #ifndef ASSERT #include <assert.h> #define ASSERT(f) assert((f)) #endif #ifndef VERIFY #ifdef _DEBUG #define VERIFY(x) ASSERT((x)) #else #define VERIFY(x) x #endif #endif

#else // #ifdef SS_ANSI #include <TCHAR.H> #include <WTYPES.H> #ifndef STRICT #define STRICT #endif

// Make sure ASSERT and verify are defined #ifndef ASSERT #include <crtdbg.h> #define ASSERT(f) _ASSERTE((f)) #endif #ifndef VERIFY #ifdef _DEBUG #define VERIFY(x) ASSERT((x)) #else #define VERIFY(x) x #endif #endif

#endif // #ifdef SS_ANSI #ifndef UNUSED #define UNUSED(x) x #endif

#endif // #ifndef W32BASE_H // Standard headers needed #include <string> // basic_string #include <algorithm> // for_each, etc. #include <functional> // for StdStringLessNoCase, et al #include <locale> // for various facets // If this is a recent enough version of VC include comdef.h, so we can write // member functions to deal with COM types & compiler support classes e.g. _bstr_t #if defined (_MSC_VER) && (_MSC_VER >= 1100) #include <comdef.h> #define SS_INC_COMDEF // signal that we #included MS comdef.h file #define STDSTRING_INC_COMDEF #define SS_NOTHROW __declspec(nothrow) #else #define SS_NOTHROW #endif

#ifndef TRACE #define TRACE_DEFINED_HERE #define TRACE #endif

// Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR. I hate to use the // versions with the "L" in front of them because that's a leftover from Win 16 // days, even though it evaluates to the same thing. Therefore, Define a PCSTR // as an LPCTSTR. #if !defined(PCTSTR) && !defined(PCTSTR_DEFINED) typedef const TCHAR* PCTSTR; #define PCTSTR_DEFINED #endif

#if !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED) typedef const OLECHAR* PCOLESTR; #define PCOLESTR_DEFINED #endif

#if !defined(POLESTR) && !defined(POLESTR_DEFINED) typedef OLECHAR* POLESTR; #define POLESTR_DEFINED #endif

#if !defined(PCUSTR) && !defined(PCUSTR_DEFINED) typedef const unsigned char* PCUSTR; typedef unsigned char* PUSTR; #define PCUSTR_DEFINED #endif

// SS_USE_FACET macro and why we need it: // // Since I'm a good little Standard C++ programmer, I use locales. Thus, I // need to make use of the use_facet<> template function here. Unfortunately, // this need is complicated by the fact the MS' implementation of the Standard // C++ Library has a non-standard version of use_facet that takes more // arguments than the standard dictates. Since I'm trying to write CStdString // to work with any version of the Standard library, this presents a problem. // // The upshot of this is that I can't do 'use_facet' directly. The MS' docs // tell me that I have to use a macro, _USE() instead. Since _USE obviously // won't be available in other implementations, this means that I have to write // my OWN macro -- SS_USE_FACET -- that evaluates either to _USE or to the // standard, use_facet. // // If you are having trouble with the SS_USE_FACET macro, in your implementation // of the Standard C++ Library, you can define your own version of SS_USE_FACET. #ifndef schMSG #define schSTR(x) #x #define schSTR2(x) schSTR(x) #define schMSG(desc) message(__FILE__ "(" schSTR2(__LINE__) "):" #desc) #endif

#ifndef SS_USE_FACET // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for // all MSVC builds, erroneously in my opinion. It causes problems for // my SS_ANSI builds. In my code, I always comment out that line. You'll // find it in \stlport\config\stl_msvc.h #if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 ) #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER) #ifdef SS_ANSI #pragma schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!) #endif #endif #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc) #elif defined(_MSC_VER ) #define SS_USE_FACET(loc, fac) std::_USE(loc,fac) #else #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc) #endif #endif

// ============================================================================= // UNICODE/MBCS conversion macros. Made to work just like the MFC/ATL ones. // ============================================================================= // First define the conversion helper functions. We define these regardless of // any preprocessor macro settings since their names won't collide. #ifdef SS_ANSI // Are we doing things the standard, non-Win32 way?... typedef std::codecvt<wchar_t, char, mbstate_t> SSCodeCvt;

// Not sure if we need all these headers. I believe ANSI says we do. #include <stdio.h> #include <stdarg.h> #include <wchar.h> #ifndef va_start #include <varargs.h> #endif

// StdCodeCvt - made to look like Win32 functions WideCharToMultiByte annd // MultiByteToWideChar but uses locales in SS_ANSI builds inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars, const std::locale& loc=std::locale()) { ASSERT(NULL != pA); ASSERT(NULL != pW); pW[0] = '\0'; PSTR pBadA = NULL; PWSTR pBadW = NULL; SSCodeCvt::result res = SSCodeCvt::ok; const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); res = conv.in(res, pA, pA + nChars, pBadA, pW, pW + nChars, pBadW); ASSERT(SSCodeCvt::ok == res); return pW; } inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars, const std::locale& loc=std::locale()) { return StdCodeCvt(pW, (PCSTR)pA, nChars, loc); }

inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars, const std::locale& loc=std::locale()) { ASSERT(NULL != pA); ASSERT(NULL != pW); pA[0] = '\0'; PSTR pBadA = NULL; PWSTR pBadW = NULL; const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); SSCodeCvt::result res = SSCodeCvt::ok; res = conv.out(res, pW, pW + nChars, pBadW, pA, pA + nChars, pBadA); ASSERT(SSCodeCvt::ok == res); return pA; } inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars, const std::locale& loc=std::locale()) { return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, loc); }

#else // ...or are we doing things assuming win32 and Visual C++? #include <malloc.h> // needed for _alloca inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars, UINT acp=CP_ACP) { ASSERT(NULL != pA); ASSERT(NULL != pW); pW[0] = '\0'; MultiByteToWideChar(acp, 0, pA, -1, pW, nChars); return pW; } inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars, UINT acp=CP_ACP) { return StdCodeCvt(pW, (PCSTR)pA, nChars, acp); }

inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP) { ASSERT(NULL != pA); ASSERT(NULL != pW); pA[0] = '\0'; WideCharToMultiByte(acp, 0, pW, -1, pA, nChars, NULL, NULL); return pA; } inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP) { return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, acp); }

// Define our conversion macros to look exactly like Microsoft's to // facilitate using this stuff both with and without MFC/ATL #ifdef _CONVERSION_USES_THREAD_LOCALE #ifndef _DEBUG #define SSCVT int _cvt; _cvt; UINT _acp=GetACP(); \ _acp; PCWSTR _pw; _pw; PCSTR _pa; _pa #else #define SSCVT int _cvt = 0; _cvt; UINT _acp=GetACP();\ _acp; PCWSTR _pw=NULL; _pw; PCSTR _pa=NULL; _pa #endif #else #ifndef _DEBUG #define SSCVT int _cvt; _cvt; UINT _acp=CP_ACP; _acp;\ PCWSTR _pw; _pw; PCSTR _pa; _pa #else #define SSCVT int _cvt = 0; _cvt; UINT _acp=CP_ACP; \ _acp; PCWSTR _pw=NULL; _pw; PCSTR _pa=NULL; _pa #endif #endif

#ifdef _CONVERSION_USES_THREAD_LOCALE #define SSA2W(pa) (\ ((_pa = pa) == NULL) ? NULL : (\ _cvt = (strlen(_pa)+1),\ StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt, _acp))) #define SSW2A(pw) (\ ((_pw = pw) == NULL) ? NULL : (\ _cvt = (wcslen(_pw)+1)*2,\ StdW2AHelper((LPSTR) _alloca(_cvt), _pw, _cvt, _acp))) #else #define SSA2W(pa) (\ ((_pa = pa) == NULL) ? NULL : (\ _cvt = (strlen(_pa)+1),\ StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt))) #define SSW2A(pw) (\ ((_pw = pw) == NULL) ? NULL : (\ _cvt = (wcslen(_pw)+1)*2,\ StdCodeCvt((LPSTR) _alloca(_cvt), _pw, _cvt))) #endif

#define SSA2CW(pa) ((PCWSTR)SSA2W((pa))) #define SSW2CA(pw) ((PCSTR)SSW2A((pw)))

#ifdef UNICODE #define SST2A SSW2A #define SSA2T SSA2W #define SST2CA SSW2CA #define SSA2CT SSA2CW inline PWSTR SST2W(PTSTR p) { return p; } inline PTSTR SSW2T(PWSTR p) { return p; } inline PCWSTR SST2CW(PCTSTR p) { return p; } inline PCTSTR SSW2CT(PCWSTR p) { return p; } #else #define SST2W SSA2W #define SSW2T SSW2A #define SST2CW SSA2CW #define SSW2CT SSW2CA inline PSTR SST2A(PTSTR p) { return p; } inline PTSTR SSA2T(PSTR p) { return p; } inline PCSTR SST2CA(PCTSTR p) { return p; } inline PCTSTR SSA2CT(PCSTR p) { return p; } #endif // #ifdef UNICODE #if defined(UNICODE) // in these cases the default (TCHAR) is the same as OLECHAR inline PCOLESTR SST2COLE(PCTSTR p) { return p; } inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; } inline POLESTR SST2OLE(PTSTR p) { return p; } inline PTSTR SSOLE2T(POLESTR p) { return p; } #elif defined(OLE2ANSI) // in these cases the default (TCHAR) is the same as OLECHAR inline PCOLESTR SST2COLE(PCTSTR p) { return p; } inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; } inline POLESTR SST2OLE(PTSTR p) { return p; } inline PTSTR SSOLE2T(POLESTR p) { return p; } #else //CharNextW doesn't work on Win95 so we use this #define SST2COLE(pa) SSA2CW((pa)) #define SST2OLE(pa) SSA2W((pa)) #define SSOLE2CT(po) SSW2CA((po)) #define SSOLE2T(po) SSW2A((po)) #endif

#ifdef OLE2ANSI #define SSW2OLE SSW2A #define SSOLE2W SSA2W #define SSW2COLE SSW2CA #define SSOLE2CW SSA2CW inline POLESTR SSA2OLE(PSTR p) { return p; } inline PSTR SSOLE2A(POLESTR p) { return p; } inline PCOLESTR SSA2COLE(PCSTR p) { return p; } inline PCSTR SSOLE2CA(PCOLESTR p){ return p; } #else #define SSA2OLE SSA2W #define SSOLE2A SSW2A #define SSA2COLE SSA2CW #define SSOLE2CA SSW2CA inline POLESTR SSW2OLE(PWSTR p) { return p; } inline PWSTR SSOLE2W(POLESTR p) { return p; } inline PCOLESTR SSW2COLE(PCWSTR p) { return p; } inline PCWSTR SSOLE2CW(PCOLESTR p){ return p; } #endif

// Above we've defined macros that look like MS' but all have // an 'SS' prefix. Now we need the real macros. We'll either // get them from the macros above or from MFC/ATL. If // SS_NO_CONVERSION is #defined, we'll forgo them #ifndef SS_NO_CONVERSION

#if defined (USES_CONVERSION)

#define _NO_STDCONVERSION // just to be consistent #else

#ifdef _MFC_VER

#include <afxconv.h> #define _NO_STDCONVERSION // just to be consistent #else

#define USES_CONVERSION SSCVT #define A2CW SSA2CW #define W2CA SSW2CA #define T2A SST2A #define A2T SSA2T #define T2W SST2W #define W2T SSW2T #define T2CA SST2CA #define A2CT SSA2CT #define T2CW SST2CW #define W2CT SSW2CT #define ocslen sslen #define ocscpy sscpy #define T2COLE SST2COLE #define OLE2CT SSOLE2CT #define T2OLE SST2COLE #define OLE2T SSOLE2CT #define A2OLE SSA2OLE #define OLE2A SSOLE2A #define W2OLE SSW2OLE #define OLE2W SSOLE2W #define A2COLE SSA2COLE #define OLE2CA SSOLE2CA #define W2COLE SSW2COLE #define OLE2CW SSOLE2CW #endif // #ifdef _MFC_VER #endif // #ifndef USES_CONVERSION #endif // #ifndef SS_NO_CONVERSION // Define ostring - generic name for std::basic_string<OLECHAR> #if !defined(ostring) && !defined(OSTRING_DEFINED) typedef std::basic_string<OLECHAR> ostring; #define OSTRING_DEFINED #endif

#endif // #ifndef SS_ANSI // StdCodeCvt when there's no conversion to be done inline PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, int nChars) { pDst[0] = '\0'; std::char_traits<char>().copy(pDst, pSrc, nChars); if ( nChars > 0 ) pDst[nChars] = '\0';

return pDst; } inline PSTR StdCodeCvt(PSTR pDst, PCUSTR pSrc, int nChars) { return StdCodeCvt(pDst, (PCSTR)pSrc, nChars); } inline PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, int nChars) { return (PUSTR)StdCodeCvt((PSTR)pDst, pSrc, nChars); }

inline PWSTR StdCodeCvt(PWSTR pDst, PCWSTR pSrc, int nChars) { pDst[0] = '\0'; std::char_traits<wchar_t>().copy(pDst, pSrc, nChars); if ( nChars > 0 ) pDst[nChars] = '\0';

return pDst; }

// Define tstring -- generic name for std::basic_string<TCHAR> #if !defined(tstring) && !defined(TSTRING_DEFINED) typedef std::basic_string<TCHAR> tstring; #define TSTRING_DEFINED #endif

// a very shorthand way of applying the fix for KB problem Q172398 // (basic_string assignment bug) #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) #define Q172398(x) (x).erase() #else #define Q172398(x) #endif

// ============================================================================= // INLINE FUNCTIONS ON WHICH CSTDSTRING RELIES // // Usually for generic text mapping, we rely on preprocessor macro definitions // to map to string functions. However the CStdStr<> template cannot use // macro-based generic text mappings because its character types do not get // resolved until template processing which comes AFTER macro processing. In // other words, UNICODE is of little help to us in the CStdStr template // // Therefore, to keep the CStdStr declaration simple, we have these inline // functions. The template calls them often. Since they are inline (and NOT // exported when this is built as a DLL), they will probably be resolved away // to nothing. // // Without these functions, the CStdStr<> template would probably have to broken // out into two, almost identical classes. Either that or it would be a huge, // convoluted mess, with tons of "if" statements all over the place checking the // size of template parameter CT. // // In several cases, you will see two versions of each function. One version is // the more portable, standard way of doing things, while the other is the // non-standard, but often significantly faster Visual C++ way. // ============================================================================= // If they defined SS_NO_REFCOUNT, then we must convert all assignments #ifdef SS_NO_REFCOUNT #define SSREF(x) (x).c_str() #else #define SSREF(x) (x) #endif

// ----------------------------------------------------------------------------- // sslen: strlen/wcslen wrappers // ----------------------------------------------------------------------------- template<typename CT> inline int sslen(const CT* pT) { return NULL == pT ? 0 : std::char_traits<CT>::length(pT); } inline SS_NOTHROW int sslen(const std::string& s) { return s.length(); } inline SS_NOTHROW int sslen(const std::wstring& s) { return s.length(); }

// ----------------------------------------------------------------------------- // ssasn: assignment functions -- assign "sSrc" to "sDst" // ----------------------------------------------------------------------------- typedef std::string::size_type SS_SIZETYPE; // just for shorthand, really typedef std::string::pointer SS_PTRTYPE; typedef std::wstring::size_type SW_SIZETYPE; typedef std::wstring::pointer SW_PTRTYPE;

inline void ssasn(std::string& sDst, const std::string& sSrc) { if ( sDst.c_str() != sSrc.c_str() ) { sDst.erase(); sDst.assign(SSREF(sSrc)); } } inline void ssasn(std::string& sDst, PCSTR pA) { // Watch out for NULLs, as always. if ( NULL == pA ) { sDst.erase(); }

// If pA actually points to part of sDst, we must NOT erase(), but // rather take a substring else if ( pA >= sDst.c_str() && pA <= sDst.c_str() + sDst.size() ) { sDst =sDst.substr(static_cast<SS_SIZETYPE>(pA-sDst.c_str())); }

// Otherwise (most cases) apply the assignment bug fix, if applicable // and do the assignment else { Q172398(sDst); sDst.assign(pA); } } inline void ssasn(std::string& sDst, const std::wstring& sSrc) { #ifdef SS_ANSI int nLen = sSrc.size(); sDst.resize(0); sDst.resize(nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen); #else SSCVT; sDst.assign(SSW2CA(sSrc.c_str())); #endif } inline void ssasn(std::string& sDst, PCWSTR pW) { #ifdef SS_ANSI int nLen = sslen(pW); sDst.resize(0); sDst.resize(nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), pW, nLen); #else SSCVT; sDst.assign(pW ? SSW2CA(pW) : ""); #endif } inline void ssasn(std::string& sDst, const int nNull) { UNUSED(nNull); ASSERT(nNull==NULL); sDst.assign(""); } inline void ssasn(std::wstring& sDst, const std::wstring& sSrc) { if ( sDst.c_str() != sSrc.c_str() ) { sDst.erase(); sDst.assign(SSREF(sSrc)); } } inline void ssasn(std::wstring& sDst, PCWSTR pW) { // Watch out for NULLs, as always. if ( NULL == pW ) { sDst.erase(); }

// If pW actually points to part of sDst, we must NOT erase(), but // rather take a substring else if ( pW >= sDst.c_str() && pW <= sDst.c_str() + sDst.size() ) { sDst = sDst.substr(static_cast<SW_SIZETYPE>(pW-sDst.c_str())); }

// Otherwise (most cases) apply the assignment bug fix, if applicable // and do the assignment else { Q172398(sDst); sDst.assign(pW); } } #undef StrSizeType inline void ssasn(std::wstring& sDst, const std::string& sSrc) { #ifdef SS_ANSI int nLen = sSrc.size(); sDst.resize(0); sDst.resize(nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen); #else SSCVT; sDst.assign(SSA2CW(sSrc.c_str())); #endif } inline void ssasn(std::wstring& sDst, PCSTR pA) { #ifdef SS_ANSI int nLen = sslen(pA); sDst.resize(0); sDst.resize(nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), pA, nLen); #else SSCVT; sDst.assign(pA ? SSA2CW(pA) : L""); #endif } inline void ssasn(std::wstring& sDst, const int nNull) { UNUSED(nNull); ASSERT(nNull==NULL); sDst.assign(L""); }

// ----------------------------------------------------------------------------- // ssadd: string object concatenation -- add second argument to first // ----------------------------------------------------------------------------- inline void ssadd(std::string& sDst, const std::wstring& sSrc) { #ifdef SS_ANSI int nLen = sSrc.size(); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen); #else SSCVT; sDst.append(SSW2CA(sSrc.c_str())); #endif } inline void ssadd(std::string& sDst, const std::string& sSrc) { sDst.append(sSrc.c_str()); } inline void ssadd(std::string& sDst, PCWSTR pW) { #ifdef SS_ANSI int nLen = sslen(pW); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), pW, nLen); #else SSCVT; if ( NULL != pW ) sDst.append(SSW2CA(pW)); #endif } inline void ssadd(std::string& sDst, PCSTR pA) { if ( pA ) sDst.append(pA); } inline void ssadd(std::wstring& sDst, const std::wstring& sSrc) { sDst.append(sSrc.c_str()); } inline void ssadd(std::wstring& sDst, const std::string& sSrc) { #ifdef SS_ANSI int nLen = sSrc.size(); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen); #else SSCVT; sDst.append(SSA2CW(sSrc.c_str())); #endif } inline void ssadd(std::wstring& sDst, PCSTR pA) { #ifdef SS_ANSI int nLen = sslen(pA); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), pA, nLen); #else SSCVT; if ( NULL != pA ) sDst.append(SSA2CW(pA)); #endif } inline void ssadd(std::wstring& sDst, PCWSTR pW) { if ( pW ) sDst.append(pW); }

// ----------------------------------------------------------------------------- // ssicmp: comparison (case insensitive ) // ----------------------------------------------------------------------------- #ifdef SS_ANSI template<typename CT> inline int ssicmp(const CT* pA1, const CT* pA2) { std::locale loc; const std::ctype<CT>& ct = SS_USE_FACET(loc, std::ctype<CT>); CT f; CT l;

do { f = ct.tolower(*(pA1++)); l = ct.tolower(*(pA2++)); } while ( (f) && (f == l) );

return (int)(f - l); } #else #ifdef _MBCS inline long sscmp(PCSTR pA1, PCSTR pA2) { return _mbscmp((PCUSTR)pA1, (PCUSTR)pA2); } inline long ssicmp(PCSTR pA1, PCSTR pA2) { return _mbsicmp((PCUSTR)pA1, (PCUSTR)pA2); } #else inline long sscmp(PCSTR pA1, PCSTR pA2) { return strcmp(pA1, pA2); } inline long ssicmp(PCSTR pA1, PCSTR pA2) { return _stricmp(pA1, pA2); } #endif inline long sscmp(PCWSTR pW1, PCWSTR pW2) { return wcscmp(pW1, pW2); } inline long ssicmp(PCWSTR pW1, PCWSTR pW2) { return _wcsicmp(pW1, pW2); } #endif

// ----------------------------------------------------------------------------- // ssupr/sslwr: Uppercase/Lowercase conversion functions // ----------------------------------------------------------------------------- #ifdef SS_ANSI template<typename CT> inline void sslwr(CT* pT, size_t nLen) { SS_USE_FACET(std::locale(), std::ctype<CT>).tolower(pT, pT+nLen); } template<typename CT> inline void ssupr(CT* pT, size_t nLen) { SS_USE_FACET(std::locale(), std::ctype<CT>).toupper(pT, pT+nLen); } #else // #else we must be on Win32 #ifdef _MBCS inline void ssupr(PSTR pA, size_t /*nLen*/) { _mbsupr((PUSTR)pA); } inline void sslwr(PSTR pA, size_t /*nLen*/) { _mbslwr((PUSTR)pA); } #else inline void ssupr(PSTR pA, size_t /*nLen*/) { _strupr(pA); } inline void sslwr(PSTR pA, size_t /*nLen*/) { _strlwr(pA); } #endif inline void ssupr(PWSTR pW, size_t /*nLen*/) { _wcsupr(pW); } inline void sslwr(PWSTR pW, size_t /*nLen*/) { _wcslwr(pW); } #endif // #ifdef SS_ANSI // ----------------------------------------------------------------------------- // vsprintf/vswprintf or _vsnprintf/_vsnwprintf equivalents. In standard // builds we can't use _vsnprintf/_vsnwsprintf because they're MS extensions. // ----------------------------------------------------------------------------- #ifdef SS_ANSI inline int ssvsprintf(PSTR pA, size_t /*nCount*/, PCSTR pFmtA, va_list vl) { return vsprintf(pA, pFmtA, vl); } inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { #ifdef __MWERKS__ return vswprintf(pW, nCount, pFmtW, vl); #else nCount; return vswprintf(pW, pFmtW, vl); #endif } inline int ssvsprintf(PWSTR pW, PCWSTR pFmtW, va_list vl) { return vswprintf(pW, pFmtW, vl); } #else inline int ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl) { return _vsnprintf(pA, nCount, pFmtA, vl); } inline int ssnprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { return _vsnwprintf(pW, nCount, pFmtW, vl); } #endif

// ----------------------------------------------------------------------------- // ssload: Type safe, overloaded ::LoadString wrappers // There is no equivalent of these in non-Win32-specific builds. However, I'm // thinking that with the message facet, there might eventually be one // ----------------------------------------------------------------------------- #ifdef SS_ANSI #else inline int ssload(HMODULE hInst, UINT uId, PSTR pBuf, int nMax) { return ::LoadStringA(hInst, uId, pBuf, nMax); } inline int ssload(HMODULE hInst, UINT uId, PWSTR pBuf, int nMax) { return ::LoadStringW(hInst, uId, pBuf, nMax); } #endif

// ----------------------------------------------------------------------------- // sscoll/ssicoll: Collation wrappers // ----------------------------------------------------------------------------- #ifdef SS_ANSI template <typename CT> inline int sscoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2) { const std::collate<CT>& coll = SS_USE_FACET(std::locale(), std::collate<CT>); return coll.compare(sz1, sz1+nLen1, sz2, sz2+nLen2); } template <typename CT> inline int ssicoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2) { const std::locale loc; const std::collate<CT>& coll = SS_USE_FACET(loc, std::collate<CT>);

std::collate<CT>::string_type s1(sz1); std::collate<CT>::string_type s2(sz2);

sslwr(const_cast<CT*>(s1.c_str()), nLen1); sslwr(const_cast<CT*>(s2.c_str()), nLen2); return coll.compare(s1.c_str(), s1.c_str()+nLen1, s2.c_str(), s2.c_str()+nLen2); } #else #ifdef _MBCS inline int sscoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/) { return _mbscoll((PCUSTR)sz1, (PCUSTR)sz2); } inline int ssicoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/) { return _mbsicoll((PCUSTR)sz1, (PCUSTR)sz2); } #else inline int sscoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/) { return strcoll(sz1, sz2); } inline int ssicoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/) { return _stricoll(sz1, sz2); } #endif inline int sscoll(PCWSTR sz1, int /*nLen1*/, PCWSTR sz2, int /*nLen2*/) { return wcscoll(sz1, sz2); } inline int ssicoll(PCWSTR sz1, int /*nLen1*/, PCWSTR sz2, int /*nLen2*/) { return _wcsicoll(sz1, sz2); } #endif

// ----------------------------------------------------------------------------- // ssfmtmsg: FormatMessage equivalents. Needed because I added a CString facade // Again -- no equivalent of these on non-Win32 builds but their might one day // be one if the message facet gets implemented // ----------------------------------------------------------------------------- #ifdef SS_ANSI #else inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PSTR pBuf, DWORD nSize, va_list* vlArgs) { return FormatMessageA(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PWSTR pBuf, DWORD nSize, va_list* vlArgs) { return FormatMessageW(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } #endif

// FUNCTION: sscpy. Copies up to 'nMax' characters from pSrc to pDst. // ----------------------------------------------------------------------------- // FUNCTION: sscpy // inline int sscpy(PSTR pDst, PCSTR pSrc, int nMax=-1); // inline int sscpy(PUSTR pDst, PCSTR pSrc, int nMax=-1) // inline int sscpy(PSTR pDst, PCWSTR pSrc, int nMax=-1); // inline int sscpy(PWSTR pDst, PCWSTR pSrc, int nMax=-1); // inline int sscpy(PWSTR pDst, PCSTR pSrc, int nMax=-1); // // DESCRIPTION: // This function is very much (but not exactly) like strcpy. These // overloads simplify copying one C-style string into another by allowing // the caller to specify two different types of strings if necessary. // // The strings must NOT overlap // // "Character" is expressed in terms of the destination string, not // the source. If no 'nMax' argument is supplied, then the number of // characters copied will be sslen(pSrc). A NULL terminator will // also be added so pDst must actually be big enough to hold nMax+1 // characters. The return value is the number of characters copied, // not including the NULL terminator. // // PARAMETERS: // pSrc - the string to be copied FROM. May be a char based string, an // MBCS string (in Win32 builds) or a wide string (wchar_t). // pSrc - the string to be copied TO. Also may be either MBCS or wide // nMax - the maximum number of characters to be copied into szDest. Note // that this is expressed in whatever a "character" means to pDst. // If pDst is a wchar_t type string than this will be the maximum // number of wchar_ts that my be copied. The pDst string must be // large enough to hold least nMaxChars+1 characters. // If the caller supplies no argument for nMax this is a signal to // the routine to copy all the characters in pSrc, regardless of // how long it is. // // RETURN VALUE: none // ----------------------------------------------------------------------------- template<typename CT1, typename CT2> inline int sscpycvt(CT1* pDst, const CT2* pSrc, int nChars) { StdCodeCvt(pDst, pSrc, nChars); pDst[SSMAX(nChars, 0)] = '\0'; return nChars; }

template<typename CT1, typename CT2> inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax, int nLen) { return sscpycvt(pDst, pSrc, SSMIN(nMax, nLen)); } template<typename CT1, typename CT2> inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax) { return sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc))); } template<typename CT1, typename CT2> inline int sscpy(CT1* pDst, const CT2* pSrc) { return sscpycvt(pDst, pSrc, sslen(pSrc)); } template<typename CT1, typename CT2> inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc, int nMax) { return sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (int)sSrc.length())); } template<typename CT1, typename CT2> inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc) { return sscpycvt(pDst, sSrc.c_str(), (int)sSrc.length()); }





// ----------------------------------------------------------------------------- // Functional objects for changing case. They also let you pass locales // ----------------------------------------------------------------------------- #ifdef SS_ANSI template<typename CT> struct SSToUpper : public std::binary_function<CT, std::locale, CT> { inline CT operator()(const CT& t, const std::locale& loc) const { return std::toupper<CT>(t, loc); } }; template<typename CT> struct SSToLower : public std::binary_function<CT, std::locale, CT> { inline CT operator()(const CT& t, const std::locale& loc) const { return std::tolower<CT>(t, loc); } }; #endif

// struct SSSHDR - useful for non Std C++ persistence schemes. typedef struct SSSHDR { BYTE byCtrl; ULONG nChars; } SSSHDR; // as in "Standard String Stream Header" // This struct is used for TrimRight() and TrimLeft() function implementations. //template<typename CT> //struct NotSpace : public std::unary_function<CT, bool> //{ // const std::locale& loc; // inline NotSpace(const std::locale& locArg) : loc(locArg) {} // inline bool operator() (CT t) { return !std::isspace(t, loc); } //}; template<typename CT> struct NotSpace : public std::unary_function<CT, bool> { const std::locale& loc; NotSpace(const std::locale& locArg) : loc(locArg) {}

// DINKUMWARE BUG: // Note -- using std::isspace in a COM DLL gives us access violations // because it causes the dynamic addition of a function to be called // when the library shuts down. Unfortunately the list is maintained // in DLL memory but the function is in static memory. So the COM DLL // goes away along with the function that was supposed to be called, // and then later when the DLL CRT shuts down it unloads the list and // tries to call the long-gone function. // This is DinkumWare's implementation problem. Until then, we will // use good old isspace and iswspace from the CRT unless they // specify SS_ANSI #ifdef SS_ANSI bool operator() const (CT t) { return !std::isspace(t, loc); } #else bool ssisp(char c) const { return FALSE != ::isspace((int) c); } bool ssisp(wchar_t c) const { return FALSE != ::iswspace((wint_t) c); } bool operator()(CT t) const { return !ssisp(t); } #endif };



// Now we can define the template (finally!) // ============================================================================= // TEMPLATE: CStdStr // template<typename CT> class CStdStr : public std::basic_string<CT> // // REMARKS: // This template derives from basic_string<CT> and adds some MFC CString- // like functionality // // Basically, this is my attempt to make Standard C++ library strings as // easy to use as the MFC CString class. // // Note that although this is a template, it makes the assumption that the // template argument (CT, the character type) is either char or wchar_t. // ============================================================================= //#define CStdStr _SS // avoid compiler warning 4786

template<typename CT> class CStdStr : public std::basic_string<CT> { // Typedefs for shorter names. Using these names also appears to help // us avoid some ambiguities that otherwise arise on some platforms typedef typename std::basic_string<CT> MYBASE; // my base class typedef CStdStr<CT> MYTYPE; // myself typedef typename MYBASE::const_pointer PCMYSTR; // PCSTR or PCWSTR typedef typename MYBASE::pointer PMYSTR; // PSTR or PWSTR typedef typename MYBASE::iterator MYITER; // my iterator type typedef typename MYBASE::const_iterator MYCITER; // you get the idea... typedef typename MYBASE::size_type MYSIZE; typedef typename MYBASE::value_type MYVAL; typedef typename MYBASE::allocator_type MYALLOC;

public:

// shorthand conversion from PCTSTR to string resource ID #define _TRES(pctstr) (LOWORD((DWORD)(pctstr)))

// CStdStr inline constructors CStdStr() { }

CStdStr(const MYTYPE& str) : MYBASE(SSREF(str)) { }

CStdStr(const std::string& str) { ssasn(*this, SSREF(str)); }

CStdStr(const std::wstring& str) { ssasn(*this, SSREF(str)); }

CStdStr(PCMYSTR pT, MYSIZE n) : MYBASE(pT, n) { }

CStdStr(PCSTR pA) { #ifdef SS_ANSI *this = pA; #else if ( NULL != HIWORD(pA) ) *this = pA; else if ( NULL != pA && !Load(_TRES(pA)) ) TRACE(_T("Can't load string %u\n"), _TRES(pA)); #endif }

CStdStr(PCWSTR pW) { #ifdef SS_ANSI *this = pW; #else if ( NULL != HIWORD(pW) ) *this = pW; else if ( NULL != pW && !Load(_TRES(pW)) ) TRACE(_T("Can't load string %u\n"), _TRES(pW)); #endif }

CStdStr(MYCITER first, MYCITER last) : MYBASE(first, last) { }

CStdStr(MYSIZE nSize, MYVAL ch, const MYALLOC& al=MYALLOC()) : MYBASE(nSize, ch, al) { }

#ifdef SS_INC_COMDEF CStdStr(const _bstr_t& bstr) { *this = static_cast<PCTSTR>(bstr); } #endif

// CStdStr inline assignment operators -- the ssasn function now takes care // of fixing the MSVC assignment bug (see knowledge base article Q172398). MYTYPE& operator=(const MYTYPE& str) { ssasn(*this, str); return *this; }

MYTYPE& operator=(const std::string& str) { ssasn(*this, str); return *this; }

MYTYPE& operator=(const std::wstring& str) { ssasn(*this, str); return *this; }

MYTYPE& operator=(PCSTR pA) { ssasn(*this, pA); return *this; }

MYTYPE& operator=(PCWSTR pW) { ssasn(*this, pW); return *this; }

MYTYPE& operator=(CT t) { Q172398(*this); MYBASE::assign(1, t); return *this; }

#ifdef SS_INC_COMDEF MYTYPE& operator=(const _bstr_t& bstr) { return operator=(static_cast<const CT*>(bstr)); } #endif

// Overloads also needed to fix the MSVC assignment bug (KB: Q172398) // *** Thanks to Pete The Plumber for catching this one *** // They also are compiled if you have explicitly turned off refcounting #if ( defined(_MSC_VER) && ( _MSC_VER < 1200 ) ) || defined(SS_NO_REFCOUNT)

MYTYPE& assign(const MYTYPE& str) { ssasn(*this, str); return *this; }

MYTYPE& assign(const MYTYPE& str, MYSIZE nStart, MYSIZE nChars) { // This overload of basic_string::assign is supposed to assign up to // <nChars> or the NULL terminator, whichever comes first. Since we // are about to call a less forgiving overload (in which <nChars> // must be a valid length), we must adjust the length here to a safe // value. Thanks to Ullrich Pollähne for catching this bug nChars = SSMIN(nChars, str.length() - nStart);

// Watch out for assignment to self if ( this == &str ) { MYTYPE strTemp(str.c_str()+nStart, nChars); assign(strTemp); } else { Q172398(*this); MYBASE::assign(str.c_str()+nStart, nChars); } return *this; }

MYTYPE& assign(const MYBASE& str) { ssasn(*this, str); return *this; }

MYTYPE& assign(const MYBASE& str, MYSIZE nStart, MYSIZE nChars) { // This overload of basic_string::assign is supposed to assign up to // <nChars> or the NULL terminator, whichever comes first. Since we // are about to call a less forgiving overload (in which <nChars> // must be a valid length), we must adjust the length here to a safe // value. Thanks to Ullrich Pollähne for catching this bug nChars = SSMIN(nChars, str.length() - nStart);

// Watch out for assignment to self if ( this == &str ) // watch out for assignment to self { MYTYPE strTemp(str.c_str() + nStart, nChars); assign(strTemp); } else { Q172398(*this); MYBASE::assign(str.c_str()+nStart, nChars); } return *this; }

MYTYPE& assign(const CT* pC, MYSIZE nChars) { // Q172398 only fix -- erase before assigning, but not if we're // assigning from our own buffer #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) if ( !empty() && ( pC < data() || pC > data() + capacity() ) ) erase(); #endif Q172398(*this); MYBASE::assign(pC, nChars); return *this; }

MYTYPE& assign(MYSIZE nChars, MYVAL val) { Q172398(*this); MYBASE::assign(nChars, val); return *this; }

MYTYPE& assign(const CT* pT) { return assign(pT, CStdStr::traits_type::length(pT)); }

MYTYPE& assign(MYCITER iterFirst, MYCITER iterLast) { #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) // Q172398 fix. don't call erase() if we're assigning from ourself if ( iterFirst < begin() || iterFirst > begin() + size() ) erase() #endif replace(begin(), end(), iterFirst, iterLast); return *this; } #endif

// ------------------------------------------------------------------------- // CStdStr inline concatenation. // ------------------------------------------------------------------------- MYTYPE& operator+=(const MYTYPE& str) { ssadd(*this, str); return *this; }

MYTYPE& operator+=(const std::string& str) { ssadd(*this, str); return *this; }

MYTYPE& operator+=(const std::wstring& str) { ssadd(*this, str); return *this; }

MYTYPE& operator+=(PCSTR pA) { ssadd(*this, pA); return *this; }

MYTYPE& operator+=(PCWSTR pW) { ssadd(*this, pW); return *this; }

MYTYPE& operator+=(CT t) { append(1, t); return *this; } #ifdef SS_INC_COMDEF // if we have _bstr_t, define a += for it too. MYTYPE& operator+=(const _bstr_t& bstr) { return operator+=(static_cast<PCMYSTR>(bstr)); } #endif

// addition operators -- global friend functions. friend MYTYPE operator+(const MYTYPE& str1, const MYTYPE& str2); friend MYTYPE operator+(const MYTYPE& str, CT t); friend MYTYPE operator+(const MYTYPE& str, PCSTR sz); friend MYTYPE operator+(const MYTYPE& str, PCWSTR sz); friend MYTYPE operator+(PCSTR pA, const MYTYPE& str); friend MYTYPE operator+(PCWSTR pW, const MYTYPE& str); #ifdef SS_INC_COMDEF friend MYTYPE operator+(const _bstr_t& bstr, const MYTYPE& str); friend MYTYPE operator+(const MYTYPE& str, const _bstr_t& bstr); #endif

// ------------------------------------------------------------------------- // Case changing functions // ------------------------------------------------------------------------- // ------------------------------------------------------------------------- MYTYPE& ToUpper() { // Strictly speaking, this would be about the most portable way // std::transform(begin(), // end(), // begin(), // std::bind2nd(SSToUpper<CT>(), std::locale())); // But practically speaking, this works faster if ( !empty() ) ssupr(GetBuf(), size());

return *this; }



MYTYPE& ToLower() { // Strictly speaking, this would be about the most portable way // std::transform(begin(), // end(), // begin(), // std::bind2nd(SSToLower<CT>(), std::locale())); // But practically speaking, this works faster if ( !empty() ) sslwr(GetBuf(), size());

return *this; }



MYTYPE& Normalize() { return Trim().ToLower(); }

// ------------------------------------------------------------------------- // CStdStr -- Direct access to character buffer. In the MS' implementation, // the at() function that we use here also calls _Freeze() providing us some // protection from multithreading problems associated with ref-counting. // ------------------------------------------------------------------------- CT* GetBuf(int nMinLen=-1) { if ( static_cast<int>(size()) < nMinLen ) resize(static_cast<MYSIZE>(nMinLen));

return empty() ? const_cast<CT*>(data()) : &(at(0)); }

CT* SetBuf(int nLen) { nLen = ( nLen > 0 ? nLen : 0 ); if ( capacity() < 1 && nLen == 0 ) resize(1);

resize(static_cast<MYSIZE>(nLen)); return const_cast<CT*>(data()); } void RelBuf(int nNewLen=-1) { resize(static_cast<MYSIZE>(nNewLen > -1 ? nNewLen : sslen(c_str()))); }

void BufferRel() { RelBuf(); } // backwards compatability CT* Buffer() { return GetBuf(); } // backwards compatability CT* BufferSet(int nLen) { return SetBuf(nLen);}// backwards compatability bool Equals(const CT* pT, bool bUseCase=false) const { // get copy, THEN compare (thread safe) return bUseCase ? compare(pT) == 0 : ssicmp(MYTYPE(*this), pT) == 0; }

// ------------------------------------------------------------------------- // FUNCTION: CStdStr::Load // REMARKS: // Loads string from resource specified by nID // // PARAMETERS: // nID - resource Identifier. Purely a Win32 thing in this case // // RETURN VALUE: // true if successful, false otherwise // ------------------------------------------------------------------------- #ifndef SS_ANSI bool Load(UINT nId, HMODULE hModule=NULL) { bool bLoaded = false; // set to true of we succeed. #ifdef _MFC_VER // When in Rome... CString strRes; bLoaded = FALSE != strRes.LoadString(nId); if ( bLoaded ) *this = strRes;

#else // Get the resource name and module handle if ( NULL == hModule ) hModule = GetResourceHandle();

PCTSTR szName = MAKEINTRESOURCE((nId>>4)+1); // lifted DWORD dwSize = 0;

// No sense continuing if we can't find the resource HRSRC hrsrc = ::FindResource(hModule, szName, RT_STRING);

if ( NULL == hrsrc ) TRACE(_T("Cannot find resource %d: 0x%X"), nId, ::GetLastError()); else if ( 0 == (dwSize = ::SizeofResource(hModule, hrsrc) / sizeof(CT))) TRACE(_T("Cant get size of resource %d 0x%X\n"),nId,GetLastError()); else { bLoaded = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize); ReleaseBuffer(); }

#endif

if ( !bLoaded ) TRACE(_T("String not loaded 0x%X\n"), ::GetLastError());

return bLoaded; } #endif // ------------------------------------------------------------------------- // FUNCTION: CStdStr::Format // void _cdecl Formst(CStdStringA& PCSTR szFormat, ...) // void _cdecl Format(PCSTR szFormat); // // DESCRIPTION: // This function does sprintf/wsprintf style formatting on CStdStringA // objects. It looks a lot like MFC's CString::Format. Some people // might even call this identical. Fortunately, these people are now // dead. // // PARAMETERS: // nId - ID of string resource holding the format string // szFormat - a PCSTR holding the format specifiers // argList - a va_list holding the arguments for the format specifiers. // // RETURN VALUE: None. // ------------------------------------------------------------------------- // formatting (using wsprintf style formatting) #ifndef SS_ANSI void Format(UINT nId, ...) { va_list argList; va_start(argList, nId); va_start(argList, nId);

MYTYPE strFmt; if ( strFmt.Load(nId) ) FormatV(strFmt, argList);

va_end(argList); } #endif void Format(const CT* szFmt, ...) { va_list argList; va_start(argList, szFmt); FormatV(szFmt, argList); va_end(argList); } void AppendFormat(const CT* szFmt, ...) { va_list argList; va_start(argList, szFmt); AppendFormatV(szFmt, argList); va_end(argList); }

#define MAX_FMT_TRIES 5 // #of times we try #define FMT_BLOCK_SIZE 2048 // # of bytes to increment per try #define BUFSIZE_1ST 256 #define BUFSIZE_2ND 512 #define STD_BUF_SIZE 1024

// an efficient way to add formatted characters to the string. You may only // add up to STD_BUF_SIZE characters at a time, though void AppendFormatV(const CT* szFmt, va_list argList) { CT szBuf[STD_BUF_SIZE]; #ifdef SS_ANSI int nLen = ssvsprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList); #else int nLen = ssnprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList); #endif if ( 0 < nLen ) append(szBuf, nLen); }

// ------------------------------------------------------------------------- // FUNCTION: FormatV // void FormatV(PCSTR szFormat, va_list, argList); // // DESCRIPTION: // This function formats the string with sprintf style format-specs. // It makes a general guess at required buffer size and then tries // successively larger buffers until it finds one big enough or a // threshold (MAX_FMT_TRIES) is exceeded. // // PARAMETERS: // szFormat - a PCSTR holding the format of the output // argList - a Microsoft specific va_list for variable argument lists // // RETURN VALUE: // ------------------------------------------------------------------------- void FormatV(const CT* szFormat, va_list argList) { #ifdef SS_ANSI

int nLen = sslen(szFormat) + STD_BUF_SIZE; ssvsprintf(GetBuffer(nLen), nLen-1, szFormat, argList); ReleaseBuffer();

#else

CT* pBuf = NULL; int nChars = 1; int nUsed = 0; size_type nActual = 0; int nTry = 0;

do { // Grow more than linearly (e.g. 512, 1536, 3072, etc) nChars += (nTry+1 * FMT_BLOCK_SIZE); pBuf = reinterpret_cast<CT*>(_alloca(sizeof(CT)*nChars)); nUsed = ssnprintf(pBuf, nChars-1, szFormat, argList);

// Ensure proper NULL termination. nActual = nUsed == -1 ? nChars-1 : SSMIN(nUsed, nChars-1); pBuf[nActual+1]= '\0';

} while ( nUsed < 0 && nTry++ < MAX_FMT_TRIES );

// assign whatever we managed to format assign(pBuf, nActual);

#endif }

// ------------------------------------------------------------------------- // CString Facade Functions: // // The following methods are intended to allow you to use this class as a // drop-in replacement for CString. // ------------------------------------------------------------------------- #ifndef SS_ANSI BSTR AllocSysString() const { ostring os; ssasn(os, *this); return ::SysAllocString(os.c_str()); } #endif

int Collate(PCMYSTR szThat) const { return sscoll(c_str(), length(), szThat, sslen(szThat)); }

int CollateNoCase(PCMYSTR szThat) const { return ssicoll(c_str(), length(), szThat, sslen(szThat)); }

int CompareNoCase(PCMYSTR szThat) const { return ssicmp(c_str(), szThat); }

int Delete(int nIdx, int nCount=1) { if ( nIdx < GetLength() ) erase(static_cast<MYSIZE>(nIdx), static_cast<MYSIZE>(nCount));

return GetLength(); }

void Empty() { erase(); }

int Find(CT ch) const { MYSIZE nIdx = find_first_of(ch); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

int Find(PCMYSTR szSub) const { MYSIZE nIdx = find(szSub); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

int Find(CT ch, int nStart) const { // CString::Find docs say add 1 to nStart when it's not zero // CString::Find code doesn't do that however. We'll stick // with what the code does MYSIZE nIdx = find_first_of(ch, static_cast<MYSIZE>(nStart)); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

int Find(PCMYSTR szSub, int nStart) const { // CString::Find docs say add 1 to nStart when it's not zero // CString::Find code doesn't do that however. We'll stick // with what the code does MYSIZE nIdx = find(szSub, static_cast<MYSIZE>(nStart)); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

int FindOneOf(PCMYSTR szCharSet) const { MYSIZE nIdx = find_first_of(szCharSet); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

#ifndef SS_ANSI void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception) { va_list argList; va_start(argList, szFormat); PMYSTR szTemp; if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, szFormat, 0, 0, reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 || szTemp == NULL ) { throw std::runtime_error("out of memory"); } *this = szTemp; LocalFree(szTemp); va_end(argList); }

void FormatMessage(UINT nFormatId, ...) throw(std::exception) { MYTYPE sFormat; VERIFY(sFormat.LoadString(nFormatId) != 0); va_list argList; va_start(argList, nFormatId); PMYSTR szTemp; if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, sFormat, 0, 0, reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 || szTemp == NULL) { throw std::runtime_error("out of memory"); } *this = szTemp; LocalFree(szTemp); va_end(argList); } #endif

// ------------------------------------------------------------------------- // GetXXXX -- Direct access to character buffer // ------------------------------------------------------------------------- CT GetAt(int nIdx) const { return at(static_cast<MYSIZE>(nIdx)); }

CT* GetBuffer(int nMinLen=-1) { return GetBuf(nMinLen); }

CT* GetBufferSetLength(int nLen) { return BufferSet(nLen); }

// GetLength() -- MFC docs say this is the # of BYTES but // in truth it is the number of CHARACTERs (chars or wchar_ts) int GetLength() const { return static_cast<int>(length()); }

int Insert(int nIdx, CT ch) { if ( static_cast<MYSIZE>(nIdx) > size() -1 ) append(1, ch); else insert(static_cast<MYSIZE>(nIdx), 1, ch);

return GetLength(); }

int Insert(int nIdx, PCMYSTR sz) { insert(static_cast<MYSIZE>(nIdx), sz); return GetLength(); }

bool IsEmpty() const { return empty(); }

MYTYPE Left(int nCount) const { return substr(0, static_cast<MYSIZE>(nCount)); }

#ifndef SS_ANSI bool LoadString(UINT nId) { return this->Load(nId); } #endif

void MakeLower() { ToLower(); }

void MakeReverse() { std::reverse(begin(), end()); }

void MakeUpper() { ToUpper(); }

MYTYPE Mid(int nFirst ) const { return substr(static_cast<MYSIZE>(nFirst)); }

MYTYPE Mid(int nFirst, int nCount) const { return substr(static_cast<MYSIZE>(nFirst), static_cast<MYSIZE>(nCount)); }

void ReleaseBuffer(int nNewLen=-1) { RelBuf(nNewLen); }

int Remove(CT ch) { MYSIZE nIdx = 0; int nRemoved = 0; while ( (nIdx=find_first_of(ch)) != npos ) { erase(nIdx, 1); nRemoved++; } return nRemoved; }

int Replace(CT chOld, CT chNew) { int nReplaced = 0; for ( MYITER iter=begin(); iter != end(); iter++ ) { if ( *iter == chOld ) { *iter = chNew; nReplaced++; } } return nReplaced; }

int Replace(PCMYSTR szOld, PCMYSTR szNew) { int nReplaced = 0; MYSIZE nIdx = 0; static const CT _C = CT(0); MYSIZE nOldLen = sslen(szOld); MYSIZE nNewLen = sslen(szNew); PCMYSTR szRealNew = szNew == NULL ? &_C : szNew; PCMYSTR szRealOld = szOld == NULL ? &_C : szOld; while ( (nIdx=find(szRealOld, nIdx)) != npos ) { replace(begin()+nIdx, begin()+nIdx+nOldLen, szRealNew); nReplaced++; nIdx += nNewLen; } return nReplaced; }

int ReverseFind(CT ch) const { MYSIZE nIdx = find_last_of(ch); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

// ReverseFind overload that's not in CString but might be useful int ReverseFind(PCMYSTR szFind, size_type pos=npos) const { MYSIZE nIdx = rfind(NULL == szFind ? MYTYPE() : szFind, pos); return static_cast<int>(nIdx == npos ? -1 : nIdx); }

MYTYPE Right(int nCount) const { nCount = SSMIN(nCount, static_cast<int>(size())); return substr(size()-static_cast<MYSIZE>(nCount)); }

void SetAt(int nIndex, CT ch) { ASSERT(size() > static_cast<MYSIZE>(nIndex)); at(static_cast<MYSIZE>(nIndex)) = ch; }

#ifndef SS_ANSI BSTR SetSysString(BSTR* pbstr) const { ostring os; ssasn(os, *this); if ( !::SysReAllocStringLen(pbstr, os.c_str(), os.length()) ) throw std::runtime_error("out of memory");

ASSERT(*pbstr != NULL); return *pbstr; } #endif

MYTYPE SpanExcluding(PCMYSTR szCharSet) const { return Left(find_first_of(szCharSet)); }

MYTYPE SpanIncluding(PCMYSTR szCharSet) const { return Left(find_first_not_of(szCharSet)); }

#if !defined(UNICODE) && !defined(SS_ANSI)

// CString's OemToAnsi and AnsiToOem functions are available only in // Unicode builds. However since we're a template we also need a // runtime check of CT and a reinterpret_cast to account for the fact // that CStdStringW gets instantiated even in non-Unicode builds. void AnsiToOem() { if ( sizeof(CT) == sizeof(char) && !empty() ) { ::CharToOem(reinterpret_cast<PCSTR>(c_str()), reinterpret_cast<PSTR>(GetBuf())); } else { ASSERT(false); } }

void OemToAnsi() { if ( sizeof(CT) == sizeof(char) && !empty() ) { ::OemToChar(reinterpret_cast<PCSTR>(c_str()), reinterpret_cast<PSTR>(GetBuf())); } else { ASSERT(false); } }

#endif

// ------------------------------------------------------------------------- // Trim and its variants // ------------------------------------------------------------------------- MYTYPE& Trim() { return TrimLeft().TrimRight(); }

MYTYPE& TrimLeft() { erase(begin(), std::find_if(begin(),end(),NotSpace<CT>(std::locale()))); return *this; }

MYTYPE& TrimLeft(CT tTrim) { erase(0, find_first_not_of(tTrim)); return *this; }

MYTYPE& TrimLeft(PCMYSTR szTrimChars) { erase(0, find_first_not_of(szTrimChars)); return *this; }

MYTYPE& TrimRight() { std::locale loc; reverse_iterator it = std::find_if(rbegin(), rend(), NotSpace<CT>(loc)); if ( rend() != it ) erase(rend() - it);

erase(it != rend() ? find_last_of(*it) + 1 : 0); return *this; }

MYTYPE& TrimRight(CT tTrim) { MYSIZE nIdx = find_last_not_of(tTrim); erase(npos == nIdx ? 0 : ++nIdx); return *this; }

MYTYPE& TrimRight(PCMYSTR szTrimChars) { MYSIZE nIdx = find_last_not_of(szTrimChars); erase(npos == nIdx ? 0 : ++nIdx); return *this; }

void FreeExtra() { MYTYPE mt; swap(mt); if ( !mt.empty() ) assign(mt.c_str(), mt.size()); }

// I have intentionally not implemented the following CString // functions. You cannot make them work without taking advantage // of implementation specific behavior. However if you absolutely // MUST have them, uncomment out these lines for "sort-of-like" // their behavior. You're on your own. // CT* LockBuffer() { return GetBuf(); }// won't really lock // void UnlockBuffer(); { } // why have UnlockBuffer w/o LockBuffer? // Array-indexing operators. Required because we defined an implicit cast // to operator const CT* (Thanks to Julian Selman for pointing this out) CT& operator[](int nIdx) { return MYBASE::operator[](static_cast<MYSIZE>(nIdx)); }

const CT& operator[](int nIdx) const { return MYBASE::operator[](static_cast<MYSIZE>(nIdx)); }

CT& operator[](unsigned int nIdx) { return MYBASE::operator[](static_cast<MYSIZE>(nIdx)); }

const CT& operator[](unsigned int nIdx) const { return MYBASE::operator[](static_cast<MYSIZE>(nIdx)); }

operator const CT*() const { return c_str(); }

// IStream related functions. Useful in IPersistStream implementations #ifdef SS_INC_COMDEF

#define SSSO_UNICODE 0x01 // the string is a wide string #define SSSO_COMPRESS 0x02 // the string is compressed // ------------------------------------------------------------------------- // FUNCTION: StreamSize // REMARKS: // Returns how many bytes it will take to StreamSave() this CStdString // object to an IStream. // ------------------------------------------------------------------------- ULONG StreamSize() const { // Control header plus string ASSERT(size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR)); return (size() * sizeof(CT)) + sizeof(SSSHDR); }

// ------------------------------------------------------------------------- // FUNCTION: StreamSave // REMARKS: // Saves this CStdString object to a COM IStream. // ------------------------------------------------------------------------- HRESULT StreamSave(IStream* pStream) const { ASSERT(size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR)); HRESULT hr = E_FAIL; ASSERT(pStream != NULL); SSSHDR hdr; hdr.byCtrl = sizeof(CT) == 2 ? SSSO_UNICODE : 0; hdr.nChars = size();

if ( FAILED(hr=pStream->Write(&hdr, sizeof(SSSHDR), NULL)) ) TRACE(_T("StreamSave: Cannot write control header, ERR=0x%X\n"),hr); else if ( empty() ) ; // nothing to write else if ( FAILED(hr=pStream->Write(c_str(), size()*sizeof(CT), NULL)) ) TRACE(_T("StreamSave: Cannot write string to stream 0x%X\n"), hr);

return hr; }

// ------------------------------------------------------------------------- // FUNCTION: StreamLoad // REMARKS: // This method loads the object from an IStream. // ------------------------------------------------------------------------- HRESULT StreamLoad(IStream* pStream) { ASSERT(pStream != NULL); SSSHDR hdr; HRESULT hr = E_FAIL;

if ( FAILED(hr=pStream->Read(&hdr, sizeof(SSSHDR), NULL)) ) { TRACE(_T("StreamLoad: Cant read control header, ERR=0x%X\n"), hr); } else if ( hdr.nChars > 0 ) { ULONG nRead = 0; PMYSTR pMyBuf = BufferSet(hdr.nChars);

// If our character size matches the character size of the string // we're trying to read, then we can read it directly into our // buffer. Otherwise, we have to read into an intermediate buffer // and convert. if ( (hdr.byCtrl & SSSO_UNICODE) != 0 ) { ULONG nBytes = hdr.nChars * sizeof(wchar_t); if ( sizeof(CT) == sizeof(wchar_t) ) { if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); } else { PWSTR pBufW = reinterpret_cast<PWSTR>(_alloca((nBytes)+1)); if ( FAILED(hr=pStream->Read(pBufW, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); else sscpy(pMyBuf, pBufW, hdr.nChars*sizeof(wchar_t)); } } else { ULONG nBytes = hdr.nChars * sizeof(char); if ( sizeof(CT) == sizeof(char) ) { if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); } else { PSTR pBufA = reinterpret_cast<PSTR>(_alloca(nBytes)); if ( FAILED(hr=pStream->Read(pBufA, hdr.nChars, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); else sscpy(pMyBuf, pBufA, hdr.nChars); } } } else { this->erase(); } return hr; } #endif // #ifdef SS_INC_COMDEF // SetResourceHandle/GetResourceHandle. In MFC builds, these map directly // to AfxSetResourceHandle and AfxGetResourceHandle. In non-MFC builds they // point to a single static HINST so that those who call the member // functions that take resource IDs can provide an alternate HINST of a DLL // to search. This is not exactly the list of HMODULES that MFC provides // but it's better than nothing. #ifdef _MFC_VER static void SetResourceHandle(HMODULE hNew) { AfxSetResourceHandle(hNew); } static HMODULE GetResourceHandle() { return AfxGetResourceHandle(); } #else static void SetResourceHandle(HMODULE hNew) { SSResourceHandle() = hNew; } static HMODULE GetResourceHandle() { return SSResourceHandle(); } #endif };



// ----------------------------------------------------------------------------- // CStdStr friend addition functions defined as inline // ----------------------------------------------------------------------------- template<typename CT> inline CStdStr<CT> operator+(const CStdStr<CT>& str1, const CStdStr<CT>& str2) { CStdStr<CT> strRet(SSREF(str1)); strRet.append(str2); return strRet; }

template<typename CT> inline CStdStr<CT> operator+(const CStdStr<CT>& str, CT t) { // this particular overload is needed for disabling reference counting // though it's only an issue from line 1 to line 2 CStdStr<CT> strRet(SSREF(str)); // 1 strRet.append(1, t); // 2 return strRet; }

template<typename CT> inline CStdStr<CT> operator+(const CStdStr<CT>& str, PCSTR pA) { return CStdStr<CT>(str) + CStdStr<CT>(pA); }

template<typename CT> inline CStdStr<CT> operator+(PCSTR pA, const CStdStr<CT>& str) { CStdStr<CT> strRet(pA); strRet.append(str); return strRet; }

template<typename CT> inline CStdStr<CT> operator+(const CStdStr<CT>& str, PCWSTR pW) { return CStdStr<CT>(SSREF(str)) + CStdStr<CT>(pW); }

template<typename CT> inline CStdStr<CT> operator+(PCWSTR pW, const CStdStr<CT>& str) { CStdStr<CT> strRet(pW); strRet.append(str); return strRet; }

#ifdef SS_INC_COMDEF template<typename CT> inline CStdStr<CT> operator+(const _bstr_t& bstr, const CStdStr<CT>& str) { return static_cast<const CT*>(bstr) + str; }

template<typename CT> inline CStdStr<CT> operator+(const CStdStr<CT>& str, const _bstr_t& bstr) { return str + static_cast<const CT*>(bstr); } #endif

// ============================================================================= // END OF CStdStr INLINE FUNCTION DEFINITIONS // ============================================================================= // Now typedef our class names based upon this humongous template typedef CStdStr<char> CStdStringA; // a better std::string typedef CStdStr<wchar_t> CStdStringW; // a better std::wstring typedef CStdStr<OLECHAR> CStdStringO; // almost always CStdStringW // SSResourceHandle: our MFC-like resource handle inline HMODULE& SSResourceHandle() { static HMODULE hModuleSS = GetModuleHandle(NULL); return hModuleSS; }

// In MFC builds, define some global serialization operators // Special operators that allow us to serialize CStdStrings to CArchives. // Note that we use an intermediate CString object in order to ensure that // we use the exact same format. #ifdef _MFC_VER inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringA& strA) { CString strTemp = strA; return ar << strTemp; } inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringW& strW) { CString strTemp = strW; return ar << strTemp; }

inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringA& strA) { CString strTemp; ar >> strTemp; strA = strTemp; return ar; } inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringW& strW) { CString strTemp; ar >> strTemp; strW = strTemp; return ar; } #endif // #ifdef _MFC_VER -- (i.e. is this MFC?) // WUSysMessage -- return the system string corresponding to a system error or // HRESULT value. #define SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT)

// ----------------------------------------------------------------------------- // HOW TO EXPORT CSTDSTRING FROM A DLL // // If you want to export CStdStringA and CStdStringW from a DLL, then all you // need to // 1. make sure that all components link to the same DLL version // of the CRT (not the static one). // 2. Uncomment the 3 lines of code below // 3. #define 2 macros per the instructions in MS KnowledgeBase // article Q168958. The macros are: // // MACRO DEFINTION WHEN EXPORTING DEFINITION WHEN IMPORTING // ----- ------------------------ ------------------------- // SSDLLEXP (nothing, just #define it) extern // SSDLLSPEC __declspec(dllexport) __declspec(dllimport) // // Note that these macros must be available to ALL clients who want to // link to the DLL and use the class. If they // ----------------------------------------------------------------------------- //#pragma warning(disable:4231) // non-standard extension ("extern template") // SSDLLEXP template class SSDLLSPEC CStdStr<char>; // SSDLLEXP template class SSDLLSPEC CStdStr<wchar_t>;

// ----------------------------------------------------------------------------- // GLOBAL FUNCTION: WUFormat // CStdStringA WUFormat(UINT nId, ...); // CStdStringA WUFormat(PCSTR szFormat, ...); // // REMARKS: // This function allows the caller for format and return a CStdStringA // object with a single line of code. // ----------------------------------------------------------------------------- #ifdef SS_ANSI #else inline CStdStringA WUFormatA(UINT nId, ...) { va_list argList; va_start(argList, nId);

CStdStringA strFmt; CStdStringA strOut; if ( strFmt.Load(nId) ) strOut.FormatV(strFmt, argList);

va_end(argList); return strOut; } inline CStdStringA WUFormatA(PCSTR szFormat, ...) { va_list argList; va_start(argList, szFormat); CStdStringA strOut; strOut.FormatV(szFormat, argList); va_end(argList); return strOut; }

inline CStdStringW WUFormatW(UINT nId, ...) { va_list argList; va_start(argList, nId);

CStdStringW strFmt; CStdStringW strOut; if ( strFmt.Load(nId) ) strOut.FormatV(strFmt, argList);

va_end(argList); return strOut; } inline CStdStringW WUFormatW(PCWSTR szwFormat, ...) { va_list argList; va_start(argList, szwFormat); CStdStringW strOut; strOut.FormatV(szwFormat, argList); va_end(argList); return strOut; } #endif // #ifdef SS_ANSI #ifdef SS_ANSI #else // ------------------------------------------------------------------------- // FUNCTION: WUSysMessage // CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID); // CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID); // // DESCRIPTION: // This function simplifies the process of obtaining a string equivalent // of a system error code returned from GetLastError(). You simply // supply the value returned by GetLastError() to this function and the // corresponding system string is returned in the form of a CStdStringA. // // PARAMETERS: // dwError - a DWORD value representing the error code to be translated // dwLangId - the language id to use. defaults to english. // // RETURN VALUE: // a CStdStringA equivalent of the error code. Currently, this function // only returns either English of the system default language strings. // ------------------------------------------------------------------------- #define SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT) inline CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID) { CHAR szBuf[512];

if ( 0 != ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, dwLangId, szBuf, 511, NULL) ) return WUFormatA("%s (0x%X)", szBuf, dwError); else return WUFormatA("Unknown error (0x%X)", dwError); } inline CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID) { WCHAR szBuf[512];

if ( 0 != ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, dwLangId, szBuf, 511, NULL) ) return WUFormatW(L"%s (0x%X)", szBuf, dwError); else return WUFormatW(L"Unknown error (0x%X)", dwError); } #endif

// Define TCHAR based friendly names for some of these functions #ifdef UNICODE #define CStdString CStdStringW #define WUSysMessage WUSysMessageW #define WUFormat WUFormatW #else #define CStdString CStdStringA #define WUSysMessage WUSysMessageA #define WUFormat WUFormatA #endif

// ...and some shorter names for the space-efficient #define WUSysMsg WUSysMessage #define WUSysMsgA WUSysMessageA #define WUSysMsgW WUSysMessageW #define WUFmtA WUFormatA #define WUFmtW WUFormatW #define WUFmt WUFormat #define WULastErrMsg() WUSysMessage(::GetLastError()) #define WULastErrMsgA() WUSysMessageA(::GetLastError()) #define WULastErrMsgW() WUSysMessageW(::GetLastError())

// ----------------------------------------------------------------------------- // FUNCTIONAL COMPARATORS: // REMARKS: // These structs are derived from the std::binary_function template. They // give us functional classes (which may be used in Standard C++ Library // collections and algorithms) that perform case-insensitive comparisons of // CStdString objects. This is useful for maps in which the key may be the // proper string but in the wrong case. // ----------------------------------------------------------------------------- #define StdStringLessNoCaseW SSLNCW // avoid VC compiler warning 4786 #define StdStringEqualsNoCaseW SSENCW #define StdStringLessNoCaseA SSLNCA #define StdStringEqualsNoCaseA SSENCA

#ifdef UNICODE #define StdStringLessNoCase SSLNCW #define StdStringEqualsNoCase SSENCW #else #define StdStringLessNoCase SSLNCA #define StdStringEqualsNoCase SSENCA #endif

struct StdStringLessNoCaseW : std::binary_function<CStdStringW, CStdStringW, bool> { inline bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; } }; struct StdStringEqualsNoCaseW : std::binary_function<CStdStringW, CStdStringW, bool> { inline bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; } }; struct StdStringLessNoCaseA : std::binary_function<CStdStringA, CStdStringA, bool> { inline bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; } }; struct StdStringEqualsNoCaseA : std::binary_function<CStdStringA, CStdStringA, bool> { inline bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; } };

// If we had to define our own version of TRACE above, get rid of it now #ifdef TRACE_DEFINED_HERE #undef TRACE #undef TRACE_DEFINED_HERE #endif

#endif // #ifndef STDSTRING_H

Currently browsing [inifile.zip] (62,782 bytes) - [Html version/CIniFile.cpp.html] - (69,037 bytes)

<H3><CENTER>D:\CIniFile-Filpcode\CIniFile.cpp</CENTER></H3><PRE>
<FONT color="#008000">//-----------------------------------------------------------------------------</FONT>
<FONT color="#008000">// File name    : CIniFile.cpp</FONT>
<FONT color="#008000">// Author       : AV (Antoine Villepreux)</FONT>
<FONT color="#008000">// date         : 20/11/2000</FONT>
<FONT color="#008000">// Description  : CIniFile class implementation</FONT>
<FONT color="#008000">//              : Easy IniFile object management</FONT>
<FONT color="#008000">//-----------------------------------------------------------------------------</FONT>


<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Macros</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> M_MODULE_BGN <FONT color="#0f4b95">#define</FONT> M_MODULE_END

<FONT color="#0f4b95">#define</FONT> M_INCLUDES_BGN <FONT color="#0f4b95">#define</FONT> M_INCLUDES_END

<FONT color="#0f4b95">#define</FONT> M_INIFILE_FN_BGN <FONT color="#0f4b95">#define</FONT> M_INIFILE_FN_END

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> M_MODULE_BGN(<FONT color="#a52a00">"CIniFile.cpp"</FONT>)

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Includes</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> M_INCLUDES_BGN(<FONT color="#a52a00">"CIniFile.cpp"</FONT>)

<FONT color="#0f4b95">#include</FONT> <FONT color="#a52a00">"Common.h"</FONT> <FONT color="#0f4b95">#include</FONT> <FONT color="#a52a00">"CIniFile.h"</FONT> <FONT color="#008000">// #include "CCrypto.h"</FONT> <FONT color="#0f4b95">#include</FONT> <FONT color="#a52a00">"float.h"</FONT> <FONT color="#0f4b95">#include</FONT> <FONT color="#a52a00">"limits.h"</FONT>

M_INCLUDES_END(<FONT color="#a52a00">"CIniFile.cpp"</FONT>)

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> _DEBUG_NEW <FONT color="#0f4b95">#undef</FONT> <FONT color="#0f4b95">new</FONT> <FONT color="#0f4b95">#define</FONT> <FONT color="#0f4b95">new</FONT> DEBUG_NEW <FONT color="#0f4b95">#undef</FONT> THIS_FILE <FONT color="#0f4b95">#define</FONT> THIS_FILE __FILE__ <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Error constants</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strError = <FONT color="#a52a00">"CINIFILE_ERROR_READING_KEY_OR_SECTION"</FONT>; <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::ms_iError = INT_MAX; <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> CIniFile::ms_fError = FLT_MAX;

<FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strErrorMsg[CIniFile::E_INI_ERROR_MESSAGES::E_ERROR_MESSAGES_COUNT] = {

<FONT color="#a52a00">"Error: Unable to open ini file"</FONT>, <FONT color="#a52a00">"Error: Unable to save ini file"</FONT>, <FONT color="#a52a00">"Error: Unable to locate specified section"</FONT>, <FONT color="#a52a00">"Error: Unable to locate specified key"</FONT>, <FONT color="#a52a00">"Warning: unknown extension"</FONT> , <FONT color="#a52a00">"Warning: end string delimiter not found"</FONT> };

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Internal shortcuts constants</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strComment [CIniFile::E_INI_COMMENTS ::E_COMMENTS_COUNT ] = { <FONT color="#a52a00">";"</FONT> , <FONT color="#a52a00">"//"</FONT>, <FONT color="#a52a00">"/*"</FONT>, <FONT color="#a52a00">"\t\t"</FONT> }; <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strType [CIniFile::E_INI_TYPES ::E_TYPES_COUNT ] = { <FONT color="#a52a00">"%d"</FONT> , <FONT color="#a52a00">"%f"</FONT>, <FONT color="#a52a00">"%s"</FONT> }; <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strMarkup [CIniFile::E_INI_MARKUPS ::E_MARKUPS_COUNT ] = { <FONT color="#a52a00">"["</FONT> , <FONT color="#a52a00">"]"</FONT> , <FONT color="#a52a00">"="</FONT> }; <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strTrim [CIniFile::E_INI_TRIM ::E_TRIM_COUNT ] = { <FONT color="#a52a00">" "</FONT> , <FONT color="#a52a00">"\t"</FONT> }; <FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strExtension[CIniFile::E_INI_EXTENSIONS::E_EXTENSIONS_COUNT] = { <FONT color="#a52a00">".ini"</FONT>, <FONT color="#a52a00">".crk"</FONT> };

<FONT color="#0f4b95">const</FONT> CStdString CIniFile::ms_strStringDelimiter = <FONT color="#a52a00">"\""</FONT>;

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Various defines</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT>

<FONT color="#0f4b95">#ifdef</FONT> TO_BOOL <FONT color="#0f4b95">#undef</FONT> TO_BOOL <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#define</FONT> TO_BOOL(i) (((i)==<FONT color="#a52a00">0</FONT>)?false:true)

<FONT color="#0f4b95">#ifdef</FONT> TO_INT <FONT color="#0f4b95">#undef</FONT> TO_INT <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#define</FONT> TO_INT(b) (((b))?<FONT color="#a52a00">1</FONT>:<FONT color="#a52a00">0</FONT>)

<FONT color="#0f4b95">#define</FONT> BREAKPOINT _asm <FONT color="#0f4b95">int</FONT> <FONT color="#a52a00">3</FONT>

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// CIniFile Implementation</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT>

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CIniFile::CIniFile()</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Construct empty IniFile object</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CIniFile::CIniFile() { M_INIFILE_FN_BGN(CIniFile::CIniFile())

SetReadableExtension (ms_strExtension[E_INI_EXTENSIONS::E_READABLE ]); SetEncryptedExtension(ms_strExtension[E_INI_EXTENSIONS::E_ENCRYPTED]);

m_bFastRead = false;

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CIniFile::CIniFile(const CFilename & strFilename, bool bFastRead)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Construct IniFile object based on given file</FONT> <FONT color="#008000">// : Optionnal fast read may be used if file doesn't contain any</FONT> <FONT color="#008000">// : trailing spaces nor tabs</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CIniFile::CIniFile(<FONT color="#0f4b95">const</FONT> CFilename & strFilename, <FONT color="#0f4b95">bool</FONT> bFastRead) { M_INIFILE_FN_BGN(CIniFile::CIniFile(<FONT color="#0f4b95">const</FONT> CFilename & strFilename))

SetReadableExtension (ms_strExtension[E_INI_EXTENSIONS::E_READABLE ]); SetEncryptedExtension(ms_strExtension[E_INI_EXTENSIONS::E_ENCRYPTED]);

Load(strFilename, bFastRead);

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CIniFile::~CIniFile()</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Destruct IniFile object</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CIniFile::~CIniFile() { M_INIFILE_FN_BGN(CIniFile::~CIniFile(<FONT color="#0f4b95">bool</FONT> bSave))

<FONT color="#0f4b95">#ifdef</FONT> INI_SAVE_ON_EXIT

Save(m_strPath);

<FONT color="#0f4b95">#endif</FONT>

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::Load(const CStdString& strFilename, bool bFastRead)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Load ini file from disk or from previous specified file</FONT> <FONT color="#008000">// : Optionnal fast read may be used if file doesn't contain any</FONT> <FONT color="#008000">// : trailing spaces nor tabs</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::Load(<FONT color="#0f4b95">const</FONT> CStdString& strFilename, <FONT color="#0f4b95">bool</FONT> bFastRead) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::Load(<FONT color="#0f4b95">const</FONT> CStdString& strFilename))

m_bFastRead = bFastRead;

<FONT color="#0f4b95">if</FONT> (strFilename != <FONT color="#a52a00">""</FONT>) { m_strPath = strFilename; }

<FONT color="#008000">// Try reading readable ini file</FONT>

<FONT color="#0f4b95">if</FONT> (m_strPath.GetLength() > m_strReadableExtension.GetLength()) <FONT color="#0f4b95">if</FONT> (!m_strReadableExtension.CompareNoCase(m_strPath.Right(m_strReadableExtension.GetLength()))) { <FONT color="#008000">// If *.ini doesn't exist change extension to crypted extension and try again</FONT>

<FONT color="#0f4b95">if</FONT> (LoadReadableFile(m_strPath, true)) { <FONT color="#0f4b95">return</FONT> true; } <FONT color="#0f4b95">else</FONT> { m_strPath = m_strPath.Left(m_strPath.GetLength() - m_strReadableExtension.GetLength()) + m_strEncryptedExtension; } }

<FONT color="#008000">// Try reading crypted ini file</FONT> <FONT color="#0f4b95">if</FONT> (m_strPath.GetLength() > m_strEncryptedExtension.GetLength()) <FONT color="#0f4b95">if</FONT> (!m_strEncryptedExtension.CompareNoCase(m_strPath.Right(m_strEncryptedExtension.GetLength()))) { <FONT color="#0f4b95">return</FONT> LoadReadableFile(m_strPath, false); }

<FONT color="#008000">// No recognized extension found</FONT> <FONT color="#008000">// Try reading readable ini file</FONT>

m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_UNKNOWN_EXTENSION];

<FONT color="#0f4b95">if</FONT> (LoadReadableFile()) { <FONT color="#0f4b95">return</FONT> true; } <FONT color="#0f4b95">else</FONT> { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_READ];

<FONT color="#0f4b95">#ifdef</FONT> WIN32 CStdString strMsg = m_strPath + <FONT color="#a52a00">" file not found !"</FONT>; ::<FONT color="#0f4b95">MessageBox</FONT>(NULL,strMsg, m_strLastError, MB_OK); <FONT color="#0f4b95">#endif</FONT>

BREAKPOINT;

<FONT color="#0f4b95">#ifdef</FONT> INI_USE_EXEPTIONS

throw(strMsg.c_str());

<FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">return</FONT> false; }

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::LoadReadableFile(const CStdString& strFilename, bool bIsReadable)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Internal function - file loading</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::LoadReadableFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename, <FONT color="#0f4b95">bool</FONT> bIsReadable) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::LoadReadableFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename, <FONT color="#0f4b95">bool</FONT> bIsReadable))

<FONT color="#0f4b95">if</FONT> (strFilename != <FONT color="#a52a00">""</FONT>) m_strPath = strFilename;

<FONT color="#008000">// Open stream</FONT>

std::ifstream inifile; inifile.open(m_strPath);

<FONT color="#0f4b95">if</FONT> (inifile.fail()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_READ]; <FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">// Open stream Ok, parse file lines</FONT>

CStdString strLine, strSection, strKey, strValue;

<FONT color="#0f4b95">while</FONT> (GetLine(inifile, strLine)) { <FONT color="#0f4b95">if</FONT> (! bIsReadable) { Decrypt(strLine); }

<FONT color="#0f4b95">if</FONT> (!m_bFastRead) { ManageComments(&strLine); }

<FONT color="#0f4b95">if</FONT> (strLine != <FONT color="#a52a00">""</FONT>) { <FONT color="#0f4b95">if</FONT> ( strLine[<FONT color="#a52a00">0</FONT>] == (ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN])[<FONT color="#a52a00">0</FONT>] && strLine[strLine.GetLength()-<FONT color="#a52a00">1</FONT>] == (ms_strMarkup[E_INI_MARKUPS::E_SECTION_END] )[<FONT color="#a52a00">0</FONT>] ) { <FONT color="#008000">// Section found</FONT>

strSection = strLine;

strSection.TrimLeft (ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN]); strSection.TrimRight(ms_strMarkup[E_INI_MARKUPS::E_SECTION_END]);

<FONT color="#0f4b95">if</FONT> (!m_bFastRead) { CleanString(&strSection); } } <FONT color="#0f4b95">else</FONT> { <FONT color="#008000">// Key found</FONT>

strKey = strLine.Left (strLine.Find(ms_strMarkup[E_INI_MARKUPS::E_KEY])); strValue = strLine.Right(strLine.GetLength()-strKey.GetLength()-<FONT color="#a52a00">1</FONT>);

<FONT color="#0f4b95">if</FONT> (!m_bFastRead) { CleanString(&strKey); CleanString(&strValue); }

strValue.TrimLeft(ms_strMarkup[E_INI_MARKUPS::E_KEY]); SetValue(strSection, strKey, strValue); } } }

inifile.close();

<FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::Save(const CStdString& strFilename)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Save IniFile object to disk with specified filename</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::Save(<FONT color="#0f4b95">const</FONT> CStdString& strFilename) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::Save(<FONT color="#0f4b95">const</FONT> CStdString& strFilename))

<FONT color="#0f4b95">if</FONT> (strFilename != <FONT color="#a52a00">""</FONT>) m_strPath = strFilename;

<FONT color="#0f4b95">if</FONT> (m_strPath.GetLength() > m_strReadableExtension.GetLength()) <FONT color="#0f4b95">if</FONT> (!m_strReadableExtension.CompareNoCase(m_strPath.Right(m_strReadableExtension.GetLength()))) { <FONT color="#0f4b95">return</FONT> SaveReadableFile(); } <FONT color="#0f4b95">if</FONT> (m_strPath.GetLength() > m_strEncryptedExtension.GetLength()) <FONT color="#0f4b95">if</FONT> (!m_strEncryptedExtension.CompareNoCase(m_strPath.Right(m_strEncryptedExtension.GetLength()))) { <FONT color="#0f4b95">return</FONT> SaveEncryptedFile(); }

m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_UNKNOWN_EXTENSION];

SaveReadableFile();

<FONT color="#0f4b95">return</FONT> false;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SaveReadableFile(const CStdString& strFilename)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - save readable file to disk</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SaveReadableFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SaveReadableFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename))

<FONT color="#0f4b95">if</FONT> (strFilename != <FONT color="#a52a00">""</FONT>) m_strPath = strFilename;

std::ofstream inifile; inifile.open(m_strPath);

<FONT color="#0f4b95">for</FONT>(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { inifile << <FONT color="#a52a00">"\n"</FONT> << ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN] << (*m_itSection).first << ms_strMarkup[E_INI_MARKUPS::E_SECTION_END] << <FONT color="#a52a00">"\n"</FONT>;

<FONT color="#0f4b95">for</FONT>(m_itKey=((*m_itSection).second).begin(); m_itKey!=((*m_itSection).second).end(); m_itKey++) { inifile << (*m_itKey).first << ms_strMarkup[E_INI_MARKUPS::E_KEY] << (*m_itKey).second << <FONT color="#a52a00">"\n"</FONT>; } }

inifile.close();

<FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SaveEncryptedFile(const CStdString& strFilename)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - save crypted file to disk</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SaveEncryptedFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SaveEncryptedFile(<FONT color="#0f4b95">const</FONT> CStdString& strFilename))

<FONT color="#0f4b95">if</FONT> (strFilename != <FONT color="#a52a00">""</FONT>) m_strPath = strFilename;

std::ofstream inifile; inifile.open(m_strPath);

<FONT color="#0f4b95">for</FONT>(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { inifile << <FONT color="#a52a00">"\n"</FONT> << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_SECTION_BEGIN]) << Encrypt((*m_itSection).first) << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_SECTION_END]) << <FONT color="#a52a00">"\n"</FONT>;

<FONT color="#0f4b95">for</FONT>(m_itKey=((*m_itSection).second).begin(); m_itKey!=((*m_itSection).second).end(); m_itKey++) { inifile << Encrypt((*m_itKey).first) << Encrypt(ms_strMarkup[E_INI_MARKUPS::E_KEY]) << Encrypt((*m_itKey).second) << <FONT color="#a52a00">"\n"</FONT>; } }

inifile.close();

<FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : void CIniFile::Reset()</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Reset IniFile object - clears all sections and keys</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> CIniFile::Reset() { M_INIFILE_FN_BGN(<FONT color="#0f4b95">void</FONT> CIniFile::Reset())

<FONT color="#0f4b95">for</FONT>(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { ((*m_itSection).second).clear(); }

m_data.clear();

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : unsigned int CIniFile::GetSectionCount()</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get number of sections</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetSectionCount() { M_INIFILE_FN_BGN(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetSectionCount())

<FONT color="#0f4b95">return</FONT> m_data.size();

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">0</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : unsigned int CIniFile::GetKeyCount(const CStdString& strSection)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get number of keys in specified section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetKeyCount(<FONT color="#0f4b95">const</FONT> CStdString& strSection) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetKeyCount(<FONT color="#0f4b95">const</FONT> CStdString& strSection))

<FONT color="#0f4b95">return</FONT> m_data[strSection].size();

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">0</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : unsigned int CIniFile::GetKeyCount(unsigned int iSection)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get number of keys in i-th section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetKeyCount(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetKeyCount(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

<FONT color="#0f4b95">return</FONT> (*m_itSection).second.size();

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">0</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetSection(unsigned int iSection)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get name of i-th section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetSection(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection) { M_INIFILE_FN_BGN(CStdString CIniFile::GetSection(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

<FONT color="#0f4b95">return</FONT> (*m_itSection).first;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetKey(unsigned int iSection, unsigned int iKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get name of i-th key from i-th section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetKey(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetKey(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey))

m_itSection = m_data.begin(); std::advance(m_itSection, iSection);

m_itKey = (*m_itSection).second.begin(); std::advance(m_itKey, iKey);

<FONT color="#0f4b95">return</FONT> (*m_itKey).first;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetKey(const CStdString& strSection, unsigned int iKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get name of i-th key from specified section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetKey(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetKey(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey))

m_itKey = m_data[strSection].begin(); std::advance(m_itKey, iKey);

<FONT color="#0f4b95">return</FONT> (*m_itKey).first;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : int CIniFile::GetSection(const CStdString& strSection)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get id of specified section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetSection(<FONT color="#0f4b95">const</FONT> CStdString& strSection) { M_FN_BGN(<FONT color="#0f4b95">int</FONT> CIniFile::GetSection(<FONT color="#0f4b95">const</FONT> CStdString& strSection))

<FONT color="#0f4b95">int</FONT> iCurrentSection = <FONT color="#a52a00">0</FONT>;

<FONT color="#0f4b95">for</FONT>(m_itSection=m_data.begin(); m_itSection!=m_data.end(); m_itSection++) { <FONT color="#0f4b95">if</FONT> ((*m_itSection).first == strSection) { <FONT color="#0f4b95">return</FONT> iCurrentSection; }

iCurrentSection++; }

<FONT color="#0f4b95">return</FONT> -<FONT color="#a52a00">1</FONT>;

M_FN_END

<FONT color="#0f4b95">return</FONT> -<FONT color="#a52a00">1</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : int CIniFile::GetKey(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get id of specified key from specified section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetKey(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_FN_BGN(<FONT color="#0f4b95">int</FONT> CIniFile::GetKey(<FONT color="#0f4b95">const</FONT> CStdString& strKey);)

<FONT color="#0f4b95">int</FONT> iCurrentKey = <FONT color="#a52a00">0</FONT>;

<FONT color="#0f4b95">for</FONT>(m_itKey=m_data[strSection].begin(); m_itKey!=m_data[strSection].end(); m_itKey++) { <FONT color="#0f4b95">if</FONT> ((*m_itKey).first == strKey) { <FONT color="#0f4b95">return</FONT> iCurrentKey; }

iCurrentKey++; }

<FONT color="#0f4b95">return</FONT> -<FONT color="#a52a00">1</FONT>;

M_FN_END

<FONT color="#0f4b95">return</FONT> -<FONT color="#a52a00">1</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get string value from specified section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

<FONT color="#0f4b95">if</FONT> (!m_bFastRead) { <FONT color="#0f4b95">if</FONT> (m_data.find(strSection) == m_data.end()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_FIND_SECTION]; } <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> (m_data[strSection].find(strKey) == m_data[strSection].end()) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_FIND_KEY]; } <FONT color="#0f4b95">else</FONT> { <FONT color="#0f4b95">return</FONT> m_data[strSection][strKey]; }

<FONT color="#0f4b95">#ifdef</FONT> WIN32 ::<FONT color="#0f4b95">MessageBox</FONT>(NULL, m_strLastError, m_strPath, MB_ICONWARNING); <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifdef</FONT> INI_USE_EXEPTIONS throw(ms_strError.c_str()); <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#0f4b95">return</FONT> m_data[strSection][strKey];

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get string value from specified section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

<FONT color="#0f4b95">return</FONT> GetValue(strSection,strKey);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_strError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get string value from specified section/key and return default value if section or key not found</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault))

<FONT color="#0f4b95">if</FONT> (!m_bFastRead) { <FONT color="#0f4b95">if</FONT> ( (m_data.find(strSection) == m_data.end()) || (m_data[strSection].find(strKey) == m_data[strSection].end()) ) { <FONT color="#0f4b95">return</FONT> strDefault; } }

<FONT color="#0f4b95">return</FONT> GetValue(strSection,strKey);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> strDefault; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& strDefault)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get string value from specified section/key and return default value if section or key not found</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault) { M_INIFILE_FN_BGN(CStdString CIniFile::GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault))

<FONT color="#0f4b95">return</FONT> GetValue(strSection,strKey,strDefault);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> strDefault; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get integer value from specified section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">int</FONT> CIniFile::GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

<FONT color="#0f4b95">return</FONT> atoi(GetValue(strSection,strKey).c_str());

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_iError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : int CIniFile::GetValueI(const CStdString& strSection, const CStdString& strKey, const int & iDefault)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get integer value from specified section/key and return default value if section or key not found</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">int</FONT> CIniFile::GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & iDefault) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">int</FONT> CIniFile::GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & iDefault))

CStdString strDefault; strDefault.Format(ms_strType[CIniFile::E_INI_TYPES::E_INTEGER], iDefault);

<FONT color="#0f4b95">return</FONT> atoi(GetValue(strSection,strKey,strDefault).c_str());

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> iDefault; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get boolean value from specified section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

<FONT color="#0f4b95">return</FONT> TO_BOOL(GetValueI(strSection,strKey));

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> TO_BOOL(ms_iError); }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::GetValueB(const CStdString& strSection, const CStdString& strKey, const bool & bDefault)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get boolean value from specified section/key and return default value if section or key not found</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & bDefault) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & bDefault))

<FONT color="#0f4b95">return</FONT> TO_BOOL(GetValueI(strSection,strKey,TO_INT(bDefault)));

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> TO_BOOL(bDefault); }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get floating point value from specified section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">float</FONT> CIniFile::GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">float</FONT> CIniFile::GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

<FONT color="#0f4b95">return</FONT> (<FONT color="#0f4b95">float</FONT>)atof(GetValue(strSection,strKey).c_str());

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> ms_fError; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : float CIniFile::GetValueF(const CStdString& strSection, const CStdString& strKey, const float & fDefault)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get floating point value from specified section/key and return default value if section or key not found</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">float</FONT> CIniFile::GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & fDefault) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">float</FONT> CIniFile::GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & fDefault))

CStdString strDefault; strDefault.Format(ms_strType[CIniFile::E_INI_TYPES::E_FLOAT], fDefault);

<FONT color="#0f4b95">return</FONT> (<FONT color="#0f4b95">float</FONT>)atof(GetValue(strSection,strKey,strDefault).c_str());

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> fDefault; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : void CIniFile::SetReadableExtension(const CStdString& ext)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Change readable exension</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> CIniFile::SetReadableExtension(<FONT color="#0f4b95">const</FONT> CStdString& ext) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">void</FONT> CIniFile::SetReadableExtension(<FONT color="#0f4b95">const</FONT> CStdString& ext))

m_strReadableExtension = ext;

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : void CIniFile::SetEncryptedExtension(const CStdString& ext)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Change crypted exension</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> CIniFile::SetEncryptedExtension(<FONT color="#0f4b95">const</FONT> CStdString& ext) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">void</FONT> CIniFile::SetEncryptedExtension(<FONT color="#0f4b95">const</FONT> CStdString& ext))

m_strEncryptedExtension = ext;

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::GetLastErrorMessage()</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Get last error message</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::GetLastErrorMessage() { M_INIFILE_FN_BGN(CStdString CIniFile::GetLastErrorMessage())

<FONT color="#0f4b95">return</FONT> m_strLastError;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">"error in error handling !"</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool bCreate)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set string value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& value, <FONT color="#0f4b95">bool</FONT> bCreate) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& value, <FONT color="#0f4b95">bool</FONT> bCreate))

<FONT color="#0f4b95">if</FONT> (m_data.find(strSection) == m_data.end()) { <FONT color="#0f4b95">if</FONT> (!bCreate) { <FONT color="#0f4b95">return</FONT> false; }

m_data.insert(CSection::value_type(strSection,CKey())); }

<FONT color="#0f4b95">if</FONT> (m_data[strSection].find(strKey) == m_data[strSection].end()) { <FONT color="#0f4b95">if</FONT> (!bCreate) { <FONT color="#0f4b95">return</FONT> false; }

m_data[strSection].insert(CKey::value_type(strKey,<FONT color="#a52a00">""</FONT>)); }

m_data[strSection][strKey] = value; <FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false;

}

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValueS(const CStdString& strSection, const CStdString& strKey, const CStdString& value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set string value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& value, <FONT color="#0f4b95">bool</FONT> create))

SetValue(strSection, strKey, value, create); <FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false;

}

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const int & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set integer value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

<FONT color="#0f4b95">return</FONT> SetValueI(strSection, strKey, value, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set boolean value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

<FONT color="#0f4b95">return</FONT> SetValueB(strSection, strKey, value, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValue(const CStdString& strSection, const CStdString& strKey, const float & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set floating point value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValue(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

<FONT color="#0f4b95">return</FONT> SetValueF(strSection, strKey, value, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValueI(const CStdString& strSection, const CStdString& strKey, const int & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set integer value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_INTEGER],value); <FONT color="#0f4b95">return</FONT> SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValueB(const CStdString& strSection, const CStdString& strKey, const bool & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description :Set boolean value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_INTEGER],TO_INT(value)); <FONT color="#0f4b95">return</FONT> SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::SetValueF(const CStdString& strSection, const CStdString& strKey, const float & value, bool create)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Set floating point value to specified section/key. Possibility to create section/key if doesn't exist</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::SetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & value, <FONT color="#0f4b95">bool</FONT> create) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::SetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & value, <FONT color="#0f4b95">bool</FONT> create))

CStdString temp; temp.Format(ms_strType[E_INI_TYPES::E_FLOAT],value); <FONT color="#0f4b95">return</FONT> SetValue(strSection, strKey, temp, create);

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::Delete(const CStdString& strSection, const CStdString& strKey)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Delete section/key</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey))

m_data[strSection].erase(strKey);

<FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : bool CIniFile::Delete(const CStdString& strSection)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : Delete section</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">bool</FONT> CIniFile::Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">bool</FONT> CIniFile::Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection))

m_data.erase(strSection);

<FONT color="#0f4b95">return</FONT> true;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> false; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : std::istream & CIniFile::GetLine(std::istream & is, CStdString& str)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - get line from stream</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> std::istream & CIniFile::GetLine(std::istream & is, CStdString& str) { M_INIFILE_FN_BGN(std::istream & CIniFile::GetLine(std::istream & is, CStdString& str))

<FONT color="#0f4b95">char</FONT> buf[INI_LINE_MAX_LENGTH]; is.getline(buf, INI_LINE_MAX_LENGTH); str = buf; <FONT color="#0f4b95">return</FONT> is;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> is; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : void CIniFile::CleanString(CStdString * pString)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - clean given string (removes trailing characters)</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> CIniFile::CleanString(CStdString * pString) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">void</FONT> CIniFile::CleanString(CStdString * pString))

<FONT color="#0f4b95">int</FONT> iOldLength = pString->GetLength();

<FONT color="#0f4b95">do</FONT> <FONT color="#0f4b95">for</FONT>(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iTrim=<FONT color="#a52a00">0</FONT>; iTrim<E_INI_TRIM::E_TRIM_COUNT; iTrim++) { iOldLength = pString->GetLength();

pString->TrimLeft (ms_strTrim[iTrim]); pString->TrimRight(ms_strTrim[iTrim]); } <FONT color="#0f4b95">while</FONT>(pString->GetLength() != iOldLength);

pString->TrimLeft (ms_strStringDelimiter); pString->TrimRight(ms_strStringDelimiter);

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::ManageComments(CStdString * pString)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - removes (and retrieve) comment from string</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::ManageComments(CStdString * pString) { M_INIFILE_FN_BGN(CStdString CIniFile::ManageComments(CStdString * pString))

<FONT color="#008000">// First, look for string delimiters</FONT>

<FONT color="#0f4b95">int</FONT> iDelimiterBegin = pString->Find (ms_strStringDelimiter[<FONT color="#a52a00">0</FONT>]); <FONT color="#0f4b95">int</FONT> iDelimiterEnd = pString->ReverseFind(ms_strStringDelimiter[<FONT color="#a52a00">0</FONT>]);

<FONT color="#0f4b95">if</FONT> (iDelimiterEnd < iDelimiterBegin) { m_strLastError = ms_strErrorMsg[E_INI_ERROR_MESSAGES::E_END_DELIMITER]; }

<FONT color="#008000">// then manage comments</FONT>

CStdString strComment = <FONT color="#a52a00">""</FONT>;

<FONT color="#0f4b95">int</FONT> iPrevPos, iPos, iLength=pString->GetLength();

iPrevPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_0]); <FONT color="#0f4b95">if</FONT> ((iPrevPos<<FONT color="#a52a00">0</FONT>)||((iPrevPos>iDelimiterBegin)&&(iPrevPos<iDelimiterEnd))) iPrevPos = iLength;

iPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_1]); <FONT color="#0f4b95">if</FONT> ((iPos<<FONT color="#a52a00">0</FONT>)||((iPos>iDelimiterBegin)&&(iPos<iDelimiterEnd))) iPos = iLength;

iPos = (iPrevPos<iPos) ? iPrevPos : iPos;

iPrevPos = pString->Find(ms_strComment[E_INI_COMMENTS::E_2]); <FONT color="#0f4b95">if</FONT> ((iPrevPos<<FONT color="#a52a00">0</FONT>)||((iPrevPos>iDelimiterBegin)&&(iPrevPos<iDelimiterEnd))) iPrevPos = iLength;

iPos = (iPrevPos<iPos) ? iPrevPos : iPos;

<FONT color="#0f4b95">if</FONT> (iPos>=<FONT color="#a52a00">0</FONT>) { strComment = pString->Right(iLength-iPos); *pString = pString->Left (iPos);

pString->TrimRight(); pString->TrimRight(ms_strComment[E_INI_COMMENTS::E_SPACING]); }

<FONT color="#0f4b95">return</FONT> strComment;

M_INIFILE_FN_END

<FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">""</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : void CIniFile::Decrypt(CStdString& str)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - decrypt string (uses CCrypto)</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> CIniFile::Decrypt(CStdString& str) { M_INIFILE_FN_BGN(<FONT color="#0f4b95">void</FONT> CIniFile::Decrypt(CStdString& str))

<FONT color="#008000">// CCrypto::Decrypt(&str);</FONT>

M_INIFILE_FN_END }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Name : CStdString CIniFile::Encrypt(const CStdString& str)</FONT> <FONT color="#008000">// Author : AV (Antoine Villepreux)</FONT> <FONT color="#008000">// Date : 20/11/2000</FONT> <FONT color="#008000">// Description : internal function - encrypt string (uses CCrypto)</FONT> <FONT color="#008000">//-----------------------------------------------------------------------------</FONT> CStdString CIniFile::Encrypt(<FONT color="#0f4b95">const</FONT> CStdString& str) { M_INIFILE_FN_BGN(CStdString CIniFile::Encrypt(<FONT color="#0f4b95">const</FONT> CStdString& str))

CStdString strTmp = str;

<FONT color="#008000">// CCrypto::Encrypt(&strTmp);</FONT>

<FONT color="#0f4b95">return</FONT> strTmp;

M_INIFILE_FN_END <FONT color="#0f4b95">return</FONT> <FONT color="#a52a00">""</FONT>; }

<FONT color="#008000">//-----------------------------------------------------------------------------</FONT>

M_MODULE_END(<FONT color="#a52a00">"CIniFile.cpp"</FONT>)

</PRE><P><HR></P>

Currently browsing [inifile.zip] (62,782 bytes) - [Html version/CIniFile.h.html] - (14,663 bytes)

<H3><CENTER>D:\CIniFile-Filpcode\CIniFile.h</CENTER></H3><PRE>
<FONT color="#008000">//------------------------------------------------------------------------------</FONT>
<FONT color="#008000">// File name   : CIniFile.h</FONT>
<FONT color="#008000">// Author      : Microïds - Antoine Villepreux</FONT>
<FONT color="#008000">// Description : CIniFile class definition</FONT>
<FONT color="#008000">// Purpose     : Easy *.ini files management</FONT>
<FONT color="#008000">//------------------------------------------------------------------------------</FONT>

<FONT color="#0f4b95">#ifndef</FONT> CINIFILE_H
<FONT color="#0f4b95">#define</FONT> CINIFILE_H

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// Precompiler options</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> INI_USE_EXEPTIONS <FONT color="#0f4b95">#define</FONT> INI_CASE_INENSITIVE <FONT color="#0f4b95">#undef</FONT> INI_SAVE_ON_EXIT

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// Includes</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#include</FONT> <map> <FONT color="#0f4b95">#include</FONT> <fstream> <FONT color="#0f4b95">#include</FONT> <FONT color="#a52a00">"CStdString.h"</FONT>

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// CIniFile defines</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> INI_LINE_MAX_LENGTH <FONT color="#a52a00">1024</FONT>

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// CFilename definition</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> CFilename CStdString

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// CIniFile definition</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">class</FONT> CIniFile { <FONT color="#0f4b95">public</FONT>: <FONT color="#008000">// created in memory, no load from disk</FONT> CIniFile(); CIniFile(<FONT color="#0f4b95">const</FONT> CFilename &, <FONT color="#0f4b95">bool</FONT> bFastRead = false); <FONT color="#0f4b95">virtual</FONT> ~CIniFile();

<FONT color="#008000">// I/O - extension sensitive</FONT> <FONT color="#0f4b95">bool</FONT> Load(<FONT color="#0f4b95">const</FONT> CFilename & filename = <FONT color="#a52a00">""</FONT>, <FONT color="#0f4b95">bool</FONT> bFastRead = false); <FONT color="#0f4b95">bool</FONT> Save(<FONT color="#0f4b95">const</FONT> CFilename & filename = <FONT color="#a52a00">""</FONT>);

<FONT color="#008000">// Clear all</FONT> <FONT color="#0f4b95">void</FONT> Reset();

<FONT color="#008000">// Errors that 'GetValue' functions may return if key or section doesn't exist</FONT> <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strError; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> ms_iError; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> ms_fError;

<FONT color="#008000">// Get/Set values</FONT> CStdString GetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey); <FONT color="#008000">// #ifdef INI_USE_EXEPTIONS throw CStdString</FONT> CStdString GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey); <FONT color="#0f4b95">int</FONT> GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey); <FONT color="#0f4b95">bool</FONT> GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey); <FONT color="#0f4b95">float</FONT> GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey);

<FONT color="#008000">// No error but default value returned if section/key doesn't exists - use at your own risk</FONT> CStdString GetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault); CStdString GetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strDefault); <FONT color="#0f4b95">int</FONT> GetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & iDefault ); <FONT color="#0f4b95">bool</FONT> GetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & bDefault ); <FONT color="#0f4b95">float</FONT> GetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & fDefault );

<FONT color="#008000">// beware!! 'Save' After Setting values (to save to disk)</FONT> <FONT color="#0f4b95">bool</FONT> SetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & iValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & bValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValue (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & fValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValueS(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> CStdString& strValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValueI(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> & iValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValueB(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">bool</FONT> & bValue, <FONT color="#0f4b95">bool</FONT> bCreate=true); <FONT color="#0f4b95">bool</FONT> SetValueF(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">float</FONT> & fValue, <FONT color="#0f4b95">bool</FONT> bCreate=true);

<FONT color="#008000">// Sections/Keys Deletion/Retrieval</FONT> <FONT color="#0f4b95">bool</FONT> Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection); <FONT color="#0f4b95">bool</FONT> Delete(<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey);

<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> GetSectionCount(); <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> GetKeyCount(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection); <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> GetKeyCount(<FONT color="#0f4b95">const</FONT> CStdString& strSection);

CStdString GetSection(<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection); CStdString GetKey (<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey); CStdString GetKey (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> iKey);

<FONT color="#0f4b95">int</FONT> GetSection(<FONT color="#0f4b95">const</FONT> CStdString& strSection); <FONT color="#0f4b95">int</FONT> GetKey (<FONT color="#0f4b95">const</FONT> CStdString& strSection, <FONT color="#0f4b95">const</FONT> CStdString& strKey); <FONT color="#008000">// Extensions</FONT> <FONT color="#0f4b95">void</FONT> SetReadableExtension (<FONT color="#0f4b95">const</FONT> CStdString&); <FONT color="#0f4b95">void</FONT> SetEncryptedExtension(<FONT color="#0f4b95">const</FONT> CStdString&);

<FONT color="#008000">// Error messages</FONT> CStdString GetLastErrorMessage();

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// Private</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">protected</FONT>:

<FONT color="#0f4b95">enum</FONT> E_INI_ERROR_MESSAGES { E_READ = <FONT color="#a52a00">0</FONT>, E_WRITE, E_FIND_SECTION, E_FIND_KEY, E_UNKNOWN_EXTENSION, E_END_DELIMITER, E_ERROR_MESSAGES_COUNT, };

<FONT color="#0f4b95">enum</FONT> E_INI_COMMENTS { E_0 = <FONT color="#a52a00">0</FONT>, E_1, E_2, E_SPACING, E_COMMENTS_COUNT };

<FONT color="#0f4b95">enum</FONT> E_INI_TYPES { E_INTEGER = <FONT color="#a52a00">0</FONT>, E_FLOAT, E_STRING, E_TYPES_COUNT };

<FONT color="#0f4b95">enum</FONT> E_INI_MARKUPS { E_SECTION_BEGIN = <FONT color="#a52a00">0</FONT>, E_SECTION_END, E_KEY, E_MARKUPS_COUNT };

<FONT color="#0f4b95">enum</FONT> E_INI_TRIM { E_TRIM_0 = <FONT color="#a52a00">0</FONT>, E_TRIM_1, E_TRIM_COUNT };

<FONT color="#0f4b95">enum</FONT> E_INI_EXTENSIONS { E_READABLE = <FONT color="#a52a00">0</FONT>, E_ENCRYPTED, E_EXTENSIONS_COUNT };

<FONT color="#0f4b95">private</FONT>:

<FONT color="#008000">// Constants</FONT> <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strErrorMsg []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strComment []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strType []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strMarkup []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strTrim []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strExtension []; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CStdString ms_strStringDelimiter;

<FONT color="#008000">// Data</FONT> <FONT color="#0f4b95">typedef</FONT> std::map<CStdString, CStdString> CKey; <FONT color="#0f4b95">typedef</FONT> std::map<CStdString, CKey> CSection;

CSection m_data;

CSection::iterator m_itSection; CKey::iterator m_itKey;

<FONT color="#008000">// File</FONT> CStdString m_strPath; std::istream & GetLine(std::istream&, CStdString&);

<FONT color="#0f4b95">bool</FONT> LoadReadableFile (<FONT color="#0f4b95">const</FONT> CFilename& strFilename = <FONT color="#a52a00">""</FONT>, <FONT color="#0f4b95">bool</FONT> bIsReadable = true); <FONT color="#0f4b95">bool</FONT> SaveReadableFile (<FONT color="#0f4b95">const</FONT> CFilename& strFilename = <FONT color="#a52a00">""</FONT>); <FONT color="#0f4b95">bool</FONT> SaveEncryptedFile(<FONT color="#0f4b95">const</FONT> CFilename& strFilename = <FONT color="#a52a00">""</FONT>);

<FONT color="#008000">// String format</FONT> CStdString ManageComments(CStdString*); <FONT color="#0f4b95">void</FONT> CleanString(CStdString*);

<FONT color="#008000">// Encryption</FONT> CStdString m_strEncryptedExtension; CStdString m_strReadableExtension;

<FONT color="#0f4b95">void</FONT> Decrypt(CStdString&); CStdString Encrypt(<FONT color="#0f4b95">const</FONT> CStdString&);

<FONT color="#008000">// Various</FONT> CStdString m_strLastError; <FONT color="#0f4b95">bool</FONT> m_bFastRead; };

<FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#008000">// Inline functions</FONT> <FONT color="#008000">//------------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// CIniFile</FONT> </PRE><P><HR></P>

Currently browsing [inifile.zip] (62,782 bytes) - [Html version/CStdString.h.html] - (162,902 bytes)

<H3><CENTER>D:\CIniFile-Filpcode\CStdString.h</CENTER></H3><PRE><FONT color="#008000">// =============================================================================</FONT>
<FONT color="#008000">//  FILE:  StdString.h</FONT>
<FONT color="#008000">//  AUTHOR: Joe O'Leary (with outside help noted in comments)</FONT>
<FONT color="#008000">//  REMARKS:</FONT>
<FONT color="#008000">//      This header file declares the CStdStr template.  This template derives</FONT>
<FONT color="#008000">//      the Standard C++ Library basic_string<> template and add to it the</FONT>
<FONT color="#008000">//      the following conveniences:</FONT>
<FONT color="#008000">//          - The full MFC CString set of functions (including implicit cast)</FONT>
<FONT color="#008000">//          - writing to/reading from COM IStream interfaces</FONT>
<FONT color="#008000">//          - Functional objects for use in STL algorithms</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//      From this template, we intstantiate two classes:  CStdStringA and</FONT>
<FONT color="#008000">//      CStdStringW.  The name "CStdString" is just a #define of one of these,</FONT>
<FONT color="#008000">//      based upone the _UNICODE macro setting</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//      This header also declares our own version of the MFC/ATL UNICODE-MBCS</FONT>
<FONT color="#008000">//      conversion macros.  Our version looks exactly like the Microsoft's to</FONT>
<FONT color="#008000">//      facilitate portability.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//  NOTE:</FONT>
<FONT color="#008000">//      If you you use this in an MFC or ATL build, you should include either</FONT>
<FONT color="#008000">//      afx.h or atlbase.h first, as appropriate.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//  PEOPLE WHO HAVE CONTRIBUTED TO THIS CLASS:</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//      Several people have helped me iron out problems and othewise improve</FONT>
<FONT color="#008000">//      this class.  OK, this is a long list but in my own defense, this code</FONT>
<FONT color="#008000">//      has undergone two major rewrites.  Many of the improvements became</FONT>
<FONT color="#008000">//      necessary after I rewrote the code as a template.  Others helped me</FONT>
<FONT color="#008000">//      improve the CString facade.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//      Anyway, these people are (in chronological order):</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//          - Pete the Plumber (???)</FONT>
<FONT color="#008000">//          - Julian Selman</FONT>
<FONT color="#008000">//          - Chris (of Melbsys)</FONT>
<FONT color="#008000">//          - Dave Plummer</FONT>
<FONT color="#008000">//          - John C Sipos</FONT>
<FONT color="#008000">//          - Chris Sells</FONT>
<FONT color="#008000">//          - Nigel Nunn</FONT>
<FONT color="#008000">//          - Fan Xia</FONT>
<FONT color="#008000">//          - Matthew Williams</FONT>
<FONT color="#008000">//          - Carl Engman</FONT>
<FONT color="#008000">//          - Mark Zeren</FONT>
<FONT color="#008000">//          - Craig Watson</FONT>
<FONT color="#008000">//          - Rich Zuris</FONT>
<FONT color="#008000">//          - Karim Ratib</FONT>
<FONT color="#008000">//          - Chris Conti</FONT>
<FONT color="#008000">//          - Baptiste Lepilleur</FONT>
<FONT color="#008000">//          - Greg Pickles</FONT>
<FONT color="#008000">//          - Jim Cline</FONT>
<FONT color="#008000">//          - Jeff Kohn</FONT>
<FONT color="#008000">//          - Todd Heckel</FONT>
<FONT color="#008000">//          - Ullrich Pollähne</FONT>
<FONT color="#008000">//          - Joe Vitaterna</FONT>
<FONT color="#008000">//          - Joe Woodbury</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//  REVISION HISTORY</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-JUL-11 - Joe Woodbury noted that the CString::Find docs don't match</FONT>
<FONT color="#008000">//                  what the CString::Find code really ends up doing.   I was</FONT>
<FONT color="#008000">//                  trying to match the docs.  Now I match the CString code</FONT>
<FONT color="#008000">//                - Joe also caught me truncating strings for GetBuffer() calls</FONT>
<FONT color="#008000">//                  when the supplied length was less than the current length.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-MAY-25 - Better support for STLPORT's Standard library distribution</FONT>
<FONT color="#008000">//                - Got rid of the NSP macro - it interfered with Koenig lookup</FONT>
<FONT color="#008000">//                - Thanks to Joe Woodbury for catching a TrimLeft() bug that</FONT>
<FONT color="#008000">//                  I introduced in January.  Empty strings were not getting</FONT>
<FONT color="#008000">//                  trimmed</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-APR-17 - Thanks to Joe Vitaterna for pointing out that ReverseFind</FONT>
<FONT color="#008000">//                  is supposed to be a const function.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-MAR-07 - Thanks to Ullrich Pollähne for catching a range bug in one</FONT>
<FONT color="#008000">//                  of the overloads of assign.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-FEB-01 - You can now use CStdString on the Mac with CodeWarrior!</FONT>
<FONT color="#008000">//                  Thanks to Todd Heckel for helping out with this.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    2000-JAN-23 - Thanks to Jim Cline for pointing out how I could make the</FONT>
<FONT color="#008000">//                  Trim() function more efficient.</FONT>
<FONT color="#008000">//                - Thanks to Jeff Kohn for prompting me to find and fix a typo</FONT>
<FONT color="#008000">//                  in one of the addition operators that takes _bstr_t.</FONT>
<FONT color="#008000">//                - Got rid of the .CPP file -  you only need StdString.h now!</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-DEC-22 - Thanks to Greg Pickles for helping me identify a problem</FONT>
<FONT color="#008000">//                  with my implementation of CStdString::FormatV in which</FONT>
<FONT color="#008000">//                  resulting string might not be properly NULL terminated.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-DEC-06 - Chris Conti pointed yet another basic_string<> assignment</FONT>
<FONT color="#008000">//                  bug that MS has not fixed.  CStdString did nothing to fix</FONT>
<FONT color="#008000">//                  it either but it does now!  The bug was: create a string</FONT>
<FONT color="#008000">//                  longer than 31 characters, get a pointer to it (via c_str())</FONT>
<FONT color="#008000">//                  and then assign that pointer to the original string object.</FONT>
<FONT color="#008000">//                  The resulting string would be empty.  Not with CStdString!</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-OCT-06 - BufferSet was erasing the string even when it was merely</FONT>
<FONT color="#008000">//                  supposed to shrink it.  Fixed.  Thanks to Chris Conti.</FONT>
<FONT color="#008000">//                - Some of the Q172398 fixes were not checking for assignment-</FONT>
<FONT color="#008000">//                  to-self.  Fixed.  Thanks to Baptiste Lepilleur.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-AUG-20 - Improved Load() function to be more efficient by using </FONT>
<FONT color="#008000">//                  SizeOfResource().  Thanks to Rich Zuris for this.</FONT>
<FONT color="#008000">//                - Corrected resource ID constructor, again thanks to Rich.</FONT>
<FONT color="#008000">//                - Fixed a bug that occurred with UNICODE characters above</FONT>
<FONT color="#008000">//                  the first 255 ANSI ones.  Thanks to Craig Watson. </FONT>
<FONT color="#008000">//                - Added missing overloads of TrimLeft() and TrimRight().</FONT>
<FONT color="#008000">//                  Thanks to Karim Ratib for pointing them out</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-JUL-21 - Made all calls to GetBuf() with no args check length first.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-JUL-10 - Improved MFC/ATL independence of conversion macros</FONT>
<FONT color="#008000">//                - Added SS_NO_REFCOUNT macro to allow you to disable any</FONT>
<FONT color="#008000">//                  reference-counting your basic_string<> impl. may do.</FONT>
<FONT color="#008000">//                - Improved ReleaseBuffer() to be as forgiving as CString.</FONT>
<FONT color="#008000">//                  Thanks for Fan Xia for helping me find this and to</FONT>
<FONT color="#008000">//                  Matthew Williams for pointing it out directly.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-JUL-06 - Thanks to Nigel Nunn for catching a very sneaky bug in</FONT>
<FONT color="#008000">//                  ToLower/ToUpper.  They should call GetBuf() instead of</FONT>
<FONT color="#008000">//                  data() in order to ensure the changed string buffer is not</FONT>
<FONT color="#008000">//                  reference-counted (in those implementations that refcount).</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-JUL-01 - Added a true CString facade.  Now you can use CStdString as</FONT>
<FONT color="#008000">//                  a drop-in replacement for CString.  If you find this useful,</FONT>
<FONT color="#008000">//                  you can thank Chris Sells for finally convincing me to give</FONT>
<FONT color="#008000">//                  in and implement it.</FONT>
<FONT color="#008000">//                - Changed operators << and >> (for MFC CArchive) to serialize</FONT>
<FONT color="#008000">//                  EXACTLY as CString's do.  So now you can send a CString out</FONT>
<FONT color="#008000">//                  to a CArchive and later read it in as a CStdString.   I have</FONT>
<FONT color="#008000">//                  no idea why you would want to do this but you can. </FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-JUN-21 - Changed the CStdString class into the CStdStr template.</FONT>
<FONT color="#008000">//                - Fixed FormatV() to correctly decrement the loop counter.</FONT>
<FONT color="#008000">//                  This was harmless bug but a bug nevertheless.  Thanks to</FONT>
<FONT color="#008000">//                  Chris (of Melbsys) for pointing it out</FONT>
<FONT color="#008000">//                - Changed Format() to try a normal stack-based array before</FONT>
<FONT color="#008000">//                  using to _alloca().</FONT>
<FONT color="#008000">//                - Updated the text conversion macros to properly use code</FONT>
<FONT color="#008000">//                  pages and to fit in better in MFC/ATL builds.  In other</FONT>
<FONT color="#008000">//                  words, I copied Microsoft's conversion stuff again. </FONT>
<FONT color="#008000">//                - Added equivalents of CString::GetBuffer, GetBufferSetLength</FONT>
<FONT color="#008000">//                - new sscpy() replacement of CStdString::CopyString()</FONT>
<FONT color="#008000">//                - a Trim() function that combines TrimRight() and TrimLeft().</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-MAR-13 - Corrected the "NotSpace" functional object to use _istpace()</FONT>
<FONT color="#008000">//                  instead of _isspace()   Thanks to Dave Plummer for this.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-FEB-26 - Removed errant line (left over from testing) that #defined</FONT>
<FONT color="#008000">//                  _MFC_VER.  Thanks to John C Sipos for noticing this.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1999-FEB-03 - Fixed a bug in a rarely-used overload of operator+() that</FONT>
<FONT color="#008000">//                  caused infinite recursion and stack overflow</FONT>
<FONT color="#008000">//                - Added member functions to simplify the process of</FONT>
<FONT color="#008000">//                  persisting CStdStrings to/from DCOM IStream interfaces </FONT>
<FONT color="#008000">//                - Added functional objects (e.g. StdStringLessNoCase) that</FONT>
<FONT color="#008000">//                  allow CStdStrings to be used as keys STL map objects with</FONT>
<FONT color="#008000">//                  case-insensitive comparison </FONT>
<FONT color="#008000">//                - Added array indexing operators (i.e. operator[]).  I</FONT>
<FONT color="#008000">//                  originally assumed that these were unnecessary and would be</FONT>
<FONT color="#008000">//                  inherited from basic_string.  However, without them, Visual</FONT>
<FONT color="#008000">//                  C++ complains about ambiguous overloads when you try to use</FONT>
<FONT color="#008000">//                  them.  Thanks to Julian Selman to pointing this out. </FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1998-FEB-?? - Added overloads of assign() function to completely account</FONT>
<FONT color="#008000">//                  for Q172398 bug.  Thanks to "Pete the Plumber" for this</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//    1998-FEB-?? - Initial submission</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">// COPYRIGHT:</FONT>
<FONT color="#008000">//      1999 Joseph M. O'Leary.  This code is free.  Use it anywhere you want.</FONT>
<FONT color="#008000">//      Rewrite it, restructure it, whatever.  Please don't blame me if it makes</FONT>
<FONT color="#008000">//      your $30 billion dollar satellite explode in orbit.  If you redistribute</FONT>
<FONT color="#008000">//      it in any form, I'd appreciate it if you would leave this notice here.</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//      If you find any bugs, please let me know:</FONT>
<FONT color="#008000">//</FONT>
<FONT color="#008000">//              jmoleary@earthlink.net</FONT>
<FONT color="#008000">//              http://home.earthlink.net/~jmoleary</FONT>
<FONT color="#008000">// =============================================================================</FONT>

<FONT color="#008000">// Avoid multiple inclusion the VC++ way,</FONT>
<FONT color="#008000">// Turn off browser references</FONT>
<FONT color="#008000">// Turn off unavoidable compiler warnings</FONT>

<FONT color="#0f4b95">#if</FONT> defined(_MSC_VER) && (_MSC_VER > <FONT color="#a52a00">1100</FONT>)
    <FONT color="#0f4b95">#pragma</FONT> once
    <FONT color="#0f4b95">#pragma</FONT> component(browser, off, references, <FONT color="#a52a00">"CStdString"</FONT>)
    <FONT color="#0f4b95">#pragma</FONT> warning (disable : <FONT color="#a52a00">4290</FONT>) <FONT color="#008000">// C++ Exception Specification ignored</FONT>
    <FONT color="#0f4b95">#pragma</FONT> warning (disable : <FONT color="#a52a00">4127</FONT>) <FONT color="#008000">// Conditional expression is constant</FONT>
    <FONT color="#0f4b95">#pragma</FONT> warning (disable : <FONT color="#a52a00">4097</FONT>) <FONT color="#008000">// typedef name used as synonym for class name</FONT>

    <FONT color="#008000">// AV - 22/08/2000</FONT>
    <FONT color="#008000">// To avoid "identifier was truncated to '255' characters in the debug information"</FONT>
    <FONT color="#0f4b95">#pragma</FONT> warning (disable : <FONT color="#a52a00">4786</FONT>)

<FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifndef</FONT> STDSTRING_H <FONT color="#0f4b95">#define</FONT> STDSTRING_H

<FONT color="#008000">// MACRO: SS_NO_REFCOUNT:</FONT> <FONT color="#008000">// turns off reference counting at the assignment level</FONT> <FONT color="#008000">// I define this by default. comment it out if you don't want it.</FONT> <FONT color="#0f4b95">#define</FONT> SS_NO_REFCOUNT

<FONT color="#008000">// In non-Visual C++ and/or non-Win32 builds, we can't use some cool stuff.</FONT> <FONT color="#0f4b95">#if</FONT> !defined(_MSC_VER) || !defined(_WIN32) <FONT color="#0f4b95">#define</FONT> SS_ANSI <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well</FONT> <FONT color="#0f4b95">#if</FONT> defined (_UNICODE) && !defined (UNICODE) <FONT color="#0f4b95">#define</FONT> UNICODE <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#if</FONT> defined (UNICODE) && !defined (_UNICODE) <FONT color="#0f4b95">#define</FONT> _UNICODE <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// MIN and MAX. The Standard C++ template versions go by so many names (at</FONT> <FONT color="#008000">// at least in the MS implementation) that you never know what's available </FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">template</FONT><<FONT color="#0f4b95">class</FONT> Type> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">const</FONT> Type& SSMIN(<FONT color="#0f4b95">const</FONT> Type& arg1, <FONT color="#0f4b95">const</FONT> Type& arg2) { <FONT color="#0f4b95">return</FONT> arg2 < arg1 ? arg2 : arg1; } <FONT color="#0f4b95">template</FONT><<FONT color="#0f4b95">class</FONT> Type> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">const</FONT> Type& SSMAX(<FONT color="#0f4b95">const</FONT> Type& arg1, <FONT color="#0f4b95">const</FONT> Type& arg2) { <FONT color="#0f4b95">return</FONT> arg2 > arg1 ? arg2 : arg1; }

<FONT color="#008000">// If they have not #included W32Base.h (part of my W32 utility library) then</FONT> <FONT color="#008000">// we need to define some stuff. Otherwise, this is all defined there.</FONT> <FONT color="#0f4b95">#if</FONT> !defined(W32BASE_H)

<FONT color="#008000">// If they want us to use only standard C++ stuff (no Win32 stuff)</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI

<FONT color="#008000">// On non-Win32 platforms, there is no TCHAR.H so define what we need</FONT> <FONT color="#0f4b95">#ifndef</FONT> _WIN32

<FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">char</FONT>* PCSTR; <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">char</FONT>* PSTR; <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">const</FONT> wchar_t* PCWSTR; <FONT color="#0f4b95">typedef</FONT> wchar_t* PWSTR; <FONT color="#0f4b95">#ifdef</FONT> UNICODE <FONT color="#0f4b95">typedef</FONT> wchar_t TCHAR; <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">char</FONT> TCHAR; <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">typedef</FONT> wchar_t OLECHAR;

<FONT color="#0f4b95">#else</FONT>

<FONT color="#0f4b95">#include</FONT> <TCHAR.H> <FONT color="#0f4b95">#include</FONT> <WTYPES.H> <FONT color="#0f4b95">#ifndef</FONT> STRICT <FONT color="#0f4b95">#define</FONT> STRICT <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef _WIN32</FONT>

<FONT color="#008000">// Make sure ASSERT and verify are defined in an ANSI fashion</FONT> <FONT color="#0f4b95">#ifndef</FONT> ASSERT <FONT color="#0f4b95">#include</FONT> <assert.h> <FONT color="#0f4b95">#define</FONT> ASSERT(f) assert((f)) <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#ifndef</FONT> VERIFY <FONT color="#0f4b95">#ifdef</FONT> _DEBUG <FONT color="#0f4b95">#define</FONT> VERIFY(x) ASSERT((x)) <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> VERIFY(x) x <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#else</FONT> <FONT color="#008000">// #ifdef SS_ANSI</FONT> <FONT color="#0f4b95">#include</FONT> <TCHAR.H> <FONT color="#0f4b95">#include</FONT> <WTYPES.H> <FONT color="#0f4b95">#ifndef</FONT> STRICT <FONT color="#0f4b95">#define</FONT> STRICT <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Make sure ASSERT and verify are defined</FONT> <FONT color="#0f4b95">#ifndef</FONT> ASSERT <FONT color="#0f4b95">#include</FONT> <crtdbg.h> <FONT color="#0f4b95">#define</FONT> ASSERT(f) _ASSERTE((f)) <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#ifndef</FONT> VERIFY <FONT color="#0f4b95">#ifdef</FONT> _DEBUG <FONT color="#0f4b95">#define</FONT> VERIFY(x) ASSERT((x)) <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> VERIFY(x) x <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef SS_ANSI</FONT> <FONT color="#0f4b95">#ifndef</FONT> UNUSED <FONT color="#0f4b95">#define</FONT> UNUSED(x) x <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef W32BASE_H</FONT> <FONT color="#008000">// Standard headers needed</FONT> <FONT color="#0f4b95">#include</FONT> <string> <FONT color="#008000">// basic_string</FONT> <FONT color="#0f4b95">#include</FONT> <algorithm> <FONT color="#008000">// for_each, etc.</FONT> <FONT color="#0f4b95">#include</FONT> <functional> <FONT color="#008000">// for StdStringLessNoCase, et al</FONT> <FONT color="#0f4b95">#include</FONT> <locale> <FONT color="#008000">// for various facets</FONT> <FONT color="#008000">// If this is a recent enough version of VC include comdef.h, so we can write</FONT> <FONT color="#008000">// member functions to deal with COM types & compiler support classes e.g. _bstr_t</FONT> <FONT color="#0f4b95">#if</FONT> defined (_MSC_VER) && (_MSC_VER >= <FONT color="#a52a00">1100</FONT>) <FONT color="#0f4b95">#include</FONT> <comdef.h> <FONT color="#0f4b95">#define</FONT> SS_INC_COMDEF <FONT color="#008000">// signal that we #included MS comdef.h file</FONT> <FONT color="#0f4b95">#define</FONT> STDSTRING_INC_COMDEF <FONT color="#0f4b95">#define</FONT> SS_NOTHROW __declspec(nothrow) <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SS_NOTHROW <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifndef</FONT> TRACE <FONT color="#0f4b95">#define</FONT> TRACE_DEFINED_HERE <FONT color="#0f4b95">#define</FONT> TRACE <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR. I hate to use the</FONT> <FONT color="#008000">// versions with the "L" in front of them because that's a leftover from Win 16</FONT> <FONT color="#008000">// days, even though it evaluates to the same thing. Therefore, Define a PCSTR</FONT> <FONT color="#008000">// as an LPCTSTR.</FONT> <FONT color="#0f4b95">#if</FONT> !defined(PCTSTR) && !defined(PCTSTR_DEFINED) <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">const</FONT> TCHAR* PCTSTR; <FONT color="#0f4b95">#define</FONT> PCTSTR_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#if</FONT> !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED) <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">const</FONT> OLECHAR* PCOLESTR; <FONT color="#0f4b95">#define</FONT> PCOLESTR_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#if</FONT> !defined(POLESTR) && !defined(POLESTR_DEFINED) <FONT color="#0f4b95">typedef</FONT> OLECHAR* POLESTR; <FONT color="#0f4b95">#define</FONT> POLESTR_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#if</FONT> !defined(PCUSTR) && !defined(PCUSTR_DEFINED) <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">char</FONT>* PCUSTR; <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">char</FONT>* PUSTR; <FONT color="#0f4b95">#define</FONT> PCUSTR_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// SS_USE_FACET macro and why we need it:</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Since I'm a good little Standard C++ programmer, I use locales. Thus, I</FONT> <FONT color="#008000">// need to make use of the use_facet<> template function here. Unfortunately,</FONT> <FONT color="#008000">// this need is complicated by the fact the MS' implementation of the Standard</FONT> <FONT color="#008000">// C++ Library has a non-standard version of use_facet that takes more</FONT> <FONT color="#008000">// arguments than the standard dictates. Since I'm trying to write CStdString</FONT> <FONT color="#008000">// to work with any version of the Standard library, this presents a problem.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// The upshot of this is that I can't do 'use_facet' directly. The MS' docs</FONT> <FONT color="#008000">// tell me that I have to use a macro, _USE() instead. Since _USE obviously</FONT> <FONT color="#008000">// won't be available in other implementations, this means that I have to write</FONT> <FONT color="#008000">// my OWN macro -- SS_USE_FACET -- that evaluates either to _USE or to the</FONT> <FONT color="#008000">// standard, use_facet.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// If you are having trouble with the SS_USE_FACET macro, in your implementation</FONT> <FONT color="#008000">// of the Standard C++ Library, you can define your own version of SS_USE_FACET.</FONT> <FONT color="#0f4b95">#ifndef</FONT> schMSG <FONT color="#0f4b95">#define</FONT> schSTR(x) #x <FONT color="#0f4b95">#define</FONT> schSTR2(x) schSTR(x) <FONT color="#0f4b95">#define</FONT> schMSG(desc) message(__FILE__ <FONT color="#a52a00">"("</FONT> schSTR2(__LINE__) <FONT color="#a52a00">"):"</FONT> #desc) <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifndef</FONT> SS_USE_FACET <FONT color="#008000">// STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for</FONT> <FONT color="#008000">// all MSVC builds, erroneously in my opinion. It causes problems for</FONT> <FONT color="#008000">// my SS_ANSI builds. In my code, I always comment out that line. You'll</FONT> <FONT color="#008000">// find it in \stlport\config\stl_msvc.h</FONT> <FONT color="#0f4b95">#if</FONT> defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= <FONT color="#a52a00">0x400</FONT> ) <FONT color="#0f4b95">#if</FONT> defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER) <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">#pragma</FONT> schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!) <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#define</FONT> SS_USE_FACET(loc, fac) std::use_facet<fac >(loc) <FONT color="#0f4b95">#elif</FONT> defined(_MSC_VER ) <FONT color="#0f4b95">#define</FONT> SS_USE_FACET(loc, fac) std::_USE(loc,fac) <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SS_USE_FACET(loc, fac) std::use_facet<fac >(loc) <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// UNICODE/MBCS conversion macros. Made to work just like the MFC/ATL ones.</FONT> <FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// First define the conversion helper functions. We define these regardless of</FONT> <FONT color="#008000">// any preprocessor macro settings since their names won't collide. </FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#008000">// Are we doing things the standard, non-Win32 way?...</FONT> <FONT color="#0f4b95">typedef</FONT> std::codecvt<wchar_t, <FONT color="#0f4b95">char</FONT>, mbstate_t> SSCodeCvt;

<FONT color="#008000">// Not sure if we need all these headers. I believe ANSI says we do.</FONT> <FONT color="#0f4b95">#include</FONT> <stdio.h> <FONT color="#0f4b95">#include</FONT> <stdarg.h> <FONT color="#0f4b95">#include</FONT> <wchar.h> <FONT color="#0f4b95">#ifndef</FONT> va_start <FONT color="#0f4b95">#include</FONT> <varargs.h> <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// StdCodeCvt - made to look like Win32 functions WideCharToMultiByte annd</FONT> <FONT color="#008000">// MultiByteToWideChar but uses locales in SS_ANSI builds</FONT> <FONT color="#0f4b95">inline</FONT> PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, <FONT color="#0f4b95">int</FONT> nChars, <FONT color="#0f4b95">const</FONT> std::locale& loc=std::locale()) { ASSERT(NULL != pA); ASSERT(NULL != pW); pW[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; PSTR pBadA = NULL; PWSTR pBadW = NULL; SSCodeCvt::result res = SSCodeCvt::ok; <FONT color="#0f4b95">const</FONT> SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); res = conv.in(res, pA, pA + nChars, pBadA, pW, pW + nChars, pBadW); ASSERT(SSCodeCvt::ok == res); <FONT color="#0f4b95">return</FONT> pW; } <FONT color="#0f4b95">inline</FONT> PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, <FONT color="#0f4b95">int</FONT> nChars, <FONT color="#0f4b95">const</FONT> std::locale& loc=std::locale()) { <FONT color="#0f4b95">return</FONT> StdCodeCvt(pW, (PCSTR)pA, nChars, loc); }

<FONT color="#0f4b95">inline</FONT> PSTR StdCodeCvt(PSTR pA, PCWSTR pW, <FONT color="#0f4b95">int</FONT> nChars, <FONT color="#0f4b95">const</FONT> std::locale& loc=std::locale()) { ASSERT(NULL != pA); ASSERT(NULL != pW); pA[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; PSTR pBadA = NULL; PWSTR pBadW = NULL; <FONT color="#0f4b95">const</FONT> SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); SSCodeCvt::result res = SSCodeCvt::ok; res = conv.out(res, pW, pW + nChars, pBadW, pA, pA + nChars, pBadA); ASSERT(SSCodeCvt::ok == res); <FONT color="#0f4b95">return</FONT> pA; } <FONT color="#0f4b95">inline</FONT> PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, <FONT color="#0f4b95">int</FONT> nChars, <FONT color="#0f4b95">const</FONT> std::locale& loc=std::locale()) { <FONT color="#0f4b95">return</FONT> (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, loc); }

<FONT color="#0f4b95">#else</FONT> <FONT color="#008000">// ...or are we doing things assuming win32 and Visual C++?</FONT> <FONT color="#0f4b95">#include</FONT> <malloc.h> <FONT color="#008000">// needed for _alloca</FONT> <FONT color="#0f4b95">inline</FONT> PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, <FONT color="#0f4b95">int</FONT> nChars, UINT acp=CP_ACP) { ASSERT(NULL != pA); ASSERT(NULL != pW); pW[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; MultiByteToWideChar(acp, <FONT color="#a52a00">0</FONT>, pA, -<FONT color="#a52a00">1</FONT>, pW, nChars); <FONT color="#0f4b95">return</FONT> pW; } <FONT color="#0f4b95">inline</FONT> PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, <FONT color="#0f4b95">int</FONT> nChars, UINT acp=CP_ACP) { <FONT color="#0f4b95">return</FONT> StdCodeCvt(pW, (PCSTR)pA, nChars, acp); }

<FONT color="#0f4b95">inline</FONT> PSTR StdCodeCvt(PSTR pA, PCWSTR pW, <FONT color="#0f4b95">int</FONT> nChars, UINT acp=CP_ACP) { ASSERT(NULL != pA); ASSERT(NULL != pW); pA[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; WideCharToMultiByte(acp, <FONT color="#a52a00">0</FONT>, pW, -<FONT color="#a52a00">1</FONT>, pA, nChars, NULL, NULL); <FONT color="#0f4b95">return</FONT> pA; } <FONT color="#0f4b95">inline</FONT> PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, <FONT color="#0f4b95">int</FONT> nChars, UINT acp=CP_ACP) { <FONT color="#0f4b95">return</FONT> (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, acp); }

<FONT color="#008000">// Define our conversion macros to look exactly like Microsoft's to</FONT> <FONT color="#008000">// facilitate using this stuff both with and without MFC/ATL</FONT> <FONT color="#0f4b95">#ifdef</FONT> _CONVERSION_USES_THREAD_LOCALE <FONT color="#0f4b95">#ifndef</FONT> _DEBUG <FONT color="#0f4b95">#define</FONT> SSCVT <FONT color="#0f4b95">int</FONT> _cvt; _cvt; UINT _acp=GetACP(); \ _acp; PCWSTR _pw; _pw; PCSTR _pa; _pa <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SSCVT <FONT color="#0f4b95">int</FONT> _cvt = <FONT color="#a52a00">0</FONT>; _cvt; UINT _acp=GetACP();\ _acp; PCWSTR _pw=NULL; _pw; PCSTR _pa=NULL; _pa <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#ifndef</FONT> _DEBUG <FONT color="#0f4b95">#define</FONT> SSCVT <FONT color="#0f4b95">int</FONT> _cvt; _cvt; UINT _acp=CP_ACP; _acp;\ PCWSTR _pw; _pw; PCSTR _pa; _pa <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SSCVT <FONT color="#0f4b95">int</FONT> _cvt = <FONT color="#a52a00">0</FONT>; _cvt; UINT _acp=CP_ACP; \ _acp; PCWSTR _pw=NULL; _pw; PCSTR _pa=NULL; _pa <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifdef</FONT> _CONVERSION_USES_THREAD_LOCALE <FONT color="#0f4b95">#define</FONT> SSA2W(pa) (\ ((_pa = pa) == NULL) ? NULL : (\ _cvt = (strlen(_pa)+<FONT color="#a52a00">1</FONT>),\ StdCodeCvt((PWSTR) _alloca(_cvt*<FONT color="#a52a00">2</FONT>), _pa, _cvt, _acp))) <FONT color="#0f4b95">#define</FONT> SSW2A(pw) (\ ((_pw = pw) == NULL) ? NULL : (\ _cvt = (wcslen(_pw)+<FONT color="#a52a00">1</FONT>)*<FONT color="#a52a00">2</FONT>,\ StdW2AHelper((<FONT color="#0f4b95">LPSTR</FONT>) _alloca(_cvt), _pw, _cvt, _acp))) <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SSA2W(pa) (\ ((_pa = pa) == NULL) ? NULL : (\ _cvt = (strlen(_pa)+<FONT color="#a52a00">1</FONT>),\ StdCodeCvt((PWSTR) _alloca(_cvt*<FONT color="#a52a00">2</FONT>), _pa, _cvt))) <FONT color="#0f4b95">#define</FONT> SSW2A(pw) (\ ((_pw = pw) == NULL) ? NULL : (\ _cvt = (wcslen(_pw)+<FONT color="#a52a00">1</FONT>)*<FONT color="#a52a00">2</FONT>,\ StdCodeCvt((<FONT color="#0f4b95">LPSTR</FONT>) _alloca(_cvt), _pw, _cvt))) <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#define</FONT> SSA2CW(pa) ((PCWSTR)SSA2W((pa))) <FONT color="#0f4b95">#define</FONT> SSW2CA(pw) ((PCSTR)SSW2A((pw)))

<FONT color="#0f4b95">#ifdef</FONT> UNICODE <FONT color="#0f4b95">#define</FONT> SST2A SSW2A <FONT color="#0f4b95">#define</FONT> SSA2T SSA2W <FONT color="#0f4b95">#define</FONT> SST2CA SSW2CA <FONT color="#0f4b95">#define</FONT> SSA2CT SSA2CW <FONT color="#0f4b95">inline</FONT> PWSTR SST2W(PTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PTSTR SSW2T(PWSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCWSTR SST2CW(PCTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCTSTR SSW2CT(PCWSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SST2W SSA2W <FONT color="#0f4b95">#define</FONT> SSW2T SSW2A <FONT color="#0f4b95">#define</FONT> SST2CW SSA2CW <FONT color="#0f4b95">#define</FONT> SSW2CT SSW2CA <FONT color="#0f4b95">inline</FONT> PSTR SST2A(PTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PTSTR SSA2T(PSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCSTR SST2CA(PCTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCTSTR SSA2CT(PCSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef UNICODE</FONT> <FONT color="#0f4b95">#if</FONT> defined(UNICODE) <FONT color="#008000">// in these cases the default (TCHAR) is the same as OLECHAR</FONT> <FONT color="#0f4b95">inline</FONT> PCOLESTR SST2COLE(PCTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCTSTR SSOLE2CT(PCOLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> POLESTR SST2OLE(PTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PTSTR SSOLE2T(POLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#elif</FONT> defined(OLE2ANSI) <FONT color="#008000">// in these cases the default (TCHAR) is the same as OLECHAR</FONT> <FONT color="#0f4b95">inline</FONT> PCOLESTR SST2COLE(PCTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCTSTR SSOLE2CT(PCOLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> POLESTR SST2OLE(PTSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PTSTR SSOLE2T(POLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#else</FONT> <FONT color="#008000">//CharNextW doesn't work on Win95 so we use this</FONT> <FONT color="#0f4b95">#define</FONT> SST2COLE(pa) SSA2CW((pa)) <FONT color="#0f4b95">#define</FONT> SST2OLE(pa) SSA2W((pa)) <FONT color="#0f4b95">#define</FONT> SSOLE2CT(po) SSW2CA((po)) <FONT color="#0f4b95">#define</FONT> SSOLE2T(po) SSW2A((po)) <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#ifdef</FONT> OLE2ANSI <FONT color="#0f4b95">#define</FONT> SSW2OLE SSW2A <FONT color="#0f4b95">#define</FONT> SSOLE2W SSA2W <FONT color="#0f4b95">#define</FONT> SSW2COLE SSW2CA <FONT color="#0f4b95">#define</FONT> SSOLE2CW SSA2CW <FONT color="#0f4b95">inline</FONT> POLESTR SSA2OLE(PSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PSTR SSOLE2A(POLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCOLESTR SSA2COLE(PCSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCSTR SSOLE2CA(PCOLESTR p){ <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SSA2OLE SSA2W <FONT color="#0f4b95">#define</FONT> SSOLE2A SSW2A <FONT color="#0f4b95">#define</FONT> SSA2COLE SSA2CW <FONT color="#0f4b95">#define</FONT> SSOLE2CA SSW2CA <FONT color="#0f4b95">inline</FONT> POLESTR SSW2OLE(PWSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PWSTR SSOLE2W(POLESTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCOLESTR SSW2COLE(PCWSTR p) { <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">inline</FONT> PCWSTR SSOLE2CW(PCOLESTR p){ <FONT color="#0f4b95">return</FONT> p; } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Above we've defined macros that look like MS' but all have</FONT> <FONT color="#008000">// an 'SS' prefix. Now we need the real macros. We'll either</FONT> <FONT color="#008000">// get them from the macros above or from MFC/ATL. If</FONT> <FONT color="#008000">// SS_NO_CONVERSION is #defined, we'll forgo them</FONT> <FONT color="#0f4b95">#ifndef</FONT> SS_NO_CONVERSION

<FONT color="#0f4b95">#if</FONT> defined (USES_CONVERSION)

<FONT color="#0f4b95">#define</FONT> _NO_STDCONVERSION <FONT color="#008000">// just to be consistent</FONT> <FONT color="#0f4b95">#else</FONT>

<FONT color="#0f4b95">#ifdef</FONT> _MFC_VER

<FONT color="#0f4b95">#include</FONT> <afxconv.h> <FONT color="#0f4b95">#define</FONT> _NO_STDCONVERSION <FONT color="#008000">// just to be consistent</FONT> <FONT color="#0f4b95">#else</FONT>

<FONT color="#0f4b95">#define</FONT> USES_CONVERSION SSCVT <FONT color="#0f4b95">#define</FONT> A2CW SSA2CW <FONT color="#0f4b95">#define</FONT> W2CA SSW2CA <FONT color="#0f4b95">#define</FONT> T2A SST2A <FONT color="#0f4b95">#define</FONT> A2T SSA2T <FONT color="#0f4b95">#define</FONT> T2W SST2W <FONT color="#0f4b95">#define</FONT> W2T SSW2T <FONT color="#0f4b95">#define</FONT> T2CA SST2CA <FONT color="#0f4b95">#define</FONT> A2CT SSA2CT <FONT color="#0f4b95">#define</FONT> T2CW SST2CW <FONT color="#0f4b95">#define</FONT> W2CT SSW2CT <FONT color="#0f4b95">#define</FONT> ocslen sslen <FONT color="#0f4b95">#define</FONT> ocscpy sscpy <FONT color="#0f4b95">#define</FONT> T2COLE SST2COLE <FONT color="#0f4b95">#define</FONT> OLE2CT SSOLE2CT <FONT color="#0f4b95">#define</FONT> T2OLE SST2COLE <FONT color="#0f4b95">#define</FONT> OLE2T SSOLE2CT <FONT color="#0f4b95">#define</FONT> A2OLE SSA2OLE <FONT color="#0f4b95">#define</FONT> OLE2A SSOLE2A <FONT color="#0f4b95">#define</FONT> W2OLE SSW2OLE <FONT color="#0f4b95">#define</FONT> OLE2W SSOLE2W <FONT color="#0f4b95">#define</FONT> A2COLE SSA2COLE <FONT color="#0f4b95">#define</FONT> OLE2CA SSOLE2CA <FONT color="#0f4b95">#define</FONT> W2COLE SSW2COLE <FONT color="#0f4b95">#define</FONT> OLE2CW SSOLE2CW <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef _MFC_VER</FONT> <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef USES_CONVERSION</FONT> <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef SS_NO_CONVERSION</FONT> <FONT color="#008000">// Define ostring - generic name for std::basic_string<OLECHAR></FONT> <FONT color="#0f4b95">#if</FONT> !defined(ostring) && !defined(OSTRING_DEFINED) <FONT color="#0f4b95">typedef</FONT> std::basic_string<OLECHAR> ostring; <FONT color="#0f4b95">#define</FONT> OSTRING_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef SS_ANSI</FONT> <FONT color="#008000">// StdCodeCvt when there's no conversion to be done</FONT> <FONT color="#0f4b95">inline</FONT> PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, <FONT color="#0f4b95">int</FONT> nChars) { pDst[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; std::char_traits<<FONT color="#0f4b95">char</FONT>>().copy(pDst, pSrc, nChars); <FONT color="#0f4b95">if</FONT> ( nChars > <FONT color="#a52a00">0</FONT> ) pDst[nChars] = <FONT color="#a52a00">'\0'</FONT>;

<FONT color="#0f4b95">return</FONT> pDst; } <FONT color="#0f4b95">inline</FONT> PSTR StdCodeCvt(PSTR pDst, PCUSTR pSrc, <FONT color="#0f4b95">int</FONT> nChars) { <FONT color="#0f4b95">return</FONT> StdCodeCvt(pDst, (PCSTR)pSrc, nChars); } <FONT color="#0f4b95">inline</FONT> PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, <FONT color="#0f4b95">int</FONT> nChars) { <FONT color="#0f4b95">return</FONT> (PUSTR)StdCodeCvt((PSTR)pDst, pSrc, nChars); }

<FONT color="#0f4b95">inline</FONT> PWSTR StdCodeCvt(PWSTR pDst, PCWSTR pSrc, <FONT color="#0f4b95">int</FONT> nChars) { pDst[<FONT color="#a52a00">0</FONT>] = <FONT color="#a52a00">'\0'</FONT>; std::char_traits<wchar_t>().copy(pDst, pSrc, nChars); <FONT color="#0f4b95">if</FONT> ( nChars > <FONT color="#a52a00">0</FONT> ) pDst[nChars] = <FONT color="#a52a00">'\0'</FONT>;

<FONT color="#0f4b95">return</FONT> pDst; }

<FONT color="#008000">// Define tstring -- generic name for std::basic_string<TCHAR></FONT> <FONT color="#0f4b95">#if</FONT> !defined(tstring) && !defined(TSTRING_DEFINED) <FONT color="#0f4b95">typedef</FONT> std::basic_string<TCHAR> tstring; <FONT color="#0f4b95">#define</FONT> TSTRING_DEFINED <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// a very shorthand way of applying the fix for KB problem Q172398</FONT> <FONT color="#008000">// (basic_string assignment bug)</FONT> <FONT color="#0f4b95">#if</FONT> defined ( _MSC_VER ) && ( _MSC_VER < <FONT color="#a52a00">1200</FONT> ) <FONT color="#0f4b95">#define</FONT> Q172398(x) (x).erase() <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> Q172398(x) <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// INLINE FUNCTIONS ON WHICH CSTDSTRING RELIES</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Usually for generic text mapping, we rely on preprocessor macro definitions</FONT> <FONT color="#008000">// to map to string functions. However the CStdStr<> template cannot use</FONT> <FONT color="#008000">// macro-based generic text mappings because its character types do not get</FONT> <FONT color="#008000">// resolved until template processing which comes AFTER macro processing. In</FONT> <FONT color="#008000">// other words, UNICODE is of little help to us in the CStdStr template</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Therefore, to keep the CStdStr declaration simple, we have these inline</FONT> <FONT color="#008000">// functions. The template calls them often. Since they are inline (and NOT</FONT> <FONT color="#008000">// exported when this is built as a DLL), they will probably be resolved away</FONT> <FONT color="#008000">// to nothing. </FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Without these functions, the CStdStr<> template would probably have to broken</FONT> <FONT color="#008000">// out into two, almost identical classes. Either that or it would be a huge,</FONT> <FONT color="#008000">// convoluted mess, with tons of "if" statements all over the place checking the</FONT> <FONT color="#008000">// size of template parameter CT.</FONT> <FONT color="#008000">// </FONT> <FONT color="#008000">// In several cases, you will see two versions of each function. One version is</FONT> <FONT color="#008000">// the more portable, standard way of doing things, while the other is the</FONT> <FONT color="#008000">// non-standard, but often significantly faster Visual C++ way.</FONT> <FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// If they defined SS_NO_REFCOUNT, then we must convert all assignments</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_NO_REFCOUNT <FONT color="#0f4b95">#define</FONT> SSREF(x) (x).c_str() <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> SSREF(x) (x) <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// sslen: strlen/wcslen wrappers</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sslen(<FONT color="#0f4b95">const</FONT> CT* pT) { <FONT color="#0f4b95">return</FONT> NULL == pT ? <FONT color="#a52a00">0</FONT> : std::char_traits<CT>::length(pT); } <FONT color="#0f4b95">inline</FONT> SS_NOTHROW <FONT color="#0f4b95">int</FONT> sslen(<FONT color="#0f4b95">const</FONT> std::string& s) { <FONT color="#0f4b95">return</FONT> s.length(); } <FONT color="#0f4b95">inline</FONT> SS_NOTHROW <FONT color="#0f4b95">int</FONT> sslen(<FONT color="#0f4b95">const</FONT> std::wstring& s) { <FONT color="#0f4b95">return</FONT> s.length(); }

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssasn: assignment functions -- assign "sSrc" to "sDst"</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">typedef</FONT> std::string::size_type SS_SIZETYPE; <FONT color="#008000">// just for shorthand, really</FONT> <FONT color="#0f4b95">typedef</FONT> std::string::pointer SS_PTRTYPE; <FONT color="#0f4b95">typedef</FONT> std::wstring::size_type SW_SIZETYPE; <FONT color="#0f4b95">typedef</FONT> std::wstring::pointer SW_PTRTYPE;

<FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::string& sDst, <FONT color="#0f4b95">const</FONT> std::string& sSrc) { <FONT color="#0f4b95">if</FONT> ( sDst.c_str() != sSrc.c_str() ) { sDst.erase(); sDst.assign(SSREF(sSrc)); } } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::string& sDst, PCSTR pA) { <FONT color="#008000">// Watch out for NULLs, as always.</FONT> <FONT color="#0f4b95">if</FONT> ( NULL == pA ) { sDst.erase(); }

<FONT color="#008000">// If pA actually points to part of sDst, we must NOT erase(), but</FONT> <FONT color="#008000">// rather take a substring</FONT> <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( pA >= sDst.c_str() && pA <= sDst.c_str() + sDst.size() ) { sDst =sDst.substr(static_cast<SS_SIZETYPE>(pA-sDst.c_str())); }

<FONT color="#008000">// Otherwise (most cases) apply the assignment bug fix, if applicable</FONT> <FONT color="#008000">// and do the assignment</FONT> <FONT color="#0f4b95">else</FONT> { Q172398(sDst); sDst.assign(pA); } } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::string& sDst, <FONT color="#0f4b95">const</FONT> std::wstring& sSrc) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sSrc.size(); sDst.resize(<FONT color="#a52a00">0</FONT>); sDst.resize(nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.assign(SSW2CA(sSrc.c_str())); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::string& sDst, PCWSTR pW) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sslen(pW); sDst.resize(<FONT color="#a52a00">0</FONT>); sDst.resize(nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), pW, nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.assign(pW ? SSW2CA(pW) : <FONT color="#a52a00">""</FONT>); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::string& sDst, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> nNull) { UNUSED(nNull); ASSERT(nNull==NULL); sDst.assign(<FONT color="#a52a00">""</FONT>); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::wstring& sDst, <FONT color="#0f4b95">const</FONT> std::wstring& sSrc) { <FONT color="#0f4b95">if</FONT> ( sDst.c_str() != sSrc.c_str() ) { sDst.erase(); sDst.assign(SSREF(sSrc)); } } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::wstring& sDst, PCWSTR pW) { <FONT color="#008000">// Watch out for NULLs, as always.</FONT> <FONT color="#0f4b95">if</FONT> ( NULL == pW ) { sDst.erase(); }

<FONT color="#008000">// If pW actually points to part of sDst, we must NOT erase(), but</FONT> <FONT color="#008000">// rather take a substring</FONT> <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( pW >= sDst.c_str() && pW <= sDst.c_str() + sDst.size() ) { sDst = sDst.substr(static_cast<SW_SIZETYPE>(pW-sDst.c_str())); }

<FONT color="#008000">// Otherwise (most cases) apply the assignment bug fix, if applicable</FONT> <FONT color="#008000">// and do the assignment</FONT> <FONT color="#0f4b95">else</FONT> { Q172398(sDst); sDst.assign(pW); } } <FONT color="#0f4b95">#undef</FONT> StrSizeType <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::wstring& sDst, <FONT color="#0f4b95">const</FONT> std::string& sSrc) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sSrc.size(); sDst.resize(<FONT color="#a52a00">0</FONT>); sDst.resize(nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.assign(SSA2CW(sSrc.c_str())); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::wstring& sDst, PCSTR pA) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sslen(pA); sDst.resize(<FONT color="#a52a00">0</FONT>); sDst.resize(nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), pA, nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.assign(pA ? SSA2CW(pA) : L<FONT color="#a52a00">""</FONT>); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssasn(std::wstring& sDst, <FONT color="#0f4b95">const</FONT> <FONT color="#0f4b95">int</FONT> nNull) { UNUSED(nNull); ASSERT(nNull==NULL); sDst.assign(L<FONT color="#a52a00">""</FONT>); }

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssadd: string object concatenation -- add second argument to first</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::string& sDst, <FONT color="#0f4b95">const</FONT> std::wstring& sSrc) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sSrc.size(); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.append(SSW2CA(sSrc.c_str())); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::string& sDst, <FONT color="#0f4b95">const</FONT> std::string& sSrc) { sDst.append(sSrc.c_str()); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::string& sDst, PCWSTR pW) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sslen(pW); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), pW, nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; <FONT color="#0f4b95">if</FONT> ( NULL != pW ) sDst.append(SSW2CA(pW)); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::string& sDst, PCSTR pA) { <FONT color="#0f4b95">if</FONT> ( pA ) sDst.append(pA); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::wstring& sDst, <FONT color="#0f4b95">const</FONT> std::wstring& sSrc) { sDst.append(sSrc.c_str()); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::wstring& sDst, <FONT color="#0f4b95">const</FONT> std::string& sSrc) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sSrc.size(); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; sDst.append(SSA2CW(sSrc.c_str())); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::wstring& sDst, PCSTR pA) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = sslen(pA); sDst.resize(sDst.size() + nLen); StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), pA, nLen); <FONT color="#0f4b95">#else</FONT> SSCVT; <FONT color="#0f4b95">if</FONT> ( NULL != pA ) sDst.append(SSA2CW(pA)); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssadd(std::wstring& sDst, PCWSTR pW) { <FONT color="#0f4b95">if</FONT> ( pW ) sDst.append(pW); }

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssicmp: comparison (case insensitive )</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssicmp(<FONT color="#0f4b95">const</FONT> CT* pA1, <FONT color="#0f4b95">const</FONT> CT* pA2) { std::locale loc; <FONT color="#0f4b95">const</FONT> std::ctype<CT>& ct = SS_USE_FACET(loc, std::ctype<CT>); CT f; CT l;

<FONT color="#0f4b95">do</FONT> { f = ct.tolower(*(pA1++)); l = ct.tolower(*(pA2++)); } <FONT color="#0f4b95">while</FONT> ( (f) && (f == l) );

<FONT color="#0f4b95">return</FONT> (<FONT color="#0f4b95">int</FONT>)(f - l); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MBCS <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> sscmp(PCSTR pA1, PCSTR pA2) { <FONT color="#0f4b95">return</FONT> _mbscmp((PCUSTR)pA1, (PCUSTR)pA2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> ssicmp(PCSTR pA1, PCSTR pA2) { <FONT color="#0f4b95">return</FONT> _mbsicmp((PCUSTR)pA1, (PCUSTR)pA2); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> sscmp(PCSTR pA1, PCSTR pA2) { <FONT color="#0f4b95">return</FONT> strcmp(pA1, pA2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> ssicmp(PCSTR pA1, PCSTR pA2) { <FONT color="#0f4b95">return</FONT> _stricmp(pA1, pA2); } <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> sscmp(PCWSTR pW1, PCWSTR pW2) { <FONT color="#0f4b95">return</FONT> wcscmp(pW1, pW2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">long</FONT> ssicmp(PCWSTR pW1, PCWSTR pW2) { <FONT color="#0f4b95">return</FONT> _wcsicmp(pW1, pW2); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssupr/sslwr: Uppercase/Lowercase conversion functions</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> sslwr(CT* pT, size_t nLen) { SS_USE_FACET(std::locale(), std::ctype<CT>).tolower(pT, pT+nLen); } <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssupr(CT* pT, size_t nLen) { SS_USE_FACET(std::locale(), std::ctype<CT>).toupper(pT, pT+nLen); } <FONT color="#0f4b95">#else</FONT> <FONT color="#008000">// #else we must be on Win32</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MBCS <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssupr(PSTR pA, size_t <FONT color="#008000">/*nLen*/</FONT>) { _mbsupr((PUSTR)pA); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> sslwr(PSTR pA, size_t <FONT color="#008000">/*nLen*/</FONT>) { _mbslwr((PUSTR)pA); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssupr(PSTR pA, size_t <FONT color="#008000">/*nLen*/</FONT>) { _strupr(pA); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> sslwr(PSTR pA, size_t <FONT color="#008000">/*nLen*/</FONT>) { _strlwr(pA); } <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> ssupr(PWSTR pW, size_t <FONT color="#008000">/*nLen*/</FONT>) { _wcsupr(pW); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">void</FONT> sslwr(PWSTR pW, size_t <FONT color="#008000">/*nLen*/</FONT>) { _wcslwr(pW); } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef SS_ANSI</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// vsprintf/vswprintf or _vsnprintf/_vsnwprintf equivalents. In standard</FONT> <FONT color="#008000">// builds we can't use _vsnprintf/_vsnwsprintf because they're MS extensions.</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssvsprintf(PSTR pA, size_t <FONT color="#008000">/*nCount*/</FONT>, PCSTR pFmtA, va_list vl) { <FONT color="#0f4b95">return</FONT> vsprintf(pA, pFmtA, vl); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { <FONT color="#0f4b95">#ifdef</FONT> __MWERKS__ <FONT color="#0f4b95">return</FONT> vswprintf(pW, nCount, pFmtW, vl); <FONT color="#0f4b95">#else</FONT> nCount; <FONT color="#0f4b95">return</FONT> vswprintf(pW, pFmtW, vl); <FONT color="#0f4b95">#endif</FONT> } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssvsprintf(PWSTR pW, PCWSTR pFmtW, va_list vl) { <FONT color="#0f4b95">return</FONT> vswprintf(pW, pFmtW, vl); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl) { <FONT color="#0f4b95">return</FONT> _vsnprintf(pA, nCount, pFmtA, vl); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssnprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { <FONT color="#0f4b95">return</FONT> _vsnwprintf(pW, nCount, pFmtW, vl); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssload: Type safe, overloaded ::LoadString wrappers</FONT> <FONT color="#008000">// There is no equivalent of these in non-Win32-specific builds. However, I'm</FONT> <FONT color="#008000">// thinking that with the message facet, there might eventually be one</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssload(HMODULE hInst, UINT uId, PSTR pBuf, <FONT color="#0f4b95">int</FONT> nMax) { <FONT color="#0f4b95">return</FONT> ::LoadStringA(hInst, uId, pBuf, nMax); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssload(HMODULE hInst, UINT uId, PWSTR pBuf, <FONT color="#0f4b95">int</FONT> nMax) { <FONT color="#0f4b95">return</FONT> ::LoadStringW(hInst, uId, pBuf, nMax); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// sscoll/ssicoll: Collation wrappers</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">template</FONT> <typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscoll(<FONT color="#0f4b95">const</FONT> CT* sz1, <FONT color="#0f4b95">int</FONT> nLen1, <FONT color="#0f4b95">const</FONT> CT* sz2, <FONT color="#0f4b95">int</FONT> nLen2) { <FONT color="#0f4b95">const</FONT> std::collate<CT>& coll = SS_USE_FACET(std::locale(), std::collate<CT>); <FONT color="#0f4b95">return</FONT> coll.compare(sz1, sz1+nLen1, sz2, sz2+nLen2); } <FONT color="#0f4b95">template</FONT> <typename CT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssicoll(<FONT color="#0f4b95">const</FONT> CT* sz1, <FONT color="#0f4b95">int</FONT> nLen1, <FONT color="#0f4b95">const</FONT> CT* sz2, <FONT color="#0f4b95">int</FONT> nLen2) { <FONT color="#0f4b95">const</FONT> std::locale loc; <FONT color="#0f4b95">const</FONT> std::collate<CT>& coll = SS_USE_FACET(loc, std::collate<CT>);

std::collate<CT>::string_type s1(sz1); std::collate<CT>::string_type s2(sz2);

sslwr(const_cast<CT*>(s1.c_str()), nLen1); sslwr(const_cast<CT*>(s2.c_str()), nLen2); <FONT color="#0f4b95">return</FONT> coll.compare(s1.c_str(), s1.c_str()+nLen1, s2.c_str(), s2.c_str()+nLen2); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MBCS <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscoll(PCSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> _mbscoll((PCUSTR)sz1, (PCUSTR)sz2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssicoll(PCSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> _mbsicoll((PCUSTR)sz1, (PCUSTR)sz2); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscoll(PCSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> strcoll(sz1, sz2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssicoll(PCSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> _stricoll(sz1, sz2); } <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscoll(PCWSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCWSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> wcscoll(sz1, sz2); } <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> ssicoll(PCWSTR sz1, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen1*/</FONT>, PCWSTR sz2, <FONT color="#0f4b95">int</FONT> <FONT color="#008000">/*nLen2*/</FONT>) { <FONT color="#0f4b95">return</FONT> _wcsicoll(sz1, sz2); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// ssfmtmsg: FormatMessage equivalents. Needed because I added a CString facade</FONT> <FONT color="#008000">// Again -- no equivalent of these on non-Win32 builds but their might one day</FONT> <FONT color="#008000">// be one if the message facet gets implemented</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PSTR pBuf, DWORD nSize, va_list* vlArgs) { <FONT color="#0f4b95">return</FONT> FormatMessageA(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } <FONT color="#0f4b95">inline</FONT> DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PWSTR pBuf, DWORD nSize, va_list* vlArgs) { <FONT color="#0f4b95">return</FONT> FormatMessageW(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// FUNCTION: sscpy. Copies up to 'nMax' characters from pSrc to pDst.</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: sscpy</FONT> <FONT color="#008000">// inline int sscpy(PSTR pDst, PCSTR pSrc, int nMax=-1);</FONT> <FONT color="#008000">// inline int sscpy(PUSTR pDst, PCSTR pSrc, int nMax=-1)</FONT> <FONT color="#008000">// inline int sscpy(PSTR pDst, PCWSTR pSrc, int nMax=-1);</FONT> <FONT color="#008000">// inline int sscpy(PWSTR pDst, PCWSTR pSrc, int nMax=-1);</FONT> <FONT color="#008000">// inline int sscpy(PWSTR pDst, PCSTR pSrc, int nMax=-1);</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// DESCRIPTION:</FONT> <FONT color="#008000">// This function is very much (but not exactly) like strcpy. These</FONT> <FONT color="#008000">// overloads simplify copying one C-style string into another by allowing</FONT> <FONT color="#008000">// the caller to specify two different types of strings if necessary.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// The strings must NOT overlap</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// "Character" is expressed in terms of the destination string, not</FONT> <FONT color="#008000">// the source. If no 'nMax' argument is supplied, then the number of</FONT> <FONT color="#008000">// characters copied will be sslen(pSrc). A NULL terminator will</FONT> <FONT color="#008000">// also be added so pDst must actually be big enough to hold nMax+1</FONT> <FONT color="#008000">// characters. The return value is the number of characters copied,</FONT> <FONT color="#008000">// not including the NULL terminator.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// PARAMETERS: </FONT> <FONT color="#008000">// pSrc - the string to be copied FROM. May be a char based string, an</FONT> <FONT color="#008000">// MBCS string (in Win32 builds) or a wide string (wchar_t).</FONT> <FONT color="#008000">// pSrc - the string to be copied TO. Also may be either MBCS or wide</FONT> <FONT color="#008000">// nMax - the maximum number of characters to be copied into szDest. Note</FONT> <FONT color="#008000">// that this is expressed in whatever a "character" means to pDst.</FONT> <FONT color="#008000">// If pDst is a wchar_t type string than this will be the maximum</FONT> <FONT color="#008000">// number of wchar_ts that my be copied. The pDst string must be</FONT> <FONT color="#008000">// large enough to hold least nMaxChars+1 characters.</FONT> <FONT color="#008000">// If the caller supplies no argument for nMax this is a signal to</FONT> <FONT color="#008000">// the routine to copy all the characters in pSrc, regardless of</FONT> <FONT color="#008000">// how long it is.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// RETURN VALUE: none</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpycvt(CT1* pDst, <FONT color="#0f4b95">const</FONT> CT2* pSrc, <FONT color="#0f4b95">int</FONT> nChars) { StdCodeCvt(pDst, pSrc, nChars); pDst[SSMAX(nChars, <FONT color="#a52a00">0</FONT>)] = <FONT color="#a52a00">'\0'</FONT>; <FONT color="#0f4b95">return</FONT> nChars; }

<FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpy(CT1* pDst, <FONT color="#0f4b95">const</FONT> CT2* pSrc, <FONT color="#0f4b95">int</FONT> nMax, <FONT color="#0f4b95">int</FONT> nLen) { <FONT color="#0f4b95">return</FONT> sscpycvt(pDst, pSrc, SSMIN(nMax, nLen)); } <FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpy(CT1* pDst, <FONT color="#0f4b95">const</FONT> CT2* pSrc, <FONT color="#0f4b95">int</FONT> nMax) { <FONT color="#0f4b95">return</FONT> sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc))); } <FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpy(CT1* pDst, <FONT color="#0f4b95">const</FONT> CT2* pSrc) { <FONT color="#0f4b95">return</FONT> sscpycvt(pDst, pSrc, sslen(pSrc)); } <FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpy(CT1* pDst, <FONT color="#0f4b95">const</FONT> std::basic_string<CT2>& sSrc, <FONT color="#0f4b95">int</FONT> nMax) { <FONT color="#0f4b95">return</FONT> sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (<FONT color="#0f4b95">int</FONT>)sSrc.length())); } <FONT color="#0f4b95">template</FONT><typename CT1, typename CT2> <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">int</FONT> sscpy(CT1* pDst, <FONT color="#0f4b95">const</FONT> std::basic_string<CT2>& sSrc) { <FONT color="#0f4b95">return</FONT> sscpycvt(pDst, sSrc.c_str(), (<FONT color="#0f4b95">int</FONT>)sSrc.length()); }





<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// Functional objects for changing case. They also let you pass locales</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">struct</FONT> SSToUpper : <FONT color="#0f4b95">public</FONT> std::binary_function<CT, std::locale, CT> { <FONT color="#0f4b95">inline</FONT> CT <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CT& t, <FONT color="#0f4b95">const</FONT> std::locale& loc) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> std::toupper<CT>(t, loc); } }; <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">struct</FONT> SSToLower : <FONT color="#0f4b95">public</FONT> std::binary_function<CT, std::locale, CT> { <FONT color="#0f4b95">inline</FONT> CT <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CT& t, <FONT color="#0f4b95">const</FONT> std::locale& loc) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> std::tolower<CT>(t, loc); } }; <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// struct SSSHDR - useful for non Std C++ persistence schemes.</FONT> <FONT color="#0f4b95">typedef</FONT> <FONT color="#0f4b95">struct</FONT> SSSHDR { BYTE byCtrl; ULONG nChars; } SSSHDR; <FONT color="#008000">// as in "Standard String Stream Header"</FONT> <FONT color="#008000">// This struct is used for TrimRight() and TrimLeft() function implementations.</FONT> <FONT color="#008000">//template<typename CT></FONT> <FONT color="#008000">//struct NotSpace : public std::unary_function<CT, bool></FONT> <FONT color="#008000">//{</FONT> <FONT color="#008000">// const std::locale& loc;</FONT> <FONT color="#008000">// inline NotSpace(const std::locale& locArg) : loc(locArg) {}</FONT> <FONT color="#008000">// inline bool operator() (CT t) { return !std::isspace(t, loc); }</FONT> <FONT color="#008000">//};</FONT> <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">struct</FONT> NotSpace : <FONT color="#0f4b95">public</FONT> std::unary_function<CT, <FONT color="#0f4b95">bool</FONT>> { <FONT color="#0f4b95">const</FONT> std::locale& loc; NotSpace(<FONT color="#0f4b95">const</FONT> std::locale& locArg) : loc(locArg) {}

<FONT color="#008000">// DINKUMWARE BUG:</FONT> <FONT color="#008000">// Note -- using std::isspace in a COM DLL gives us access violations</FONT> <FONT color="#008000">// because it causes the dynamic addition of a function to be called</FONT> <FONT color="#008000">// when the library shuts down. Unfortunately the list is maintained</FONT> <FONT color="#008000">// in DLL memory but the function is in static memory. So the COM DLL</FONT> <FONT color="#008000">// goes away along with the function that was supposed to be called,</FONT> <FONT color="#008000">// and then later when the DLL CRT shuts down it unloads the list and</FONT> <FONT color="#008000">// tries to call the long-gone function.</FONT> <FONT color="#008000">// This is DinkumWare's implementation problem. Until then, we will</FONT> <FONT color="#008000">// use good old isspace and iswspace from the CRT unless they</FONT> <FONT color="#008000">// specify SS_ANSI</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>() <FONT color="#0f4b95">const</FONT> (CT t) { <FONT color="#0f4b95">return</FONT> !std::isspace(t, loc); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">bool</FONT> ssisp(<FONT color="#0f4b95">char</FONT> c) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> FALSE != ::isspace((<FONT color="#0f4b95">int</FONT>) c); } <FONT color="#0f4b95">bool</FONT> ssisp(wchar_t c) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> FALSE != ::iswspace((wint_t) c); } <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>()(CT t) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> !ssisp(t); } <FONT color="#0f4b95">#endif</FONT> };



<FONT color="#008000">// Now we can define the template (finally!)</FONT> <FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// TEMPLATE: CStdStr</FONT> <FONT color="#008000">// template<typename CT> class CStdStr : public std::basic_string<CT></FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// This template derives from basic_string<CT> and adds some MFC CString-</FONT> <FONT color="#008000">// like functionality</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Basically, this is my attempt to make Standard C++ library strings as</FONT> <FONT color="#008000">// easy to use as the MFC CString class.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Note that although this is a template, it makes the assumption that the</FONT> <FONT color="#008000">// template argument (CT, the character type) is either char or wchar_t. </FONT> <FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">//#define CStdStr _SS // avoid compiler warning 4786</FONT>

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">class</FONT> CStdStr : <FONT color="#0f4b95">public</FONT> std::basic_string<CT> { <FONT color="#008000">// Typedefs for shorter names. Using these names also appears to help</FONT> <FONT color="#008000">// us avoid some ambiguities that otherwise arise on some platforms</FONT> <FONT color="#0f4b95">typedef</FONT> typename std::basic_string<CT> MYBASE; <FONT color="#008000">// my base class</FONT> <FONT color="#0f4b95">typedef</FONT> CStdStr<CT> MYTYPE; <FONT color="#008000">// myself</FONT> <FONT color="#0f4b95">typedef</FONT> typename MYBASE::const_pointer PCMYSTR; <FONT color="#008000">// PCSTR or PCWSTR </FONT> <FONT color="#0f4b95">typedef</FONT> typename MYBASE::pointer PMYSTR; <FONT color="#008000">// PSTR or PWSTR</FONT> <FONT color="#0f4b95">typedef</FONT> typename MYBASE::iterator MYITER; <FONT color="#008000">// my iterator type</FONT> <FONT color="#0f4b95">typedef</FONT> typename MYBASE::const_iterator MYCITER; <FONT color="#008000">// you get the idea...</FONT> <FONT color="#0f4b95">typedef</FONT> typename MYBASE::size_type MYSIZE; <FONT color="#0f4b95">typedef</FONT> typename MYBASE::value_type MYVAL; <FONT color="#0f4b95">typedef</FONT> typename MYBASE::allocator_type MYALLOC;

<FONT color="#0f4b95">public</FONT>:

<FONT color="#008000">// shorthand conversion from PCTSTR to string resource ID</FONT> <FONT color="#0f4b95">#define</FONT> _TRES(pctstr) (LOWORD((DWORD)(pctstr)))

<FONT color="#008000">// CStdStr inline constructors</FONT> CStdStr() { }

CStdStr(<FONT color="#0f4b95">const</FONT> MYTYPE& str) : MYBASE(SSREF(str)) { }

CStdStr(<FONT color="#0f4b95">const</FONT> std::string& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, SSREF(str)); }

CStdStr(<FONT color="#0f4b95">const</FONT> std::wstring& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, SSREF(str)); }

CStdStr(PCMYSTR pT, MYSIZE n) : MYBASE(pT, n) { }

CStdStr(PCSTR pA) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI *<FONT color="#0f4b95">this</FONT> = pA; <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">if</FONT> ( NULL != HIWORD(pA) ) *<FONT color="#0f4b95">this</FONT> = pA; <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( NULL != pA && !Load(_TRES(pA)) ) TRACE(_T(<FONT color="#a52a00">"Can't load string %u\n"</FONT>), _TRES(pA)); <FONT color="#0f4b95">#endif</FONT> }

CStdStr(PCWSTR pW) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI *<FONT color="#0f4b95">this</FONT> = pW; <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">if</FONT> ( NULL != HIWORD(pW) ) *<FONT color="#0f4b95">this</FONT> = pW; <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( NULL != pW && !Load(_TRES(pW)) ) TRACE(_T(<FONT color="#a52a00">"Can't load string %u\n"</FONT>), _TRES(pW)); <FONT color="#0f4b95">#endif</FONT> }

CStdStr(MYCITER first, MYCITER last) : MYBASE(first, last) { }

CStdStr(MYSIZE nSize, MYVAL ch, <FONT color="#0f4b95">const</FONT> MYALLOC& al=MYALLOC()) : MYBASE(nSize, ch, al) { }

<FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF CStdStr(<FONT color="#0f4b95">const</FONT> _bstr_t& bstr) { *<FONT color="#0f4b95">this</FONT> = static_cast<PCTSTR>(bstr); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// CStdStr inline assignment operators -- the ssasn function now takes care</FONT> <FONT color="#008000">// of fixing the MSVC assignment bug (see knowledge base article Q172398).</FONT> MYTYPE& <FONT color="#0f4b95">operator</FONT>=(<FONT color="#0f4b95">const</FONT> MYTYPE& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>=(<FONT color="#0f4b95">const</FONT> std::string& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>=(<FONT color="#0f4b95">const</FONT> std::wstring& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>=(PCSTR pA) { ssasn(*<FONT color="#0f4b95">this</FONT>, pA); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>=(PCWSTR pW) { ssasn(*<FONT color="#0f4b95">this</FONT>, pW); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>=(CT t) { Q172398(*<FONT color="#0f4b95">this</FONT>); MYBASE::assign(<FONT color="#a52a00">1</FONT>, t); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

<FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF MYTYPE& <FONT color="#0f4b95">operator</FONT>=(<FONT color="#0f4b95">const</FONT> _bstr_t& bstr) { <FONT color="#0f4b95">return</FONT> <FONT color="#0f4b95">operator</FONT>=(static_cast<<FONT color="#0f4b95">const</FONT> CT*>(bstr)); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Overloads also needed to fix the MSVC assignment bug (KB: Q172398)</FONT> <FONT color="#008000">// *** Thanks to Pete The Plumber for catching this one ***</FONT> <FONT color="#008000">// They also are compiled if you have explicitly turned off refcounting</FONT> <FONT color="#0f4b95">#if</FONT> ( defined(_MSC_VER) && ( _MSC_VER < <FONT color="#a52a00">1200</FONT> ) ) || defined(SS_NO_REFCOUNT)

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> MYTYPE& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> MYTYPE& str, MYSIZE nStart, MYSIZE nChars) { <FONT color="#008000">// This overload of basic_string::assign is supposed to assign up to</FONT> <FONT color="#008000">// <nChars> or the NULL terminator, whichever comes first. Since we</FONT> <FONT color="#008000">// are about to call a less forgiving overload (in which <nChars></FONT> <FONT color="#008000">// must be a valid length), we must adjust the length here to a safe</FONT> <FONT color="#008000">// value. Thanks to Ullrich Pollähne for catching this bug</FONT> nChars = SSMIN(nChars, str.length() - nStart);

<FONT color="#008000">// Watch out for assignment to self</FONT> <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">this</FONT> == &str ) { MYTYPE strTemp(str.c_str()+nStart, nChars); assign(strTemp); } <FONT color="#0f4b95">else</FONT> { Q172398(*<FONT color="#0f4b95">this</FONT>); MYBASE::assign(str.c_str()+nStart, nChars); } <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> MYBASE& str) { ssasn(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> MYBASE& str, MYSIZE nStart, MYSIZE nChars) { <FONT color="#008000">// This overload of basic_string::assign is supposed to assign up to</FONT> <FONT color="#008000">// <nChars> or the NULL terminator, whichever comes first. Since we</FONT> <FONT color="#008000">// are about to call a less forgiving overload (in which <nChars></FONT> <FONT color="#008000">// must be a valid length), we must adjust the length here to a safe</FONT> <FONT color="#008000">// value. Thanks to Ullrich Pollähne for catching this bug</FONT> nChars = SSMIN(nChars, str.length() - nStart);

<FONT color="#008000">// Watch out for assignment to self</FONT> <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">this</FONT> == &str ) <FONT color="#008000">// watch out for assignment to self</FONT> { MYTYPE strTemp(str.c_str() + nStart, nChars); assign(strTemp); } <FONT color="#0f4b95">else</FONT> { Q172398(*<FONT color="#0f4b95">this</FONT>); MYBASE::assign(str.c_str()+nStart, nChars); } <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> CT* pC, MYSIZE nChars) { <FONT color="#008000">// Q172398 only fix -- erase before assigning, but not if we're</FONT> <FONT color="#008000">// assigning from our own buffer</FONT> <FONT color="#0f4b95">#if</FONT> defined ( _MSC_VER ) && ( _MSC_VER < <FONT color="#a52a00">1200</FONT> ) <FONT color="#0f4b95">if</FONT> ( !empty() && ( pC < data() || pC > data() + capacity() ) ) erase(); <FONT color="#0f4b95">#endif</FONT> Q172398(*<FONT color="#0f4b95">this</FONT>); MYBASE::assign(pC, nChars); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(MYSIZE nChars, MYVAL val) { Q172398(*<FONT color="#0f4b95">this</FONT>); MYBASE::assign(nChars, val); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& assign(<FONT color="#0f4b95">const</FONT> CT* pT) { <FONT color="#0f4b95">return</FONT> assign(pT, CStdStr::traits_type::length(pT)); }

MYTYPE& assign(MYCITER iterFirst, MYCITER iterLast) { <FONT color="#0f4b95">#if</FONT> defined ( _MSC_VER ) && ( _MSC_VER < <FONT color="#a52a00">1200</FONT> ) <FONT color="#008000">// Q172398 fix. don't call erase() if we're assigning from ourself</FONT> <FONT color="#0f4b95">if</FONT> ( iterFirst < begin() || iterFirst > begin() + size() ) erase() <FONT color="#0f4b95">#endif</FONT> replace(begin(), end(), iterFirst, iterLast); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// CStdStr inline concatenation.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(<FONT color="#0f4b95">const</FONT> MYTYPE& str) { ssadd(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(<FONT color="#0f4b95">const</FONT> std::string& str) { ssadd(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(<FONT color="#0f4b95">const</FONT> std::wstring& str) { ssadd(*<FONT color="#0f4b95">this</FONT>, str); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(PCSTR pA) { ssadd(*<FONT color="#0f4b95">this</FONT>, pA); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(PCWSTR pW) { ssadd(*<FONT color="#0f4b95">this</FONT>, pW); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(CT t) { append(<FONT color="#a52a00">1</FONT>, t); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; } <FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF <FONT color="#008000">// if we have _bstr_t, define a += for it too.</FONT> MYTYPE& <FONT color="#0f4b95">operator</FONT>+=(<FONT color="#0f4b95">const</FONT> _bstr_t& bstr) { <FONT color="#0f4b95">return</FONT> <FONT color="#0f4b95">operator</FONT>+=(static_cast<PCMYSTR>(bstr)); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// addition operators -- global friend functions.</FONT> <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> MYTYPE& str1, <FONT color="#0f4b95">const</FONT> MYTYPE& str2); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> MYTYPE& str, CT t); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> MYTYPE& str, PCSTR sz); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> MYTYPE& str, PCWSTR sz); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(PCSTR pA, <FONT color="#0f4b95">const</FONT> MYTYPE& str); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(PCWSTR pW, <FONT color="#0f4b95">const</FONT> MYTYPE& str); <FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> _bstr_t& bstr, <FONT color="#0f4b95">const</FONT> MYTYPE& str); <FONT color="#0f4b95">friend</FONT> MYTYPE <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> MYTYPE& str, <FONT color="#0f4b95">const</FONT> _bstr_t& bstr); <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// Case changing functions</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> MYTYPE& ToUpper() { <FONT color="#008000">// Strictly speaking, this would be about the most portable way</FONT> <FONT color="#008000">// std::transform(begin(),</FONT> <FONT color="#008000">// end(),</FONT> <FONT color="#008000">// begin(),</FONT> <FONT color="#008000">// std::bind2nd(SSToUpper<CT>(), std::locale()));</FONT> <FONT color="#008000">// But practically speaking, this works faster</FONT> <FONT color="#0f4b95">if</FONT> ( !empty() ) ssupr(GetBuf(), size());

<FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }



MYTYPE& ToLower() { <FONT color="#008000">// Strictly speaking, this would be about the most portable way</FONT> <FONT color="#008000">// std::transform(begin(),</FONT> <FONT color="#008000">// end(),</FONT> <FONT color="#008000">// begin(),</FONT> <FONT color="#008000">// std::bind2nd(SSToLower<CT>(), std::locale()));</FONT> <FONT color="#008000">// But practically speaking, this works faster</FONT> <FONT color="#0f4b95">if</FONT> ( !empty() ) sslwr(GetBuf(), size());

<FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }



MYTYPE& Normalize() { <FONT color="#0f4b95">return</FONT> Trim().ToLower(); }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// CStdStr -- Direct access to character buffer. In the MS' implementation,</FONT> <FONT color="#008000">// the at() function that we use here also calls _Freeze() providing us some</FONT> <FONT color="#008000">// protection from multithreading problems associated with ref-counting.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> CT* GetBuf(<FONT color="#0f4b95">int</FONT> nMinLen=-<FONT color="#a52a00">1</FONT>) { <FONT color="#0f4b95">if</FONT> ( static_cast<<FONT color="#0f4b95">int</FONT>>(size()) < nMinLen ) resize(static_cast<MYSIZE>(nMinLen));

<FONT color="#0f4b95">return</FONT> empty() ? const_cast<CT*>(data()) : &(at(<FONT color="#a52a00">0</FONT>)); }

CT* SetBuf(<FONT color="#0f4b95">int</FONT> nLen) { nLen = ( nLen > <FONT color="#a52a00">0</FONT> ? nLen : <FONT color="#a52a00">0</FONT> ); <FONT color="#0f4b95">if</FONT> ( capacity() < <FONT color="#a52a00">1</FONT> && nLen == <FONT color="#a52a00">0</FONT> ) resize(<FONT color="#a52a00">1</FONT>);

resize(static_cast<MYSIZE>(nLen)); <FONT color="#0f4b95">return</FONT> const_cast<CT*>(data()); } <FONT color="#0f4b95">void</FONT> RelBuf(<FONT color="#0f4b95">int</FONT> nNewLen=-<FONT color="#a52a00">1</FONT>) { resize(static_cast<MYSIZE>(nNewLen > -<FONT color="#a52a00">1</FONT> ? nNewLen : sslen(c_str()))); }

<FONT color="#0f4b95">void</FONT> BufferRel() { RelBuf(); } <FONT color="#008000">// backwards compatability</FONT> CT* Buffer() { <FONT color="#0f4b95">return</FONT> GetBuf(); } <FONT color="#008000">// backwards compatability</FONT> CT* BufferSet(<FONT color="#0f4b95">int</FONT> nLen) { <FONT color="#0f4b95">return</FONT> SetBuf(nLen);}<FONT color="#008000">// backwards compatability</FONT> <FONT color="#0f4b95">bool</FONT> Equals(<FONT color="#0f4b95">const</FONT> CT* pT, <FONT color="#0f4b95">bool</FONT> bUseCase=false) <FONT color="#0f4b95">const</FONT> { <FONT color="#008000">// get copy, THEN compare (thread safe)</FONT> <FONT color="#0f4b95">return</FONT> bUseCase ? compare(pT) == <FONT color="#a52a00">0</FONT> : ssicmp(MYTYPE(*<FONT color="#0f4b95">this</FONT>), pT) == <FONT color="#a52a00">0</FONT>; }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: CStdStr::Load</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// Loads string from resource specified by nID</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// PARAMETERS:</FONT> <FONT color="#008000">// nID - resource Identifier. Purely a Win32 thing in this case</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// RETURN VALUE:</FONT> <FONT color="#008000">// true if successful, false otherwise</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifndef</FONT> SS_ANSI <FONT color="#0f4b95">bool</FONT> Load(UINT nId, HMODULE hModule=NULL) { <FONT color="#0f4b95">bool</FONT> bLoaded = false; <FONT color="#008000">// set to true of we succeed.</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MFC_VER <FONT color="#008000">// When in Rome...</FONT> CString strRes; bLoaded = FALSE != strRes.LoadString(nId); <FONT color="#0f4b95">if</FONT> ( bLoaded ) *<FONT color="#0f4b95">this</FONT> = strRes;

<FONT color="#0f4b95">#else</FONT> <FONT color="#008000">// Get the resource name and module handle</FONT> <FONT color="#0f4b95">if</FONT> ( NULL == hModule ) hModule = GetResourceHandle();

PCTSTR szName = MAKEINTRESOURCE((nId>><FONT color="#a52a00">4</FONT>)+<FONT color="#a52a00">1</FONT>); <FONT color="#008000">// lifted </FONT> DWORD dwSize = <FONT color="#a52a00">0</FONT>;

<FONT color="#008000">// No sense continuing if we can't find the resource</FONT> HRSRC hrsrc = ::<FONT color="#0f4b95">FindResource</FONT>(hModule, szName, RT_STRING);

<FONT color="#0f4b95">if</FONT> ( NULL == hrsrc ) TRACE(_T(<FONT color="#a52a00">"Cannot find resource %d: 0x%X"</FONT>), nId, ::GetLastError()); <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( <FONT color="#a52a00">0</FONT> == (dwSize = ::<FONT color="#0f4b95">SizeofResource</FONT>(hModule, hrsrc) / <FONT color="#0f4b95">sizeof</FONT>(CT))) TRACE(_T(<FONT color="#a52a00">"Cant get size of resource %d 0x%X\n"</FONT>),nId,GetLastError()); <FONT color="#0f4b95">else</FONT> { bLoaded = <FONT color="#a52a00">0</FONT> != ssload(hModule, nId, GetBuf(dwSize), dwSize); ReleaseBuffer(); }

<FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">if</FONT> ( !bLoaded ) TRACE(_T(<FONT color="#a52a00">"String not loaded 0x%X\n"</FONT>), ::GetLastError());

<FONT color="#0f4b95">return</FONT> bLoaded; } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: CStdStr::Format</FONT> <FONT color="#008000">// void _cdecl Formst(CStdStringA& PCSTR szFormat, ...)</FONT> <FONT color="#008000">// void _cdecl Format(PCSTR szFormat);</FONT> <FONT color="#008000">// </FONT> <FONT color="#008000">// DESCRIPTION:</FONT> <FONT color="#008000">// This function does sprintf/wsprintf style formatting on CStdStringA</FONT> <FONT color="#008000">// objects. It looks a lot like MFC's CString::Format. Some people</FONT> <FONT color="#008000">// might even call this identical. Fortunately, these people are now</FONT> <FONT color="#008000">// dead.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// PARAMETERS: </FONT> <FONT color="#008000">// nId - ID of string resource holding the format string</FONT> <FONT color="#008000">// szFormat - a PCSTR holding the format specifiers</FONT> <FONT color="#008000">// argList - a va_list holding the arguments for the format specifiers.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// RETURN VALUE: None.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// formatting (using wsprintf style formatting)</FONT> <FONT color="#0f4b95">#ifndef</FONT> SS_ANSI <FONT color="#0f4b95">void</FONT> Format(UINT nId, ...) { va_list argList; va_start(argList, nId); va_start(argList, nId);

MYTYPE strFmt; <FONT color="#0f4b95">if</FONT> ( strFmt.Load(nId) ) FormatV(strFmt, argList);

va_end(argList); } <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">void</FONT> Format(<FONT color="#0f4b95">const</FONT> CT* szFmt, ...) { va_list argList; va_start(argList, szFmt); FormatV(szFmt, argList); va_end(argList); } <FONT color="#0f4b95">void</FONT> AppendFormat(<FONT color="#0f4b95">const</FONT> CT* szFmt, ...) { va_list argList; va_start(argList, szFmt); AppendFormatV(szFmt, argList); va_end(argList); }

<FONT color="#0f4b95">#define</FONT> MAX_FMT_TRIES <FONT color="#a52a00">5</FONT> <FONT color="#008000">// #of times we try </FONT> <FONT color="#0f4b95">#define</FONT> FMT_BLOCK_SIZE <FONT color="#a52a00">2048</FONT> <FONT color="#008000">// # of bytes to increment per try</FONT> <FONT color="#0f4b95">#define</FONT> BUFSIZE_1ST <FONT color="#a52a00">256</FONT> <FONT color="#0f4b95">#define</FONT> BUFSIZE_2ND <FONT color="#a52a00">512</FONT> <FONT color="#0f4b95">#define</FONT> STD_BUF_SIZE <FONT color="#a52a00">1024</FONT>

<FONT color="#008000">// an efficient way to add formatted characters to the string. You may only</FONT> <FONT color="#008000">// add up to STD_BUF_SIZE characters at a time, though</FONT> <FONT color="#0f4b95">void</FONT> AppendFormatV(<FONT color="#0f4b95">const</FONT> CT* szFmt, va_list argList) { CT szBuf[STD_BUF_SIZE]; <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">int</FONT> nLen = ssvsprintf(szBuf, STD_BUF_SIZE-<FONT color="#a52a00">1</FONT>, szFmt, argList); <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">int</FONT> nLen = ssnprintf(szBuf, STD_BUF_SIZE-<FONT color="#a52a00">1</FONT>, szFmt, argList); <FONT color="#0f4b95">#endif</FONT> <FONT color="#0f4b95">if</FONT> ( <FONT color="#a52a00">0</FONT> < nLen ) append(szBuf, nLen); }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: FormatV</FONT> <FONT color="#008000">// void FormatV(PCSTR szFormat, va_list, argList);</FONT> <FONT color="#008000">// </FONT> <FONT color="#008000">// DESCRIPTION:</FONT> <FONT color="#008000">// This function formats the string with sprintf style format-specs. </FONT> <FONT color="#008000">// It makes a general guess at required buffer size and then tries</FONT> <FONT color="#008000">// successively larger buffers until it finds one big enough or a</FONT> <FONT color="#008000">// threshold (MAX_FMT_TRIES) is exceeded.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// PARAMETERS: </FONT> <FONT color="#008000">// szFormat - a PCSTR holding the format of the output</FONT> <FONT color="#008000">// argList - a Microsoft specific va_list for variable argument lists</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// RETURN VALUE: </FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">void</FONT> FormatV(<FONT color="#0f4b95">const</FONT> CT* szFormat, va_list argList) { <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI

<FONT color="#0f4b95">int</FONT> nLen = sslen(szFormat) + STD_BUF_SIZE; ssvsprintf(GetBuffer(nLen), nLen-<FONT color="#a52a00">1</FONT>, szFormat, argList); ReleaseBuffer();

<FONT color="#0f4b95">#else</FONT>

CT* pBuf = NULL; <FONT color="#0f4b95">int</FONT> nChars = <FONT color="#a52a00">1</FONT>; <FONT color="#0f4b95">int</FONT> nUsed = <FONT color="#a52a00">0</FONT>; size_type nActual = <FONT color="#a52a00">0</FONT>; <FONT color="#0f4b95">int</FONT> nTry = <FONT color="#a52a00">0</FONT>;

<FONT color="#0f4b95">do</FONT> { <FONT color="#008000">// Grow more than linearly (e.g. 512, 1536, 3072, etc)</FONT> nChars += (nTry+<FONT color="#a52a00">1</FONT> * FMT_BLOCK_SIZE); pBuf = reinterpret_cast<CT*>(_alloca(<FONT color="#0f4b95">sizeof</FONT>(CT)*nChars)); nUsed = ssnprintf(pBuf, nChars-<FONT color="#a52a00">1</FONT>, szFormat, argList);

<FONT color="#008000">// Ensure proper NULL termination.</FONT> nActual = nUsed == -<FONT color="#a52a00">1</FONT> ? nChars-<FONT color="#a52a00">1</FONT> : SSMIN(nUsed, nChars-<FONT color="#a52a00">1</FONT>); pBuf[nActual+<FONT color="#a52a00">1</FONT>]= <FONT color="#a52a00">'\0'</FONT>;

} <FONT color="#0f4b95">while</FONT> ( nUsed < <FONT color="#a52a00">0</FONT> && nTry++ < MAX_FMT_TRIES );

<FONT color="#008000">// assign whatever we managed to format</FONT> assign(pBuf, nActual);

<FONT color="#0f4b95">#endif</FONT> }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// CString Facade Functions:</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// The following methods are intended to allow you to use this class as a</FONT> <FONT color="#008000">// drop-in replacement for CString.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifndef</FONT> SS_ANSI BSTR AllocSysString() <FONT color="#0f4b95">const</FONT> { ostring os; ssasn(os, *<FONT color="#0f4b95">this</FONT>); <FONT color="#0f4b95">return</FONT> ::SysAllocString(os.c_str()); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">int</FONT> Collate(PCMYSTR szThat) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> sscoll(c_str(), length(), szThat, sslen(szThat)); }

<FONT color="#0f4b95">int</FONT> CollateNoCase(PCMYSTR szThat) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicoll(c_str(), length(), szThat, sslen(szThat)); }

<FONT color="#0f4b95">int</FONT> CompareNoCase(PCMYSTR szThat) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicmp(c_str(), szThat); }

<FONT color="#0f4b95">int</FONT> Delete(<FONT color="#0f4b95">int</FONT> nIdx, <FONT color="#0f4b95">int</FONT> nCount=<FONT color="#a52a00">1</FONT>) { <FONT color="#0f4b95">if</FONT> ( nIdx < GetLength() ) erase(static_cast<MYSIZE>(nIdx), static_cast<MYSIZE>(nCount));

<FONT color="#0f4b95">return</FONT> GetLength(); }

<FONT color="#0f4b95">void</FONT> Empty() { erase(); }

<FONT color="#0f4b95">int</FONT> Find(CT ch) <FONT color="#0f4b95">const</FONT> { MYSIZE nIdx = find_first_of(ch); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#0f4b95">int</FONT> Find(PCMYSTR szSub) <FONT color="#0f4b95">const</FONT> { MYSIZE nIdx = find(szSub); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#0f4b95">int</FONT> Find(CT ch, <FONT color="#0f4b95">int</FONT> nStart) <FONT color="#0f4b95">const</FONT> { <FONT color="#008000">// CString::Find docs say add 1 to nStart when it's not zero</FONT> <FONT color="#008000">// CString::Find code doesn't do that however. We'll stick</FONT> <FONT color="#008000">// with what the code does</FONT> MYSIZE nIdx = find_first_of(ch, static_cast<MYSIZE>(nStart)); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#0f4b95">int</FONT> Find(PCMYSTR szSub, <FONT color="#0f4b95">int</FONT> nStart) <FONT color="#0f4b95">const</FONT> { <FONT color="#008000">// CString::Find docs say add 1 to nStart when it's not zero</FONT> <FONT color="#008000">// CString::Find code doesn't do that however. We'll stick</FONT> <FONT color="#008000">// with what the code does</FONT> MYSIZE nIdx = find(szSub, static_cast<MYSIZE>(nStart)); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#0f4b95">int</FONT> FindOneOf(PCMYSTR szCharSet) <FONT color="#0f4b95">const</FONT> { MYSIZE nIdx = find_first_of(szCharSet); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#0f4b95">#ifndef</FONT> SS_ANSI <FONT color="#0f4b95">void</FONT> FormatMessage(PCMYSTR szFormat, ...) throw(std::exception) { va_list argList; va_start(argList, szFormat); PMYSTR szTemp; <FONT color="#0f4b95">if</FONT> ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, szFormat, <FONT color="#a52a00">0</FONT>, <FONT color="#a52a00">0</FONT>, reinterpret_cast<PMYSTR>(&szTemp), <FONT color="#a52a00">0</FONT>, &argList) == <FONT color="#a52a00">0</FONT> || szTemp == NULL ) { throw std::runtime_error(<FONT color="#a52a00">"out of memory"</FONT>); } *<FONT color="#0f4b95">this</FONT> = szTemp; <FONT color="#0f4b95">LocalFree</FONT>(szTemp); va_end(argList); }

<FONT color="#0f4b95">void</FONT> FormatMessage(UINT nFormatId, ...) throw(std::exception) { MYTYPE sFormat; VERIFY(sFormat.LoadString(nFormatId) != <FONT color="#a52a00">0</FONT>); va_list argList; va_start(argList, nFormatId); PMYSTR szTemp; <FONT color="#0f4b95">if</FONT> ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, sFormat, <FONT color="#a52a00">0</FONT>, <FONT color="#a52a00">0</FONT>, reinterpret_cast<PMYSTR>(&szTemp), <FONT color="#a52a00">0</FONT>, &argList) == <FONT color="#a52a00">0</FONT> || szTemp == NULL) { throw std::runtime_error(<FONT color="#a52a00">"out of memory"</FONT>); } *<FONT color="#0f4b95">this</FONT> = szTemp; <FONT color="#0f4b95">LocalFree</FONT>(szTemp); va_end(argList); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// GetXXXX -- Direct access to character buffer</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> CT GetAt(<FONT color="#0f4b95">int</FONT> nIdx) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> at(static_cast<MYSIZE>(nIdx)); }

CT* GetBuffer(<FONT color="#0f4b95">int</FONT> nMinLen=-<FONT color="#a52a00">1</FONT>) { <FONT color="#0f4b95">return</FONT> GetBuf(nMinLen); }

CT* GetBufferSetLength(<FONT color="#0f4b95">int</FONT> nLen) { <FONT color="#0f4b95">return</FONT> BufferSet(nLen); }

<FONT color="#008000">// GetLength() -- MFC docs say this is the # of BYTES but</FONT> <FONT color="#008000">// in truth it is the number of CHARACTERs (chars or wchar_ts)</FONT> <FONT color="#0f4b95">int</FONT> GetLength() <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(length()); }

<FONT color="#0f4b95">int</FONT> Insert(<FONT color="#0f4b95">int</FONT> nIdx, CT ch) { <FONT color="#0f4b95">if</FONT> ( static_cast<MYSIZE>(nIdx) > size() -<FONT color="#a52a00">1</FONT> ) append(<FONT color="#a52a00">1</FONT>, ch); <FONT color="#0f4b95">else</FONT> insert(static_cast<MYSIZE>(nIdx), <FONT color="#a52a00">1</FONT>, ch);

<FONT color="#0f4b95">return</FONT> GetLength(); }

<FONT color="#0f4b95">int</FONT> Insert(<FONT color="#0f4b95">int</FONT> nIdx, PCMYSTR sz) { insert(static_cast<MYSIZE>(nIdx), sz); <FONT color="#0f4b95">return</FONT> GetLength(); }

<FONT color="#0f4b95">bool</FONT> IsEmpty() <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> empty(); }

MYTYPE Left(<FONT color="#0f4b95">int</FONT> nCount) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> substr(<FONT color="#a52a00">0</FONT>, static_cast<MYSIZE>(nCount)); }

<FONT color="#0f4b95">#ifndef</FONT> SS_ANSI <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">LoadString</FONT>(UINT nId) { <FONT color="#0f4b95">return</FONT> <FONT color="#0f4b95">this</FONT>->Load(nId); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">void</FONT> MakeLower() { ToLower(); }

<FONT color="#0f4b95">void</FONT> MakeReverse() { std::reverse(begin(), end()); }

<FONT color="#0f4b95">void</FONT> MakeUpper() { ToUpper(); }

MYTYPE Mid(<FONT color="#0f4b95">int</FONT> nFirst ) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> substr(static_cast<MYSIZE>(nFirst)); }

MYTYPE Mid(<FONT color="#0f4b95">int</FONT> nFirst, <FONT color="#0f4b95">int</FONT> nCount) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> substr(static_cast<MYSIZE>(nFirst), static_cast<MYSIZE>(nCount)); }

<FONT color="#0f4b95">void</FONT> ReleaseBuffer(<FONT color="#0f4b95">int</FONT> nNewLen=-<FONT color="#a52a00">1</FONT>) { RelBuf(nNewLen); }

<FONT color="#0f4b95">int</FONT> Remove(CT ch) { MYSIZE nIdx = <FONT color="#a52a00">0</FONT>; <FONT color="#0f4b95">int</FONT> nRemoved = <FONT color="#a52a00">0</FONT>; <FONT color="#0f4b95">while</FONT> ( (nIdx=find_first_of(ch)) != npos ) { erase(nIdx, <FONT color="#a52a00">1</FONT>); nRemoved++; } <FONT color="#0f4b95">return</FONT> nRemoved; }

<FONT color="#0f4b95">int</FONT> Replace(CT chOld, CT chNew) { <FONT color="#0f4b95">int</FONT> nReplaced = <FONT color="#a52a00">0</FONT>; <FONT color="#0f4b95">for</FONT> ( MYITER iter=begin(); iter != end(); iter++ ) { <FONT color="#0f4b95">if</FONT> ( *iter == chOld ) { *iter = chNew; nReplaced++; } } <FONT color="#0f4b95">return</FONT> nReplaced; }

<FONT color="#0f4b95">int</FONT> Replace(PCMYSTR szOld, PCMYSTR szNew) { <FONT color="#0f4b95">int</FONT> nReplaced = <FONT color="#a52a00">0</FONT>; MYSIZE nIdx = <FONT color="#a52a00">0</FONT>; <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">const</FONT> CT _C = CT(<FONT color="#a52a00">0</FONT>); MYSIZE nOldLen = sslen(szOld); MYSIZE nNewLen = sslen(szNew); PCMYSTR szRealNew = szNew == NULL ? &_C : szNew; PCMYSTR szRealOld = szOld == NULL ? &_C : szOld; <FONT color="#0f4b95">while</FONT> ( (nIdx=find(szRealOld, nIdx)) != npos ) { replace(begin()+nIdx, begin()+nIdx+nOldLen, szRealNew); nReplaced++; nIdx += nNewLen; } <FONT color="#0f4b95">return</FONT> nReplaced; }

<FONT color="#0f4b95">int</FONT> ReverseFind(CT ch) <FONT color="#0f4b95">const</FONT> { MYSIZE nIdx = find_last_of(ch); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

<FONT color="#008000">// ReverseFind overload that's not in CString but might be useful</FONT> <FONT color="#0f4b95">int</FONT> ReverseFind(PCMYSTR szFind, size_type pos=npos) <FONT color="#0f4b95">const</FONT> { MYSIZE nIdx = rfind(NULL == szFind ? MYTYPE() : szFind, pos); <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">int</FONT>>(nIdx == npos ? -<FONT color="#a52a00">1</FONT> : nIdx); }

MYTYPE Right(<FONT color="#0f4b95">int</FONT> nCount) <FONT color="#0f4b95">const</FONT> { nCount = SSMIN(nCount, static_cast<<FONT color="#0f4b95">int</FONT>>(size())); <FONT color="#0f4b95">return</FONT> substr(size()-static_cast<MYSIZE>(nCount)); }

<FONT color="#0f4b95">void</FONT> SetAt(<FONT color="#0f4b95">int</FONT> nIndex, CT ch) { ASSERT(size() > static_cast<MYSIZE>(nIndex)); at(static_cast<MYSIZE>(nIndex)) = ch; }

<FONT color="#0f4b95">#ifndef</FONT> SS_ANSI BSTR SetSysString(BSTR* pbstr) <FONT color="#0f4b95">const</FONT> { ostring os; ssasn(os, *<FONT color="#0f4b95">this</FONT>); <FONT color="#0f4b95">if</FONT> ( !::SysReAllocStringLen(pbstr, os.c_str(), os.length()) ) throw std::runtime_error(<FONT color="#a52a00">"out of memory"</FONT>);

ASSERT(*pbstr != NULL); <FONT color="#0f4b95">return</FONT> *pbstr; } <FONT color="#0f4b95">#endif</FONT>

MYTYPE SpanExcluding(PCMYSTR szCharSet) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> Left(find_first_of(szCharSet)); }

MYTYPE SpanIncluding(PCMYSTR szCharSet) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> Left(find_first_not_of(szCharSet)); }

<FONT color="#0f4b95">#if</FONT> !defined(UNICODE) && !defined(SS_ANSI)

<FONT color="#008000">// CString's OemToAnsi and AnsiToOem functions are available only in</FONT> <FONT color="#008000">// Unicode builds. However since we're a template we also need a</FONT> <FONT color="#008000">// runtime check of CT and a reinterpret_cast to account for the fact</FONT> <FONT color="#008000">// that CStdStringW gets instantiated even in non-Unicode builds.</FONT> <FONT color="#0f4b95">void</FONT> <FONT color="#0f4b95">AnsiToOem</FONT>() { <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">sizeof</FONT>(CT) == <FONT color="#0f4b95">sizeof</FONT>(<FONT color="#0f4b95">char</FONT>) && !empty() ) { ::CharToOem(reinterpret_cast<PCSTR>(c_str()), reinterpret_cast<PSTR>(GetBuf())); } <FONT color="#0f4b95">else</FONT> { ASSERT(false); } }

<FONT color="#0f4b95">void</FONT> <FONT color="#0f4b95">OemToAnsi</FONT>() { <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">sizeof</FONT>(CT) == <FONT color="#0f4b95">sizeof</FONT>(<FONT color="#0f4b95">char</FONT>) && !empty() ) { ::OemToChar(reinterpret_cast<PCSTR>(c_str()), reinterpret_cast<PSTR>(GetBuf())); } <FONT color="#0f4b95">else</FONT> { ASSERT(false); } }

<FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// Trim and its variants</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> MYTYPE& Trim() { <FONT color="#0f4b95">return</FONT> TrimLeft().TrimRight(); }

MYTYPE& TrimLeft() { erase(begin(), std::find_if(begin(),end(),NotSpace<CT>(std::locale()))); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& TrimLeft(CT tTrim) { erase(<FONT color="#a52a00">0</FONT>, find_first_not_of(tTrim)); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& TrimLeft(PCMYSTR szTrimChars) { erase(<FONT color="#a52a00">0</FONT>, find_first_not_of(szTrimChars)); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& TrimRight() { std::locale loc; reverse_iterator it = std::find_if(rbegin(), rend(), NotSpace<CT>(loc)); <FONT color="#0f4b95">if</FONT> ( rend() != it ) erase(rend() - it);

erase(it != rend() ? find_last_of(*it) + <FONT color="#a52a00">1</FONT> : <FONT color="#a52a00">0</FONT>); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& TrimRight(CT tTrim) { MYSIZE nIdx = find_last_not_of(tTrim); erase(npos == nIdx ? <FONT color="#a52a00">0</FONT> : ++nIdx); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

MYTYPE& TrimRight(PCMYSTR szTrimChars) { MYSIZE nIdx = find_last_not_of(szTrimChars); erase(npos == nIdx ? <FONT color="#a52a00">0</FONT> : ++nIdx); <FONT color="#0f4b95">return</FONT> *<FONT color="#0f4b95">this</FONT>; }

<FONT color="#0f4b95">void</FONT> FreeExtra() { MYTYPE mt; swap(mt); <FONT color="#0f4b95">if</FONT> ( !mt.empty() ) assign(mt.c_str(), mt.size()); }

<FONT color="#008000">// I have intentionally not implemented the following CString</FONT> <FONT color="#008000">// functions. You cannot make them work without taking advantage</FONT> <FONT color="#008000">// of implementation specific behavior. However if you absolutely</FONT> <FONT color="#008000">// MUST have them, uncomment out these lines for "sort-of-like"</FONT> <FONT color="#008000">// their behavior. You're on your own.</FONT> <FONT color="#008000">// CT* LockBuffer() { return GetBuf(); }// won't really lock</FONT> <FONT color="#008000">// void UnlockBuffer(); { } // why have UnlockBuffer w/o LockBuffer?</FONT> <FONT color="#008000">// Array-indexing operators. Required because we defined an implicit cast</FONT> <FONT color="#008000">// to operator const CT* (Thanks to Julian Selman for pointing this out)</FONT> CT& <FONT color="#0f4b95">operator</FONT>[](<FONT color="#0f4b95">int</FONT> nIdx) { <FONT color="#0f4b95">return</FONT> MYBASE::<FONT color="#0f4b95">operator</FONT>[](static_cast<MYSIZE>(nIdx)); }

<FONT color="#0f4b95">const</FONT> CT& <FONT color="#0f4b95">operator</FONT>[](<FONT color="#0f4b95">int</FONT> nIdx) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> MYBASE::<FONT color="#0f4b95">operator</FONT>[](static_cast<MYSIZE>(nIdx)); }

CT& <FONT color="#0f4b95">operator</FONT>[](<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> nIdx) { <FONT color="#0f4b95">return</FONT> MYBASE::<FONT color="#0f4b95">operator</FONT>[](static_cast<MYSIZE>(nIdx)); }

<FONT color="#0f4b95">const</FONT> CT& <FONT color="#0f4b95">operator</FONT>[](<FONT color="#0f4b95">unsigned</FONT> <FONT color="#0f4b95">int</FONT> nIdx) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> MYBASE::<FONT color="#0f4b95">operator</FONT>[](static_cast<MYSIZE>(nIdx)); }

<FONT color="#0f4b95">operator</FONT> <FONT color="#0f4b95">const</FONT> CT*() <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> c_str(); }

<FONT color="#008000">// IStream related functions. Useful in IPersistStream implementations</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF

<FONT color="#0f4b95">#define</FONT> SSSO_UNICODE <FONT color="#a52a00">0x01</FONT> <FONT color="#008000">// the string is a wide string</FONT> <FONT color="#0f4b95">#define</FONT> SSSO_COMPRESS <FONT color="#a52a00">0x02</FONT> <FONT color="#008000">// the string is compressed</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: StreamSize</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// Returns how many bytes it will take to StreamSave() this CStdString</FONT> <FONT color="#008000">// object to an IStream.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> ULONG StreamSize() <FONT color="#0f4b95">const</FONT> { <FONT color="#008000">// Control header plus string</FONT> ASSERT(size()*<FONT color="#0f4b95">sizeof</FONT>(CT) < 0xffffffffUL - <FONT color="#0f4b95">sizeof</FONT>(SSSHDR)); <FONT color="#0f4b95">return</FONT> (size() * <FONT color="#0f4b95">sizeof</FONT>(CT)) + <FONT color="#0f4b95">sizeof</FONT>(SSSHDR); }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: StreamSave</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// Saves this CStdString object to a COM IStream.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> HRESULT StreamSave(IStream* pStream) <FONT color="#0f4b95">const</FONT> { ASSERT(size()*<FONT color="#0f4b95">sizeof</FONT>(CT) < 0xffffffffUL - <FONT color="#0f4b95">sizeof</FONT>(SSSHDR)); HRESULT hr = E_FAIL; ASSERT(pStream != NULL); SSSHDR hdr; hdr.byCtrl = <FONT color="#0f4b95">sizeof</FONT>(CT) == <FONT color="#a52a00">2</FONT> ? SSSO_UNICODE : <FONT color="#a52a00">0</FONT>; hdr.nChars = size();

<FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Write(&hdr, <FONT color="#0f4b95">sizeof</FONT>(SSSHDR), NULL)) ) TRACE(_T(<FONT color="#a52a00">"StreamSave: Cannot write control header, ERR=0x%X\n"</FONT>),hr); <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( empty() ) ; <FONT color="#008000">// nothing to write</FONT> <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Write(c_str(), size()*<FONT color="#0f4b95">sizeof</FONT>(CT), NULL)) ) TRACE(_T(<FONT color="#a52a00">"StreamSave: Cannot write string to stream 0x%X\n"</FONT>), hr);

<FONT color="#0f4b95">return</FONT> hr; }

<FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: StreamLoad</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// This method loads the object from an IStream.</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> HRESULT StreamLoad(IStream* pStream) { ASSERT(pStream != NULL); SSSHDR hdr; HRESULT hr = E_FAIL;

<FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Read(&hdr, <FONT color="#0f4b95">sizeof</FONT>(SSSHDR), NULL)) ) { TRACE(_T(<FONT color="#a52a00">"StreamLoad: Cant read control header, ERR=0x%X\n"</FONT>), hr); } <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">if</FONT> ( hdr.nChars > <FONT color="#a52a00">0</FONT> ) { ULONG nRead = <FONT color="#a52a00">0</FONT>; PMYSTR pMyBuf = BufferSet(hdr.nChars);

<FONT color="#008000">// If our character size matches the character size of the string</FONT> <FONT color="#008000">// we're trying to read, then we can read it directly into our</FONT> <FONT color="#008000">// buffer. Otherwise, we have to read into an intermediate buffer</FONT> <FONT color="#008000">// and convert.</FONT> <FONT color="#0f4b95">if</FONT> ( (hdr.byCtrl & SSSO_UNICODE) != <FONT color="#a52a00">0</FONT> ) { ULONG nBytes = hdr.nChars * <FONT color="#0f4b95">sizeof</FONT>(wchar_t); <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">sizeof</FONT>(CT) == <FONT color="#0f4b95">sizeof</FONT>(wchar_t) ) { <FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T(<FONT color="#a52a00">"StreamLoad: Cannot read string: 0x%X\n"</FONT>), hr); } <FONT color="#0f4b95">else</FONT> { PWSTR pBufW = reinterpret_cast<PWSTR>(_alloca((nBytes)+<FONT color="#a52a00">1</FONT>)); <FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Read(pBufW, nBytes, &nRead)) ) TRACE(_T(<FONT color="#a52a00">"StreamLoad: Cannot read string: 0x%X\n"</FONT>), hr); <FONT color="#0f4b95">else</FONT> sscpy(pMyBuf, pBufW, hdr.nChars*<FONT color="#0f4b95">sizeof</FONT>(wchar_t)); } } <FONT color="#0f4b95">else</FONT> { ULONG nBytes = hdr.nChars * <FONT color="#0f4b95">sizeof</FONT>(<FONT color="#0f4b95">char</FONT>); <FONT color="#0f4b95">if</FONT> ( <FONT color="#0f4b95">sizeof</FONT>(CT) == <FONT color="#0f4b95">sizeof</FONT>(<FONT color="#0f4b95">char</FONT>) ) { <FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T(<FONT color="#a52a00">"StreamLoad: Cannot read string: 0x%X\n"</FONT>), hr); } <FONT color="#0f4b95">else</FONT> { PSTR pBufA = reinterpret_cast<PSTR>(_alloca(nBytes)); <FONT color="#0f4b95">if</FONT> ( FAILED(hr=pStream->Read(pBufA, hdr.nChars, &nRead)) ) TRACE(_T(<FONT color="#a52a00">"StreamLoad: Cannot read string: 0x%X\n"</FONT>), hr); <FONT color="#0f4b95">else</FONT> sscpy(pMyBuf, pBufA, hdr.nChars); } } } <FONT color="#0f4b95">else</FONT> { <FONT color="#0f4b95">this</FONT>->erase(); } <FONT color="#0f4b95">return</FONT> hr; } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef SS_INC_COMDEF</FONT> <FONT color="#008000">// SetResourceHandle/GetResourceHandle. In MFC builds, these map directly</FONT> <FONT color="#008000">// to AfxSetResourceHandle and AfxGetResourceHandle. In non-MFC builds they</FONT> <FONT color="#008000">// point to a single static HINST so that those who call the member</FONT> <FONT color="#008000">// functions that take resource IDs can provide an alternate HINST of a DLL</FONT> <FONT color="#008000">// to search. This is not exactly the list of HMODULES that MFC provides</FONT> <FONT color="#008000">// but it's better than nothing.</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MFC_VER <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">void</FONT> SetResourceHandle(HMODULE hNew) { AfxSetResourceHandle(hNew); } <FONT color="#0f4b95">static</FONT> HMODULE GetResourceHandle() { <FONT color="#0f4b95">return</FONT> AfxGetResourceHandle(); } <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">static</FONT> <FONT color="#0f4b95">void</FONT> SetResourceHandle(HMODULE hNew) { SSResourceHandle() = hNew; } <FONT color="#0f4b95">static</FONT> HMODULE GetResourceHandle() { <FONT color="#0f4b95">return</FONT> SSResourceHandle(); } <FONT color="#0f4b95">#endif</FONT> };



<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// CStdStr friend addition functions defined as inline</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> CStdStr<CT>& str1, <FONT color="#0f4b95">const</FONT> CStdStr<CT>& str2) { CStdStr<CT> strRet(SSREF(str1)); strRet.append(str2); <FONT color="#0f4b95">return</FONT> strRet; }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> CStdStr<CT>& str, CT t) { <FONT color="#008000">// this particular overload is needed for disabling reference counting</FONT> <FONT color="#008000">// though it's only an issue from line 1 to line 2</FONT> CStdStr<CT> strRet(SSREF(str)); <FONT color="#008000">// 1</FONT> strRet.append(<FONT color="#a52a00">1</FONT>, t); <FONT color="#008000">// 2</FONT> <FONT color="#0f4b95">return</FONT> strRet; }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> CStdStr<CT>& str, PCSTR pA) { <FONT color="#0f4b95">return</FONT> CStdStr<CT>(str) + CStdStr<CT>(pA); }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(PCSTR pA, <FONT color="#0f4b95">const</FONT> CStdStr<CT>& str) { CStdStr<CT> strRet(pA); strRet.append(str); <FONT color="#0f4b95">return</FONT> strRet; }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> CStdStr<CT>& str, PCWSTR pW) { <FONT color="#0f4b95">return</FONT> CStdStr<CT>(SSREF(str)) + CStdStr<CT>(pW); }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(PCWSTR pW, <FONT color="#0f4b95">const</FONT> CStdStr<CT>& str) { CStdStr<CT> strRet(pW); strRet.append(str); <FONT color="#0f4b95">return</FONT> strRet; }

<FONT color="#0f4b95">#ifdef</FONT> SS_INC_COMDEF <FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> _bstr_t& bstr, <FONT color="#0f4b95">const</FONT> CStdStr<CT>& str) { <FONT color="#0f4b95">return</FONT> static_cast<<FONT color="#0f4b95">const</FONT> CT*>(bstr) + str; }

<FONT color="#0f4b95">template</FONT><typename CT> <FONT color="#0f4b95">inline</FONT> CStdStr<CT> <FONT color="#0f4b95">operator</FONT>+(<FONT color="#0f4b95">const</FONT> CStdStr<CT>& str, <FONT color="#0f4b95">const</FONT> _bstr_t& bstr) { <FONT color="#0f4b95">return</FONT> str + static_cast<<FONT color="#0f4b95">const</FONT> CT*>(bstr); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// END OF CStdStr INLINE FUNCTION DEFINITIONS</FONT> <FONT color="#008000">// =============================================================================</FONT> <FONT color="#008000">// Now typedef our class names based upon this humongous template</FONT> <FONT color="#0f4b95">typedef</FONT> CStdStr<<FONT color="#0f4b95">char</FONT>> CStdStringA; <FONT color="#008000">// a better std::string</FONT> <FONT color="#0f4b95">typedef</FONT> CStdStr<wchar_t> CStdStringW; <FONT color="#008000">// a better std::wstring</FONT> <FONT color="#0f4b95">typedef</FONT> CStdStr<OLECHAR> CStdStringO; <FONT color="#008000">// almost always CStdStringW</FONT> <FONT color="#008000">// SSResourceHandle: our MFC-like resource handle</FONT> <FONT color="#0f4b95">inline</FONT> HMODULE& SSResourceHandle() { <FONT color="#0f4b95">static</FONT> HMODULE hModuleSS = <FONT color="#0f4b95">GetModuleHandle</FONT>(NULL); <FONT color="#0f4b95">return</FONT> hModuleSS; }

<FONT color="#008000">// In MFC builds, define some global serialization operators</FONT> <FONT color="#008000">// Special operators that allow us to serialize CStdStrings to CArchives.</FONT> <FONT color="#008000">// Note that we use an intermediate CString object in order to ensure that</FONT> <FONT color="#008000">// we use the exact same format.</FONT> <FONT color="#0f4b95">#ifdef</FONT> _MFC_VER <FONT color="#0f4b95">inline</FONT> CArchive& AFXAPI <FONT color="#0f4b95">operator</FONT><<(CArchive& ar, <FONT color="#0f4b95">const</FONT> CStdStringA& strA) { CString strTemp = strA; <FONT color="#0f4b95">return</FONT> ar << strTemp; } <FONT color="#0f4b95">inline</FONT> CArchive& AFXAPI <FONT color="#0f4b95">operator</FONT><<(CArchive& ar, <FONT color="#0f4b95">const</FONT> CStdStringW& strW) { CString strTemp = strW; <FONT color="#0f4b95">return</FONT> ar << strTemp; }

<FONT color="#0f4b95">inline</FONT> CArchive& AFXAPI <FONT color="#0f4b95">operator</FONT>>>(CArchive& ar, CStdStringA& strA) { CString strTemp; ar >> strTemp; strA = strTemp; <FONT color="#0f4b95">return</FONT> ar; } <FONT color="#0f4b95">inline</FONT> CArchive& AFXAPI <FONT color="#0f4b95">operator</FONT>>>(CArchive& ar, CStdStringW& strW) { CString strTemp; ar >> strTemp; strW = strTemp; <FONT color="#0f4b95">return</FONT> ar; } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef _MFC_VER -- (i.e. is this MFC?)</FONT> <FONT color="#008000">// WUSysMessage -- return the system string corresponding to a system error or</FONT> <FONT color="#008000">// HRESULT value.</FONT> <FONT color="#0f4b95">#define</FONT> SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT)

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// HOW TO EXPORT CSTDSTRING FROM A DLL</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// If you want to export CStdStringA and CStdStringW from a DLL, then all you</FONT> <FONT color="#008000">// need to</FONT> <FONT color="#008000">// 1. make sure that all components link to the same DLL version</FONT> <FONT color="#008000">// of the CRT (not the static one).</FONT> <FONT color="#008000">// 2. Uncomment the 3 lines of code below</FONT> <FONT color="#008000">// 3. #define 2 macros per the instructions in MS KnowledgeBase</FONT> <FONT color="#008000">// article Q168958. The macros are:</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// MACRO DEFINTION WHEN EXPORTING DEFINITION WHEN IMPORTING</FONT> <FONT color="#008000">// ----- ------------------------ -------------------------</FONT> <FONT color="#008000">// SSDLLEXP (nothing, just #define it) extern</FONT> <FONT color="#008000">// SSDLLSPEC __declspec(dllexport) __declspec(dllimport)</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// Note that these macros must be available to ALL clients who want to </FONT> <FONT color="#008000">// link to the DLL and use the class. If they </FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">//#pragma warning(disable:4231) // non-standard extension ("extern template")</FONT> <FONT color="#008000">// SSDLLEXP template class SSDLLSPEC CStdStr<char>;</FONT> <FONT color="#008000">// SSDLLEXP template class SSDLLSPEC CStdStr<wchar_t>;</FONT>

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// GLOBAL FUNCTION: WUFormat</FONT> <FONT color="#008000">// CStdStringA WUFormat(UINT nId, ...);</FONT> <FONT color="#008000">// CStdStringA WUFormat(PCSTR szFormat, ...);</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// This function allows the caller for format and return a CStdStringA</FONT> <FONT color="#008000">// object with a single line of code.</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">inline</FONT> CStdStringA WUFormatA(UINT nId, ...) { va_list argList; va_start(argList, nId);

CStdStringA strFmt; CStdStringA strOut; <FONT color="#0f4b95">if</FONT> ( strFmt.Load(nId) ) strOut.FormatV(strFmt, argList);

va_end(argList); <FONT color="#0f4b95">return</FONT> strOut; } <FONT color="#0f4b95">inline</FONT> CStdStringA WUFormatA(PCSTR szFormat, ...) { va_list argList; va_start(argList, szFormat); CStdStringA strOut; strOut.FormatV(szFormat, argList); va_end(argList); <FONT color="#0f4b95">return</FONT> strOut; }

<FONT color="#0f4b95">inline</FONT> CStdStringW WUFormatW(UINT nId, ...) { va_list argList; va_start(argList, nId);

CStdStringW strFmt; CStdStringW strOut; <FONT color="#0f4b95">if</FONT> ( strFmt.Load(nId) ) strOut.FormatV(strFmt, argList);

va_end(argList); <FONT color="#0f4b95">return</FONT> strOut; } <FONT color="#0f4b95">inline</FONT> CStdStringW WUFormatW(PCWSTR szwFormat, ...) { va_list argList; va_start(argList, szwFormat); CStdStringW strOut; strOut.FormatV(szwFormat, argList); va_end(argList); <FONT color="#0f4b95">return</FONT> strOut; } <FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifdef SS_ANSI</FONT> <FONT color="#0f4b95">#ifdef</FONT> SS_ANSI <FONT color="#0f4b95">#else</FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTION: WUSysMessage</FONT> <FONT color="#008000">// CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);</FONT> <FONT color="#008000">// CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);</FONT> <FONT color="#008000">// </FONT> <FONT color="#008000">// DESCRIPTION:</FONT> <FONT color="#008000">// This function simplifies the process of obtaining a string equivalent</FONT> <FONT color="#008000">// of a system error code returned from GetLastError(). You simply</FONT> <FONT color="#008000">// supply the value returned by GetLastError() to this function and the</FONT> <FONT color="#008000">// corresponding system string is returned in the form of a CStdStringA.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// PARAMETERS: </FONT> <FONT color="#008000">// dwError - a DWORD value representing the error code to be translated</FONT> <FONT color="#008000">// dwLangId - the language id to use. defaults to english.</FONT> <FONT color="#008000">//</FONT> <FONT color="#008000">// RETURN VALUE: </FONT> <FONT color="#008000">// a CStdStringA equivalent of the error code. Currently, this function</FONT> <FONT color="#008000">// only returns either English of the system default language strings. </FONT> <FONT color="#008000">// -------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT) <FONT color="#0f4b95">inline</FONT> CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID) { CHAR szBuf[<FONT color="#a52a00">512</FONT>];

<FONT color="#0f4b95">if</FONT> ( <FONT color="#a52a00">0</FONT> != ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, dwLangId, szBuf, <FONT color="#a52a00">511</FONT>, NULL) ) <FONT color="#0f4b95">return</FONT> WUFormatA(<FONT color="#a52a00">"%s (0x%X)"</FONT>, szBuf, dwError); <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">return</FONT> WUFormatA(<FONT color="#a52a00">"Unknown error (0x%X)"</FONT>, dwError); } <FONT color="#0f4b95">inline</FONT> CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID) { WCHAR szBuf[<FONT color="#a52a00">512</FONT>];

<FONT color="#0f4b95">if</FONT> ( <FONT color="#a52a00">0</FONT> != ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, dwLangId, szBuf, <FONT color="#a52a00">511</FONT>, NULL) ) <FONT color="#0f4b95">return</FONT> WUFormatW(L<FONT color="#a52a00">"%s (0x%X)"</FONT>, szBuf, dwError); <FONT color="#0f4b95">else</FONT> <FONT color="#0f4b95">return</FONT> WUFormatW(L<FONT color="#a52a00">"Unknown error (0x%X)"</FONT>, dwError); } <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// Define TCHAR based friendly names for some of these functions</FONT> <FONT color="#0f4b95">#ifdef</FONT> UNICODE <FONT color="#0f4b95">#define</FONT> CStdString CStdStringW <FONT color="#0f4b95">#define</FONT> WUSysMessage WUSysMessageW <FONT color="#0f4b95">#define</FONT> WUFormat WUFormatW <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> CStdString CStdStringA <FONT color="#0f4b95">#define</FONT> WUSysMessage WUSysMessageA <FONT color="#0f4b95">#define</FONT> WUFormat WUFormatA <FONT color="#0f4b95">#endif</FONT>

<FONT color="#008000">// ...and some shorter names for the space-efficient</FONT> <FONT color="#0f4b95">#define</FONT> WUSysMsg WUSysMessage <FONT color="#0f4b95">#define</FONT> WUSysMsgA WUSysMessageA <FONT color="#0f4b95">#define</FONT> WUSysMsgW WUSysMessageW <FONT color="#0f4b95">#define</FONT> WUFmtA WUFormatA <FONT color="#0f4b95">#define</FONT> WUFmtW WUFormatW <FONT color="#0f4b95">#define</FONT> WUFmt WUFormat <FONT color="#0f4b95">#define</FONT> WULastErrMsg() WUSysMessage(::GetLastError()) <FONT color="#0f4b95">#define</FONT> WULastErrMsgA() WUSysMessageA(::GetLastError()) <FONT color="#0f4b95">#define</FONT> WULastErrMsgW() WUSysMessageW(::GetLastError())

<FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#008000">// FUNCTIONAL COMPARATORS:</FONT> <FONT color="#008000">// REMARKS:</FONT> <FONT color="#008000">// These structs are derived from the std::binary_function template. They</FONT> <FONT color="#008000">// give us functional classes (which may be used in Standard C++ Library</FONT> <FONT color="#008000">// collections and algorithms) that perform case-insensitive comparisons of</FONT> <FONT color="#008000">// CStdString objects. This is useful for maps in which the key may be the</FONT> <FONT color="#008000">// proper string but in the wrong case.</FONT> <FONT color="#008000">// -----------------------------------------------------------------------------</FONT> <FONT color="#0f4b95">#define</FONT> StdStringLessNoCaseW SSLNCW <FONT color="#008000">// avoid VC compiler warning 4786</FONT> <FONT color="#0f4b95">#define</FONT> StdStringEqualsNoCaseW SSENCW <FONT color="#0f4b95">#define</FONT> StdStringLessNoCaseA SSLNCA <FONT color="#0f4b95">#define</FONT> StdStringEqualsNoCaseA SSENCA

<FONT color="#0f4b95">#ifdef</FONT> UNICODE <FONT color="#0f4b95">#define</FONT> StdStringLessNoCase SSLNCW <FONT color="#0f4b95">#define</FONT> StdStringEqualsNoCase SSENCW <FONT color="#0f4b95">#else</FONT> <FONT color="#0f4b95">#define</FONT> StdStringLessNoCase SSLNCA <FONT color="#0f4b95">#define</FONT> StdStringEqualsNoCase SSENCA <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">struct</FONT> StdStringLessNoCaseW : std::binary_function<CStdStringW, CStdStringW, <FONT color="#0f4b95">bool</FONT>> { <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CStdStringW& sLeft, <FONT color="#0f4b95">const</FONT> CStdStringW& sRight) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicmp(sLeft.c_str(), sRight.c_str()) < <FONT color="#a52a00">0</FONT>; } }; <FONT color="#0f4b95">struct</FONT> StdStringEqualsNoCaseW : std::binary_function<CStdStringW, CStdStringW, <FONT color="#0f4b95">bool</FONT>> { <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CStdStringW& sLeft, <FONT color="#0f4b95">const</FONT> CStdStringW& sRight) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicmp(sLeft.c_str(), sRight.c_str()) == <FONT color="#a52a00">0</FONT>; } }; <FONT color="#0f4b95">struct</FONT> StdStringLessNoCaseA : std::binary_function<CStdStringA, CStdStringA, <FONT color="#0f4b95">bool</FONT>> { <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CStdStringA& sLeft, <FONT color="#0f4b95">const</FONT> CStdStringA& sRight) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicmp(sLeft.c_str(), sRight.c_str()) < <FONT color="#a52a00">0</FONT>; } }; <FONT color="#0f4b95">struct</FONT> StdStringEqualsNoCaseA : std::binary_function<CStdStringA, CStdStringA, <FONT color="#0f4b95">bool</FONT>> { <FONT color="#0f4b95">inline</FONT> <FONT color="#0f4b95">bool</FONT> <FONT color="#0f4b95">operator</FONT>()(<FONT color="#0f4b95">const</FONT> CStdStringA& sLeft, <FONT color="#0f4b95">const</FONT> CStdStringA& sRight) <FONT color="#0f4b95">const</FONT> { <FONT color="#0f4b95">return</FONT> ssicmp(sLeft.c_str(), sRight.c_str()) == <FONT color="#a52a00">0</FONT>; } };

<FONT color="#008000">// If we had to define our own version of TRACE above, get rid of it now</FONT> <FONT color="#0f4b95">#ifdef</FONT> TRACE_DEFINED_HERE <FONT color="#0f4b95">#undef</FONT> TRACE <FONT color="#0f4b95">#undef</FONT> TRACE_DEFINED_HERE <FONT color="#0f4b95">#endif</FONT>

<FONT color="#0f4b95">#endif</FONT> <FONT color="#008000">// #ifndef STDSTRING_H</FONT> </PRE><P><HR></P>

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.