Добавление исходников

[stg.git] / include / stdstring.h

// =============================================================================\r
//  FILE:  StdString.h\r
//  AUTHOR:     Joe O'Leary (with outside help noted in comments)\r
//  REMARKS:\r
//              This header file declares the CStdStr template.  This template derives\r
//              the Standard C++ Library basic_string<> template and add to it the\r
//              the following conveniences:\r
//                      - The full MFC CString set of functions (including implicit cast)\r
//                      - writing to/reading from COM IStream interfaces\r
//                      - Functional objects for use in STL algorithms\r
//\r
//              From this template, we intstantiate two classes:  CStdStringA and\r
//              CStdStringW.  The name "CStdString" is just a #define of one of these,\r
//              based upone the _UNICODE macro setting\r
//\r
//              This header also declares our own version of the MFC/ATL UNICODE-MBCS\r
//              conversion macros.  Our version looks exactly like the Microsoft's to\r
//              facilitate portability.\r
//\r
//      NOTE:\r
//              If you you use this in an MFC or ATL build, you should include either\r
//              afx.h or atlbase.h first, as appropriate.\r
//\r
//      PEOPLE WHO HAVE CONTRIBUTED TO THIS CLASS:\r
//\r
//              Several people have helped me iron out problems and othewise improve\r
//              this class.  OK, this is a long list but in my own defense, this code\r
//              has undergone two major rewrites.  Many of the improvements became\r
//              necessary after I rewrote the code as a template.  Others helped me\r
//              improve the CString facade.\r
//\r
//              Anyway, these people are (in chronological order):\r
//\r
//                      - Pete the Plumber (???)\r
//                      - Julian Selman\r
//                      - Chris (of Melbsys)\r
//                      - Dave Plummer\r
//                      - John C Sipos\r
//                      - Chris Sells\r
//                      - Nigel Nunn\r
//                      - Fan Xia\r
//                      - Matthew Williams\r
//                      - Carl Engman\r
//                      - Mark Zeren\r
//                      - Craig Watson\r
//                      - Rich Zuris\r
//                      - Karim Ratib\r
//                      - Chris Conti\r
//                      - Baptiste Lepilleur\r
//                      - Greg Pickles\r
//                      - Jim Cline\r
//                      - Jeff Kohn\r
//                      - Todd Heckel\r
//                      - Ullrich Pollähne\r
//                      - Joe Vitaterna\r
//                      - Joe Woodbury\r
//                      - Aaron (no last name)\r
//                      - Joldakowski (???)\r
//                      - Scott Hathaway\r
//                      - Eric Nitzche\r
//                      - Pablo Presedo\r
//                      - Farrokh Nejadlotfi\r
//                      - Jason Mills\r
//                      - Igor Kholodov\r
//                      - Mike Crusader\r
//                      - John James\r
//                      - Wang Haifeng\r
//                      - Tim Dowty\r
//          - Arnt Witteveen\r
//          - Glen Maynard\r
//          - Paul DeMarco\r
//          - Bagira (full name?)\r
//          - Ronny Schulz\r
//          - Jakko Van Hunen\r
//                      - Charles G\r
//\r
//      REVISION HISTORY\r
//    2003-JUL-10 - Thanks to Charles G for making me realize my 'FmtArg' fixes\r
//                  had inadvertently broken the DLL-export code (which is\r
//                  normally commented out.  I had to move it up higher.  Also\r
//                                      this helped me catch a bug in ssicoll that would prevent\r
//                  compilation, otherwise.\r
//\r
//    2003-MAR-14 - Thanks to Jakko Van Hunen for pointing out a copy-and-paste\r
//                  bug in one of the overloads of FmtArg.\r
//\r
//    2003-MAR-10 - Thanks to Ronny Schulz for (twice!) sending me some changes\r
//                  to help CStdString build on SGI and for pointing out an\r
//                  error in placement of my preprocessor macros for ssfmtmsg.\r
//\r
//    2002-NOV-26 - Thanks to Bagira for pointing out that my implementation of\r
//                  SpanExcluding was not properly handling the case in which\r
//                  the string did NOT contain any of the given characters\r
//\r
//    2002-OCT-21 - Many thanks to Paul DeMarco who was invaluable in helping me\r
//                  get this code working with Borland's free compiler as well\r
//                  as the Dev-C++ compiler (available free at SourceForge).\r
//\r
//    2002-SEP-13 - Thanks to Glen Maynard who helped me get rid of some loud\r
//                  but harmless warnings that were showing up on g++.  Glen\r
//                  also pointed out that some pre-declarations of FmtArg<>\r
//                  specializations were unnecessary (and no good on G++)\r
//\r
//    2002-JUN-26 - Thanks to Arnt Witteveen for pointing out that I was using\r
//                  static_cast<> in a place in which I should have been using\r
//                  reinterpret_cast<> (the ctor for unsigned char strings).\r
//                  That's what happens when I don't unit-test properly!\r
//                  Arnt also noticed that CString was silently correcting the\r
//                  'nCount' argument to Left() and Right() where CStdString was\r
//                  not (and crashing if it was bad).  That is also now fixed!\r
//\r
//        2002-FEB-25 - Thanks to Tim Dowty for pointing out (and giving me the fix\r
//                                      for) a conversion problem with non-ASCII MBCS characters.\r
//                                      CStdString is now used in my favorite commercial MP3 player!\r
//\r
//        2001-DEC-06 - Thanks to Wang Haifeng for spotting a problem in one of the\r
//                                      assignment operators (for _bstr_t) that would cause compiler\r
//                                      errors when refcounting protection was turned off.\r
//\r
//        2001-NOV-27 - Remove calls to operator!= which involve reverse_iterators\r
//                                      due to a conflict with the rel_ops operator!=.  Thanks to\r
//                                      John James for pointing this out.\r
//\r
//    2001-OCT-29 - Added a minor range checking fix for the Mid function to\r
//                                      make it as forgiving as CString's version is.  Thanks to\r
//                                      Igor Kholodov for noticing this.  \r
//                                - Added a specialization of std::swap for CStdString.  Thanks\r
//                                      to Mike Crusader for suggesting this!  It's commented out\r
//                                      because you're not supposed to inject your own code into the\r
//                                      'std' namespace.  But if you don't care about that, it's\r
//                                      there if you want it\r
//                                - Thanks to Jason Mills for catching a case where CString was\r
//                                      more forgiving in the Delete() function than I was.\r
//\r
//        2001-JUN-06 - I was violating the Standard name lookup rules stated\r
//                                      in [14.6.2(3)].  None of the compilers I've tried so\r
//                                      far apparently caught this but HP-UX aCC 3.30 did.  The\r
//                                      fix was to add 'this->' prefixes in many places.\r
//                                      Thanks to Farrokh Nejadlotfi for this!\r
//\r
//        2001-APR-27 - StreamLoad was calculating the number of BYTES in one\r
//                                      case, not characters.  Thanks to Pablo Presedo for this.\r
//\r
//    2001-FEB-23 - Replace() had a bug which caused infinite loops if the\r
//                                      source string was empty.  Fixed thanks to Eric Nitzsche.\r
//\r
//    2001-FEB-23 - Scott Hathaway was a huge help in providing me with the\r
//                                      ability to build CStdString on Sun Unix systems.  He\r
//                                      sent me detailed build reports about what works and what\r
//                                      does not.  If CStdString compiles on your Unix box, you\r
//                                      can thank Scott for it.\r
//\r
//        2000-DEC-29 - Joldakowski noticed one overload of Insert failed to do a\r
//                                      range check as CString's does.  Now fixed -- thanks!\r
//\r
//        2000-NOV-07 - Aaron pointed out that I was calling static member\r
//                                      functions of char_traits via a temporary.  This was not\r
//                                      technically wrong, but it was unnecessary and caused\r
//                                      problems for poor old buggy VC5.  Thanks Aaron!\r
//\r
//        2000-JUL-11 - Joe Woodbury noted that the CString::Find docs don't match\r
//                                      what the CString::Find code really ends up doing.   I was\r
//                                      trying to match the docs.  Now I match the CString code\r
//                                - Joe also caught me truncating strings for GetBuffer() calls\r
//                                      when the supplied length was less than the current length.\r
//\r
//        2000-MAY-25 - Better support for STLPORT's Standard library distribution\r
//                                - Got rid of the NSP macro - it interfered with Koenig lookup\r
//                                - Thanks to Joe Woodbury for catching a TrimLeft() bug that\r
//                                      I introduced in January.  Empty strings were not getting\r
//                                      trimmed\r
//\r
//        2000-APR-17 - Thanks to Joe Vitaterna for pointing out that ReverseFind\r
//                                      is supposed to be a const function.\r
//\r
//        2000-MAR-07 - Thanks to Ullrich Pollähne for catching a range bug in one\r
//                                      of the overloads of assign.\r
//\r
//    2000-FEB-01 - You can now use CStdString on the Mac with CodeWarrior!\r
//                                      Thanks to Todd Heckel for helping out with this.\r
//\r
//        2000-JAN-23 - Thanks to Jim Cline for pointing out how I could make the\r
//                                      Trim() function more efficient.\r
//                                - Thanks to Jeff Kohn for prompting me to find and fix a typo\r
//                                      in one of the addition operators that takes _bstr_t.\r
//                                - Got rid of the .CPP file -  you only need StdString.h now!\r
//\r
//        1999-DEC-22 - Thanks to Greg Pickles for helping me identify a problem\r
//                                      with my implementation of CStdString::FormatV in which\r
//                                      resulting string might not be properly NULL terminated.\r
//\r
//        1999-DEC-06 - Chris Conti pointed yet another basic_string<> assignment\r
//                                      bug that MS has not fixed.  CStdString did nothing to fix\r
//                                      it either but it does now!  The bug was: create a string\r
//                                      longer than 31 characters, get a pointer to it (via c_str())\r
//                                      and then assign that pointer to the original string object.\r
//                                      The resulting string would be empty.  Not with CStdString!\r
//\r
//        1999-OCT-06 - BufferSet was erasing the string even when it was merely\r
//                                      supposed to shrink it.  Fixed.  Thanks to Chris Conti.\r
//                                - Some of the Q172398 fixes were not checking for assignment-\r
//                                      to-self.  Fixed.  Thanks to Baptiste Lepilleur.\r
//\r
//        1999-AUG-20 - Improved Load() function to be more efficient by using \r
//                                      SizeOfResource().  Thanks to Rich Zuris for this.\r
//                                - Corrected resource ID constructor, again thanks to Rich.\r
//                                - Fixed a bug that occurred with UNICODE characters above\r
//                                      the first 255 ANSI ones.  Thanks to Craig Watson. \r
//                                - Added missing overloads of TrimLeft() and TrimRight().\r
//                                      Thanks to Karim Ratib for pointing them out\r
//\r
//        1999-JUL-21 - Made all calls to GetBuf() with no args check length first.\r
//\r
//        1999-JUL-10 - Improved MFC/ATL independence of conversion macros\r
//                                - Added SS_NO_REFCOUNT macro to allow you to disable any\r
//                                      reference-counting your basic_string<> impl. may do.\r
//                                - Improved ReleaseBuffer() to be as forgiving as CString.\r
//                                      Thanks for Fan Xia for helping me find this and to\r
//                                      Matthew Williams for pointing it out directly.\r
//\r
//        1999-JUL-06 - Thanks to Nigel Nunn for catching a very sneaky bug in\r
//                                      ToLower/ToUpper.  They should call GetBuf() instead of\r
//                                      data() in order to ensure the changed string buffer is not\r
//                                      reference-counted (in those implementations that refcount).\r
//\r
//        1999-JUL-01 - Added a true CString facade.  Now you can use CStdString as\r
//                                      a drop-in replacement for CString.  If you find this useful,\r
//                                      you can thank Chris Sells for finally convincing me to give\r
//                                      in and implement it.\r
//                                - Changed operators << and >> (for MFC CArchive) to serialize\r
//                                      EXACTLY as CString's do.  So now you can send a CString out\r
//                                      to a CArchive and later read it in as a CStdString.   I have\r
//                                      no idea why you would want to do this but you can. \r
//\r
//        1999-JUN-21 - Changed the CStdString class into the CStdStr template.\r
//                                - Fixed FormatV() to correctly decrement the loop counter.\r
//                                      This was harmless bug but a bug nevertheless.  Thanks to\r
//                                      Chris (of Melbsys) for pointing it out\r
//                                - Changed Format() to try a normal stack-based array before\r
//                                      using to _alloca().\r
//                                - Updated the text conversion macros to properly use code\r
//                                      pages and to fit in better in MFC/ATL builds.  In other\r
//                                      words, I copied Microsoft's conversion stuff again. \r
//                                - Added equivalents of CString::GetBuffer, GetBufferSetLength\r
//                                - new sscpy() replacement of CStdString::CopyString()\r
//                                - a Trim() function that combines TrimRight() and TrimLeft().\r
//\r
//        1999-MAR-13 - Corrected the "NotSpace" functional object to use _istpace()\r
//                                      instead of _isspace()   Thanks to Dave Plummer for this.\r
//\r
//        1999-FEB-26 - Removed errant line (left over from testing) that #defined\r
//                                      _MFC_VER.  Thanks to John C Sipos for noticing this.\r
//\r
//        1999-FEB-03 - Fixed a bug in a rarely-used overload of operator+() that\r
//                                      caused infinite recursion and stack overflow\r
//                                - Added member functions to simplify the process of\r
//                                      persisting CStdStrings to/from DCOM IStream interfaces \r
//                                - Added functional objects (e.g. StdStringLessNoCase) that\r
//                                      allow CStdStrings to be used as keys STL map objects with\r
//                                      case-insensitive comparison \r
//                                - Added array indexing operators (i.e. operator[]).  I\r
//                                      originally assumed that these were unnecessary and would be\r
//                                      inherited from basic_string.  However, without them, Visual\r
//                                      C++ complains about ambiguous overloads when you try to use\r
//                                      them.  Thanks to Julian Selman to pointing this out. \r
//\r
//        1998-FEB-?? - Added overloads of assign() function to completely account\r
//                                      for Q172398 bug.  Thanks to "Pete the Plumber" for this\r
//\r
//        1998-FEB-?? - Initial submission\r
//\r
// COPYRIGHT:\r
//              2002 Joseph M. O'Leary.  This code is 100% free.  Use it anywhere you\r
//      want.  Rewrite it, restructure it, whatever.  If you can write software\r
//      that makes money off of it, good for you.  I kinda like capitalism. \r
//      Please don't blame me if it causes your $30 billion dollar satellite\r
//      explode in orbit.  If you redistribute it in any form, I'd appreciate it\r
//      if you would leave this notice here.\r
//\r
//              If you find any bugs, please let me know:\r
//\r
//                              jmoleary@earthlink.net\r
//                              http://www.joeo.net\r
//\r
//      The latest version of this code should always be available at the\r
//      following link:\r
//\r
//              http://www.joeo.net/code/StdString.zip\r
// =============================================================================\r
\r
// Avoid multiple inclusion the VC++ way,\r
// Turn off browser references\r
// Turn off unavoidable compiler warnings\r
\r
#if defined(_MSC_VER) && (_MSC_VER > 1100)\r
        #pragma once\r
        #pragma component(browser, off, references, "CStdString")\r
        #pragma warning (disable : 4290) // C++ Exception Specification ignored\r
        #pragma warning (disable : 4127) // Conditional expression is constant\r
        #pragma warning (disable : 4097) // typedef name used as synonym for class name\r
#endif\r
\r
// Borland warnings to turn off\r
#ifdef __BORLANDC__\r
    #pragma option push -w-inl\r
//      #pragma warn -inl   // Turn off inline function warnings\r
#endif\r
\r
#ifndef STDSTRING_H\r
#define STDSTRING_H\r
\r
// MACRO: SS_UNSIGNED\r
// ------------------\r
//      This macro causes the addition of a constructor and assignment operator\r
//      which take unsigned characters.  CString has such functions and in order\r
//      to provide maximum CString-compatability, this code needs them as well.\r
//      In practice you will likely never need these functions...\r
\r
//#define SS_UNSIGNED\r
\r
#ifdef SS_ALLOW_UNSIGNED_CHARS\r
        #define SS_UNSIGNED\r
#endif\r
\r
// MACRO: SS_SAFE_FORMAT\r
// ---------------------\r
//      This macro provides limited compatability with a questionable CString\r
//      "feature".  You can define it in order to avoid a common problem that\r
//      people encounter when switching from CString to CStdString.\r
//\r
//      To illustrate the problem -- With CString, you can do this:\r
//\r
//          CString sName("Joe");\r
//          CString sTmp;\r
//          sTmp.Format("My name is %s", sName);                    // WORKS!\r
//\r
//      However if you were to try this with CStdString, your program would\r
//      crash.\r
//\r
//          CStdString sName("Joe");\r
//          CStdString sTmp;\r
//          sTmp.Format("My name is %s", sName);                    // CRASHES!\r
//\r
//      You must explicitly call c_str() or cast the object to the proper type\r
//\r
//          sTmp.Format("My name is %s", sName.c_str());            // WORKS!\r
//          sTmp.Format("My name is %s", static_cast<PCSTR>(sName));// WORKS!\r
//          sTmp.Format("My name is %s", (PCSTR)sName);// WORKS!\r
//\r
//      This is because it is illegal to pass anything but a POD type as a\r
//      variadic argument to a variadic function (i.e. as one of the "..."\r
//      arguments).  The type const char* is a POD type.  The type CStdString\r
//      is not.  Of course, neither is the type CString, but CString lets you do\r
//      it anyway due to the way they laid out the class in binary.  I have no\r
//      control over this in CStdString since I derive from whatever\r
//      implementation of basic_string is available.\r
//\r
//      However if you have legacy code (which does this) that you want to take\r
//      out of the MFC world and you don't want to rewrite all your calls to\r
//      Format(), then you can define this flag and it will no longer crash.\r
//\r
//      Note however that this ONLY works for Format(), not sprintf, fprintf, \r
//      etc.  If you pass a CStdString object to one of those functions, your\r
//      program will crash.  Not much I can do to get around this, short of\r
//      writing substitutes for those functions as well.\r
\r
#define SS_SAFE_FORMAT  // use new template style Format() function\r
\r
\r
// MACRO: SS_NO_IMPLICIT_CAST\r
// --------------------------\r
//      Some people don't like the implicit cast to const char* (or rather to\r
//      const CT*) that CStdString (and MFC's CString) provide.  That was the\r
//      whole reason I created this class in the first place, but hey, whatever\r
//      bakes your cake.  Just #define this macro to get rid of the the implicit\r
//      cast.\r
\r
//#define SS_NO_IMPLICIT_CAST // gets rid of operator const CT*()\r
\r
\r
// MACRO: SS_NO_REFCOUNT\r
// ---------------------\r
//              turns off reference counting at the assignment level.  Only needed\r
//              for the version of basic_string<> that comes with Visual C++ versions\r
//              6.0 or earlier, and only then in some heavily multithreaded scenarios.\r
//              Uncomment it if you feel you need it.\r
\r
//#define SS_NO_REFCOUNT\r
\r
// MACRO: SS_WIN32\r
// ---------------\r
//      When this flag is set, we are building code for the Win32 platform and\r
//      may use Win32 specific functions (such as LoadString).  This gives us\r
//      a couple of nice extras for the code.\r
//\r
//      Obviously, Microsoft's is not the only compiler available for Win32 out\r
//      there.  So I can't just check to see if _MSC_VER is defined to detect\r
//      if I'm building on Win32.  So for now, if you use MS Visual C++ or\r
//      Borland's compiler, I turn this on.  Otherwise you may turn it on\r
//      yourself, if you prefer\r
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WIN32)\r
    #define SS_WIN32\r
#endif\r
\r
// MACRO: SS_ANSI\r
// --------------\r
//      When this macro is defined, the code attempts only to use ANSI/ISO\r
//      standard library functions to do it's work.  It will NOT attempt to use\r
//      any Win32 of Visual C++ specific functions -- even if they are\r
//      available.  You may define this flag yourself to prevent any Win32\r
//      of VC++ specific functions from being called.\r
\r
// If we're not on Win32, we MUST use an ANSI build\r
#ifndef SS_WIN32\r
    #if !defined(SS_NO_ANSI)\r
        #define SS_ANSI\r
    #endif\r
#endif\r
\r
// MACRO: SS_ALLOCA\r
// ----------------\r
//      Some implementations of the Standard C Library have a non-standard\r
//      function known as alloca().  This functions allows one to allocate a\r
//      variable amount of memory on the stack.  It comes in very useful for\r
//      the ASCII/MBCS conversion macros.\r
//\r
//      Here we attempt to determine automatically if alloca() is available on\r
//      this platform.  If so we define SS_ALLOCA to be the name of the alloca\r
//      function.  If SS_ALLOCA is undefined later on, then the conversion\r
//      macros will not be compiled.\r
//\r
//      You may prevent SS_ALLOCA\r
\r
\r
\r
// Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well\r
\r
#if defined (_UNICODE) && !defined (UNICODE)\r
        #define UNICODE\r
#endif\r
#if defined (UNICODE) && !defined (_UNICODE)\r
        #define _UNICODE\r
#endif\r
\r
// -----------------------------------------------------------------------------\r
// MIN and MAX.  The Standard C++ template versions go by so many names (at\r
// at least in the MS implementation) that you never know what's available\r
// -----------------------------------------------------------------------------\r
template<class Type>\r
inline const Type& SSMIN(const Type& arg1, const Type& arg2)\r
{\r
        return arg2 < arg1 ? arg2 : arg1;\r
}\r
template<class Type>\r
inline const Type& SSMAX(const Type& arg1, const Type& arg2)\r
{\r
        return arg2 > arg1 ? arg2 : arg1;\r
}\r
\r
// If they have not #included W32Base.h (part of my W32 utility library) then\r
// we need to define some stuff.  Otherwise, this is all defined there.\r
\r
#if !defined(W32BASE_H)\r
\r
        // If they want us to use only standard C++ stuff (no Win32 stuff)\r
\r
        #ifdef SS_ANSI\r
\r
                // On Win32 we have TCHAR.H so just include it.  This is NOT violating\r
        // the spirit of SS_ANSI as we are not calling any Win32 functions here.\r
        \r
                #ifdef SS_WIN32\r
\r
                        #include <TCHAR.H>\r
                        #include <WTYPES.H>\r
                        #ifndef STRICT\r
                                #define STRICT\r
                        #endif\r
\r
        // ... but on non-Win32 platforms, we must #define the types we need.\r
\r
                #else\r
\r
                        typedef const char*             PCSTR;\r
                        typedef char*                   PSTR;\r
                        typedef const wchar_t*  PCWSTR;\r
                        typedef wchar_t*                PWSTR;\r
                        #ifdef UNICODE\r
                                typedef wchar_t         TCHAR;\r
                        #else\r
                                typedef char            TCHAR;\r
                        #endif\r
                        typedef wchar_t                 OLECHAR;\r
\r
                #endif  // #ifndef _WIN32\r
\r
\r
                // Make sure ASSERT and verify are defined using only ANSI stuff\r
\r
                #ifndef ASSERT\r
                        #include <assert.h>\r
                        #define ASSERT(f) assert((f))\r
                #endif\r
                #ifndef VERIFY\r
                        #ifdef _DEBUG\r
                                #define VERIFY(x) ASSERT((x))\r
                        #else\r
                                #define VERIFY(x) x\r
                        #endif\r
                #endif\r
\r
        #else // ...else SS_ANSI is NOT defined\r
\r
                #include <TCHAR.H>\r
                #include <WTYPES.H>\r
                #ifndef STRICT\r
                        #define STRICT\r
                #endif\r
\r
                // Make sure ASSERT and verify are defined\r
\r
                #ifndef ASSERT\r
                        #include <crtdbg.h>\r
                        #define ASSERT(f) _ASSERTE((f))\r
                #endif\r
                #ifndef VERIFY\r
                        #ifdef _DEBUG\r
                                #define VERIFY(x) ASSERT((x))\r
                        #else\r
                                #define VERIFY(x) x\r
                        #endif\r
                #endif\r
\r
        #endif // #ifdef SS_ANSI\r
\r
        #ifndef UNUSED\r
                #define UNUSED(x) x\r
        #endif\r
\r
#endif // #ifndef W32BASE_H\r
\r
// Standard headers needed\r
\r
#include <string>                       // basic_string\r
#include <algorithm>            // for_each, etc.\r
#include <functional>           // for StdStringLessNoCase, et al\r
#include <locale>               // for various facets\r
\r
// If this is a recent enough version of VC include comdef.h, so we can write\r
// member functions to deal with COM types & compiler support classes e.g. _bstr_t\r
\r
#if defined (_MSC_VER) && (_MSC_VER >= 1100)\r
        #include <comdef.h>\r
        #define SS_INC_COMDEF           // signal that we #included MS comdef.h file\r
        #define STDSTRING_INC_COMDEF\r
        #define SS_NOTHROW __declspec(nothrow)\r
#else\r
        #define SS_NOTHROW\r
#endif\r
\r
#ifndef TRACE\r
        #define TRACE_DEFINED_HERE\r
        #define TRACE\r
#endif\r
\r
// Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR.  I hate to use the\r
// versions with the "L" in front of them because that's a leftover from Win 16\r
// days, even though it evaluates to the same thing.  Therefore, Define a PCSTR\r
// as an LPCTSTR.\r
\r
#if !defined(PCTSTR) && !defined(PCTSTR_DEFINED)\r
        typedef const TCHAR*                    PCTSTR;\r
        #define PCTSTR_DEFINED\r
#endif\r
\r
#if !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED)\r
        typedef const OLECHAR*                  PCOLESTR;\r
        #define PCOLESTR_DEFINED\r
#endif\r
\r
#if !defined(POLESTR) && !defined(POLESTR_DEFINED)\r
        typedef OLECHAR*                                POLESTR;\r
        #define POLESTR_DEFINED\r
#endif\r
\r
#if !defined(PCUSTR) && !defined(PCUSTR_DEFINED)\r
        typedef const unsigned char*    PCUSTR;\r
        typedef unsigned char*                  PUSTR;\r
        #define PCUSTR_DEFINED\r
#endif\r
\r
\r
// SGI compiler 7.3 doesnt know these  types - oh and btw, remember to use\r
// -LANG:std in the CXX Flags\r
#if defined(__sgi)\r
    typedef unsigned long           DWORD;\r
    typedef void *                  LPCVOID;\r
#endif\r
\r
\r
// SS_USE_FACET macro and why we need it:\r
//\r
// Since I'm a good little Standard C++ programmer, I use locales.  Thus, I\r
// need to make use of the use_facet<> template function here.   Unfortunately,\r
// this need is complicated by the fact the MS' implementation of the Standard\r
// C++ Library has a non-standard version of use_facet that takes more\r
// arguments than the standard dictates.  Since I'm trying to write CStdString\r
// to work with any version of the Standard library, this presents a problem.\r
//\r
// The upshot of this is that I can't do 'use_facet' directly.  The MS' docs\r
// tell me that I have to use a macro, _USE() instead.  Since _USE obviously\r
// won't be available in other implementations, this means that I have to write\r
// my OWN macro -- SS_USE_FACET -- that evaluates either to _USE or to the\r
// standard, use_facet.\r
//\r
// If you are having trouble with the SS_USE_FACET macro, in your implementation\r
// of the Standard C++ Library, you can define your own version of SS_USE_FACET.\r
#ifndef schMSG\r
        #define schSTR(x)          #x\r
        #define schSTR2(x)      schSTR(x)\r
        #define schMSG(desc) message(__FILE__ "(" schSTR2(__LINE__) "):" #desc)\r
#endif\r
\r
#ifndef SS_USE_FACET\r
        // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for\r
        // all MSVC builds, erroneously in my opinion.  It causes problems for\r
        // my SS_ANSI builds.  In my code, I always comment out that line.  You'll\r
        // find it in   \stlport\config\stl_msvc.h\r
        #if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 )\r
                #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER)\r
                        #ifdef SS_ANSI\r
                                #pragma schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!)\r
                        #endif\r
                #endif\r
                #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc)\r
        #elif defined(_MSC_VER )\r
        #define SS_USE_FACET(loc, fac) std::_USE(loc, fac)\r
\r
        // ...and\r
        #elif defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)\r
        #define SS_USE_FACET(loc, fac) std::use_facet(loc, (fac*)0)\r
        #else\r
                #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc)\r
        #endif\r
#endif\r
\r
// =============================================================================\r
// UNICODE/MBCS conversion macros.  Made to work just like the MFC/ATL ones.\r
// =============================================================================\r
\r
#include <wchar.h>      // Added to Std Library with Amendment #1.\r
\r
// First define the conversion helper functions.  We define these regardless of\r
// any preprocessor macro settings since their names won't collide. \r
\r
// Not sure if we need all these headers.   I believe ANSI says we do.\r
\r
#include <stdio.h>\r
#include <stdarg.h>\r
#include <wctype.h>\r
#include <ctype.h>\r
#include <stdlib.h>\r
#ifndef va_start\r
        #include <varargs.h>\r
#endif\r
\r
// StdCodeCvt - made to look like Win32 functions WideCharToMultiByte\r
//                              and MultiByteToWideChar but uses locales in SS_ANSI\r
//                              builds\r
//typedef int mbstate_t;\r
#if defined (SS_ANSI) || !defined (SS_WIN32)\r
\r
    typedef std::codecvt<wchar_t, char, std::mbstate_t> SSCodeCvt;\r
\r
\r
    inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars,\r
        const std::locale& loc=std::locale())\r
    {\r
        ASSERT(0 != pA);\r
        ASSERT(0 != pW);\r
        pW[0] = '\0';\r
        PCSTR pBadA                             = 0;\r
        PWSTR pBadW                             = 0;\r
        SSCodeCvt::result res   = SSCodeCvt::ok;\r
        const SSCodeCvt& conv   = SS_USE_FACET(loc, SSCodeCvt);\r
        SSCodeCvt::state_type st= { 0 };\r
        res                                             = conv.in(st,\r
                                                                          pA, pA + nChars, pBadA,\r
                                                                          pW, pW + nChars, pBadW);\r
        ASSERT(SSCodeCvt::ok == res);\r
        return pW;\r
    }\r
    inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars,\r
        const std::locale& loc=std::locale())\r
    {\r
        return StdCodeCvt(pW, (PCSTR)pA, nChars, loc);\r
    }\r
\r
    inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars,\r
        const std::locale& loc=std::locale())\r
    {\r
        ASSERT(0 != pA);\r
        ASSERT(0 != pW);\r
        pA[0] = '\0';\r
        PSTR pBadA                              = 0;\r
        PCWSTR pBadW                    = 0;\r
        SSCodeCvt::result res   = SSCodeCvt::ok;\r
        const SSCodeCvt& conv   = SS_USE_FACET(loc, SSCodeCvt);\r
        SSCodeCvt::state_type st= { 0 };\r
        res                                             = conv.out(st,\r
                                                                           pW, pW + nChars, pBadW,\r
                                                                           pA, pA + nChars, pBadA);\r
        ASSERT(SSCodeCvt::ok == res);\r
        return pA;\r
    }\r
    inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars,\r
        const std::locale& loc=std::locale())\r
    {\r
        return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, loc);\r
    }\r
\r
#else   // ...or are we doing things assuming win32 and Visual C++?\r
\r
        #include <malloc.h>     // needed for _alloca\r
\r
        inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars, UINT acp=CP_ACP)\r
        {\r
                ASSERT(0 != pA);\r
                ASSERT(0 != pW);\r
                pW[0] = '\0';\r
                MultiByteToWideChar(acp, 0, pA, -1, pW, nChars);\r
                return pW;\r
        }\r
        inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars, UINT acp=CP_ACP)\r
        {\r
                return StdCodeCvt(pW, (PCSTR)pA, nChars, acp);\r
        }\r
\r
        inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)\r
        {\r
                ASSERT(0 != pA);\r
                ASSERT(0 != pW);\r
                pA[0] = '\0';\r
                WideCharToMultiByte(acp, 0, pW, -1, pA, nChars, 0, 0);\r
                return pA;\r
        }\r
        inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)\r
        {\r
                return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, acp);\r
        }\r
\r
#endif\r
// Unicode/MBCS conversion macros are only available on implementations of\r
// the "C" library that have the non-standard _alloca function.  As far as I\r
// know that's only Microsoft's though I've hear that the function exits\r
// elsewhere.  \r
    \r
#if defined(SS_ALLOCA) && !defined SS_NO_CONVERSION\r
\r
    #include <malloc.h> // needed for _alloca\r
\r
\r
    // Define our conversion macros to look exactly like Microsoft's to\r
    // facilitate using this stuff both with and without MFC/ATL\r
\r
    #ifdef _CONVERSION_USES_THREAD_LOCALE\r
            #ifndef _DEBUG\r
                    #define SSCVT int _cvt; _cvt; UINT _acp=GetACP(); \\r
                            _acp; PCWSTR _pw; _pw; PCSTR _pa; _pa\r
            #else\r
                    #define SSCVT int _cvt = 0; _cvt; UINT _acp=GetACP();\\r
                             _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa\r
            #endif\r
    #else\r
            #ifndef _DEBUG\r
                    #define SSCVT int _cvt; _cvt; UINT _acp=CP_ACP; _acp;\\r
                             PCWSTR _pw; _pw; PCSTR _pa; _pa\r
            #else\r
                    #define SSCVT int _cvt = 0; _cvt; UINT _acp=CP_ACP; \\r
                            _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa\r
            #endif\r
    #endif\r
\r
    #ifdef _CONVERSION_USES_THREAD_LOCALE\r
            #define SSA2W(pa) (\\r
                    ((_pa = pa) == 0) ? 0 : (\\r
                            _cvt = (sslen(_pa)+1),\\r
                            StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt, _acp)))\r
            #define SSW2A(pw) (\\r
                    ((_pw = pw) == 0) ? 0 : (\\r
                            _cvt = (sslen(_pw)+1)*2,\\r
                            StdW2AHelper((LPSTR) _alloca(_cvt), _pw, _cvt, _acp)))\r
    #else\r
            #define SSA2W(pa) (\\r
                    ((_pa = pa) == 0) ? 0 : (\\r
                            _cvt = (sslen(_pa)+1),\\r
                            StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt)))\r
            #define SSW2A(pw) (\\r
                    ((_pw = pw) == 0) ? 0 : (\\r
                            _cvt = (sslen(_pw)+1)*2,\\r
                            StdCodeCvt((LPSTR) _alloca(_cvt), _pw, _cvt)))\r
    #endif\r
\r
    #define SSA2CW(pa) ((PCWSTR)SSA2W((pa)))\r
    #define SSW2CA(pw) ((PCSTR)SSW2A((pw)))\r
\r
    #ifdef UNICODE\r
            #define SST2A       SSW2A\r
            #define SSA2T       SSA2W\r
            #define SST2CA      SSW2CA\r
            #define SSA2CT      SSA2CW\r
            inline PWSTR        SST2W(PTSTR p)                  { return p; }\r
            inline PTSTR        SSW2T(PWSTR p)                  { return p; }\r
            inline PCWSTR       SST2CW(PCTSTR p)                { return p; }\r
            inline PCTSTR       SSW2CT(PCWSTR p)                { return p; }\r
    #else\r
            #define SST2W       SSA2W\r
            #define SSW2T       SSW2A\r
            #define SST2CW      SSA2CW\r
            #define SSW2CT      SSW2CA\r
            inline PSTR         SST2A(PTSTR p)                  { return p; }\r
            inline PTSTR        SSA2T(PSTR p)                   { return p; }\r
            inline PCSTR        SST2CA(PCTSTR p)                { return p; }\r
            inline PCTSTR       SSA2CT(PCSTR p)                 { return p; }\r
    #endif // #ifdef UNICODE\r
\r
    #if defined(UNICODE)\r
    // in these cases the default (TCHAR) is the same as OLECHAR\r
            inline PCOLESTR     SST2COLE(PCTSTR p)              { return p; }\r
            inline PCTSTR       SSOLE2CT(PCOLESTR p)    { return p; }\r
            inline POLESTR      SST2OLE(PTSTR p)                { return p; }\r
            inline PTSTR        SSOLE2T(POLESTR p)              { return p; }\r
    #elif defined(OLE2ANSI)\r
    // in these cases the default (TCHAR) is the same as OLECHAR\r
            inline PCOLESTR     SST2COLE(PCTSTR p)              { return p; }\r
            inline PCTSTR       SSOLE2CT(PCOLESTR p)    { return p; }\r
            inline POLESTR      SST2OLE(PTSTR p)                { return p; }\r
            inline PTSTR        SSOLE2T(POLESTR p)              { return p; }\r
    #else\r
            //CharNextW doesn't work on Win95 so we use this\r
            #define SST2COLE(pa)        SSA2CW((pa))\r
            #define SST2OLE(pa)         SSA2W((pa))\r
            #define SSOLE2CT(po)        SSW2CA((po))\r
            #define SSOLE2T(po)         SSW2A((po))\r
    #endif\r
\r
    #ifdef OLE2ANSI\r
            #define SSW2OLE             SSW2A\r
            #define SSOLE2W             SSA2W\r
            #define SSW2COLE    SSW2CA\r
            #define SSOLE2CW    SSA2CW\r
            inline POLESTR              SSA2OLE(PSTR p)         { return p; }\r
            inline PSTR                 SSOLE2A(POLESTR p)      { return p; }\r
            inline PCOLESTR             SSA2COLE(PCSTR p)       { return p; }\r
            inline PCSTR                SSOLE2CA(PCOLESTR p){ return p; }\r
    #else\r
            #define SSA2OLE             SSA2W\r
            #define SSOLE2A             SSW2A\r
            #define SSA2COLE    SSA2CW\r
            #define SSOLE2CA    SSW2CA\r
            inline POLESTR              SSW2OLE(PWSTR p)        { return p; }\r
            inline PWSTR                SSOLE2W(POLESTR p)      { return p; }\r
            inline PCOLESTR             SSW2COLE(PCWSTR p)      { return p; }\r
            inline PCWSTR               SSOLE2CW(PCOLESTR p){ return p; }\r
    #endif\r
\r
    // Above we've defined macros that look like MS' but all have\r
    // an 'SS' prefix.  Now we need the real macros.  We'll either\r
    // get them from the macros above or from MFC/ATL. \r
\r
        #if defined (USES_CONVERSION)\r
\r
                #define _NO_STDCONVERSION       // just to be consistent\r
\r
        #else\r
\r
                #ifdef _MFC_VER\r
\r
                        #include <afxconv.h>\r
                        #define _NO_STDCONVERSION // just to be consistent\r
\r
                #else\r
\r
                        #define USES_CONVERSION SSCVT\r
                        #define A2CW                    SSA2CW\r
                        #define W2CA                    SSW2CA\r
                        #define T2A                             SST2A\r
                        #define A2T                             SSA2T\r
                        #define T2W                             SST2W\r
                        #define W2T                             SSW2T\r
                        #define T2CA                    SST2CA\r
                        #define A2CT                    SSA2CT\r
                        #define T2CW                    SST2CW\r
                        #define W2CT                    SSW2CT\r
                        #define ocslen                  sslen\r
                        #define ocscpy                  sscpy\r
                        #define T2COLE                  SST2COLE\r
                        #define OLE2CT                  SSOLE2CT\r
                        #define T2OLE                   SST2COLE\r
                        #define OLE2T                   SSOLE2CT\r
                        #define A2OLE                   SSA2OLE\r
                        #define OLE2A                   SSOLE2A\r
                        #define W2OLE                   SSW2OLE\r
                        #define OLE2W                   SSOLE2W\r
                        #define A2COLE                  SSA2COLE\r
                        #define OLE2CA                  SSOLE2CA\r
                        #define W2COLE                  SSW2COLE\r
                        #define OLE2CW                  SSOLE2CW\r
        \r
                #endif // #ifdef _MFC_VER\r
        #endif // #ifndef USES_CONVERSION\r
#endif // #ifndef SS_NO_CONVERSION\r
\r
// Define ostring - generic name for std::basic_string<OLECHAR>\r
\r
#if !defined(ostring) && !defined(OSTRING_DEFINED)\r
        typedef std::basic_string<OLECHAR> ostring;\r
        #define OSTRING_DEFINED\r
#endif\r
\r
// StdCodeCvt when there's no conversion to be done\r
inline PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, int nChars)\r
{\r
        if ( nChars > 0 )\r
        {\r
                pDst[0]                         = '\0';\r
                std::basic_string<char>::traits_type::copy(pDst, pSrc, nChars);\r
//              std::char_traits<char>::copy(pDst, pSrc, nChars);\r
                if ( nChars > 0 )\r
                        pDst[nChars]    = '\0';\r
        }\r
\r
        return pDst;\r
}\r
inline PSTR StdCodeCvt(PSTR pDst, PCUSTR pSrc, int nChars)\r
{\r
        return StdCodeCvt(pDst, (PCSTR)pSrc, nChars);\r
}\r
inline PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, int nChars)\r
{\r
        return (PUSTR)StdCodeCvt((PSTR)pDst, pSrc, nChars);\r
}\r
\r
inline PWSTR StdCodeCvt(PWSTR pDst, PCWSTR pSrc, int nChars)\r
{\r
        if ( nChars > 0 )\r
        {\r
                pDst[0]                         = '\0';\r
                std::basic_string<wchar_t>::traits_type::copy(pDst, pSrc, nChars);\r
//              std::char_traits<wchar_t>::copy(pDst, pSrc, nChars);\r
                if ( nChars > 0 )\r
                        pDst[nChars]    = '\0';\r
        }\r
\r
        return pDst;\r
}\r
\r
\r
// Define tstring -- generic name for std::basic_string<TCHAR>\r
\r
#if !defined(tstring) && !defined(TSTRING_DEFINED)\r
        typedef std::basic_string<TCHAR> tstring;\r
        #define TSTRING_DEFINED\r
#endif\r
\r
// a very shorthand way of applying the fix for KB problem Q172398\r
// (basic_string assignment bug)\r
\r
#if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )\r
        #define Q172398(x) (x).erase()\r
#else\r
        #define Q172398(x)\r
#endif\r
\r
// =============================================================================\r
// INLINE FUNCTIONS ON WHICH CSTDSTRING RELIES\r
//\r
// Usually for generic text mapping, we rely on preprocessor macro definitions\r
// to map to string functions.  However the CStdStr<> template cannot use\r
// macro-based generic text mappings because its character types do not get\r
// resolved until template processing which comes AFTER macro processing.  In\r
// other words, UNICODE is of little help to us in the CStdStr template\r
//\r
// Therefore, to keep the CStdStr declaration simple, we have these inline\r
// functions.  The template calls them often.  Since they are inline (and NOT\r
// exported when this is built as a DLL), they will probably be resolved away\r
// to nothing. \r
//\r
// Without these functions, the CStdStr<> template would probably have to broken\r
// out into two, almost identical classes.  Either that or it would be a huge,\r
// convoluted mess, with tons of "if" statements all over the place checking the\r
// size of template parameter CT.\r
// \r
// In several cases, you will see two versions of each function.  One version is\r
// the more portable, standard way of doing things, while the other is the\r
// non-standard, but often significantly faster Visual C++ way.\r
// =============================================================================\r
\r
// If they defined SS_NO_REFCOUNT, then we must convert all assignments\r
\r
#ifdef SS_NO_REFCOUNT\r
        #define SSREF(x) (x).c_str()\r
#else\r
        #define SSREF(x) (x)\r
#endif\r
\r
// -----------------------------------------------------------------------------\r
// sslen: strlen/wcslen wrappers\r
// -----------------------------------------------------------------------------\r
template<typename CT> inline int sslen(const CT* pT)\r
{\r
        return 0 == pT ? 0 : std::basic_string<CT>::traits_type::length(pT);\r
//      return 0 == pT ? 0 : std::char_traits<CT>::length(pT);\r
}\r
inline SS_NOTHROW int sslen(const std::string& s)\r
{\r
        return s.length();\r
}\r
inline SS_NOTHROW int sslen(const std::wstring& s)\r
{\r
        return s.length();\r
}\r
\r
// -----------------------------------------------------------------------------\r
// sstolower/sstoupper -- convert characters to upper/lower case\r
// -----------------------------------------------------------------------------\r
template<typename CT>\r
inline CT sstolower(const CT& t, const std::locale& loc = std::locale())\r
{\r
        return std::tolower<CT>(t, loc);\r
}\r
template<typename CT>\r
inline CT sstoupper(const CT& t, const std::locale& loc = std::locale())\r
{\r
        return std::toupper<CT>(t, loc);\r
}\r
\r
// -----------------------------------------------------------------------------\r
// ssasn: assignment functions -- assign "sSrc" to "sDst"\r
// -----------------------------------------------------------------------------\r
typedef std::string::size_type          SS_SIZETYPE; // just for shorthand, really\r
typedef std::string::pointer            SS_PTRTYPE;  \r
typedef std::wstring::size_type         SW_SIZETYPE;\r
typedef std::wstring::pointer           SW_PTRTYPE;  \r
\r
inline void     ssasn(std::string& sDst, const std::string& sSrc)\r
{\r
        if ( sDst.c_str() != sSrc.c_str() )\r
        {\r
                sDst.erase();\r
                sDst.assign(SSREF(sSrc));\r
        }\r
}\r
inline void     ssasn(std::string& sDst, PCSTR pA)\r
{\r
        // Watch out for NULLs, as always.\r
\r
        if ( 0 == pA )\r
        {\r
                sDst.erase();\r
        }\r
\r
        // If pA actually points to part of sDst, we must NOT erase(), but\r
        // rather take a substring\r
\r
        else if ( pA >= sDst.c_str() && pA <= sDst.c_str() + sDst.size() )\r
        {\r
                sDst =sDst.substr(static_cast<SS_SIZETYPE>(pA-sDst.c_str()));\r
        }\r
\r
        // Otherwise (most cases) apply the assignment bug fix, if applicable\r
        // and do the assignment\r
\r
        else\r
        {\r
                Q172398(sDst);\r
                sDst.assign(pA);\r
        }\r
}\r
inline void     ssasn(std::string& sDst, const std::wstring& sSrc)\r
{\r
        int nLen        = sSrc.size();\r
        sDst.resize(nLen * sizeof(wchar_t) + 1);\r
        StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen);\r
        sDst.resize(nLen);\r
        //sDst.resize(sslen(sDst.c_str()));\r
}\r
inline void     ssasn(std::string& sDst, PCWSTR pW)\r
{\r
        int nLen        = sslen(pW);\r
        sDst.resize(nLen * sizeof(wchar_t) + 1);\r
        StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), pW, nLen);\r
        sDst.resize(nLen);\r
        //sDst.resize(sslen(sDst.c_str()));\r
}\r
inline void ssasn(std::string& sDst, const int nNull)\r
{\r
        UNUSED(nNull);\r
        ASSERT(nNull==0);\r
        sDst.assign("");\r
}       \r
inline void     ssasn(std::wstring& sDst, const std::wstring& sSrc)\r
{\r
        if ( sDst.c_str() != sSrc.c_str() )\r
        {\r
                sDst.erase();\r
                sDst.assign(SSREF(sSrc));\r
        }\r
}\r
inline void     ssasn(std::wstring& sDst, PCWSTR pW)\r
{\r
        // Watch out for NULLs, as always.\r
\r
        if ( 0 == pW )\r
        {\r
                sDst.erase();\r
        }\r
\r
        // If pW actually points to part of sDst, we must NOT erase(), but\r
        // rather take a substring\r
\r
        else if ( pW >= sDst.c_str() && pW <= sDst.c_str() + sDst.size() )\r
        {\r
                sDst = sDst.substr(static_cast<SW_SIZETYPE>(pW-sDst.c_str()));\r
        }\r
\r
        // Otherwise (most cases) apply the assignment bug fix, if applicable\r
        // and do the assignment\r
\r
        else\r
        {\r
                Q172398(sDst);\r
                sDst.assign(pW);\r
        }\r
}\r
#undef StrSizeType\r
inline void     ssasn(std::wstring& sDst, const std::string& sSrc)\r
{\r
        int nLen        = sSrc.size();\r
        sDst.resize(nLen+1);\r
        StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen+1);\r
        sDst.resize(sslen(sDst.c_str()));\r
}\r
inline void     ssasn(std::wstring& sDst, PCSTR pA)\r
{\r
        int nLen        = sslen(pA);\r
        sDst.resize(nLen+1);\r
        StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), pA, nLen+1);\r
        sDst.resize(sslen(sDst.c_str()));\r
}\r
inline void ssasn(std::wstring& sDst, const int nNull)\r
{\r
        UNUSED(nNull);\r
        ASSERT(nNull==0);\r
        sDst.assign(L"");\r
}\r
\r
\r
// -----------------------------------------------------------------------------\r
// ssadd: string object concatenation -- add second argument to first\r
// -----------------------------------------------------------------------------\r
inline void     ssadd(std::string& sDst, const std::wstring& sSrc)\r
{\r
        int nSrcLen     = sSrc.size();\r
        int nDstLen     = sDst.size();\r
        int nEndLen     = nSrcLen + nDstLen;\r
        sDst.resize(nEndLen + 1);\r
        StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nDstLen), sSrc.c_str(), nSrcLen);\r
        sDst.resize(nEndLen);\r
}\r
inline void     ssadd(std::string& sDst, const std::string& sSrc)\r
{\r
        if ( &sDst == &sSrc )\r
                sDst.reserve(2*sDst.size());\r
\r
        sDst.append(sSrc.c_str());\r
}\r
inline void     ssadd(std::string& sDst, PCWSTR pW)\r
{\r
        int nSrcLen     = sslen(pW);\r
        int nDstLen     = sDst.size();\r
        int nEndLen     = nSrcLen + nDstLen;\r
        sDst.resize(nEndLen + 1);\r
        StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nDstLen), pW, nSrcLen+1);\r
        sDst.resize(nEndLen);\r
}\r
inline void     ssadd(std::string& sDst, PCSTR pA)\r
{\r
        if ( pA )\r
        {\r
                // If the string being added is our internal string or a part of our\r
                // internal string, then we must NOT do any reallocation without\r
                // first copying that string to another object (since we're using a\r
                // direct pointer)\r
\r
                if ( pA >= sDst.c_str() && pA <= sDst.c_str()+sDst.length())\r
                {\r
                        if ( sDst.capacity() <= sDst.size()+sslen(pA) )\r
                                sDst.append(std::string(pA));\r
                        else\r
                                sDst.append(pA);\r
                }\r
                else\r
                {\r
                        sDst.append(pA); \r
                }\r
        }\r
}\r
inline void     ssadd(std::wstring& sDst, const std::wstring& sSrc)\r
{\r
        if ( &sDst == &sSrc )\r
                sDst.reserve(2*sDst.size());\r
\r
        sDst.append(sSrc.c_str());\r
}\r
inline void     ssadd(std::wstring& sDst, const std::string& sSrc)\r
{\r
        int nSrcLen     = sSrc.size();\r
        int nDstLen     = sDst.size();\r
        int nEndLen     = nSrcLen + nDstLen;\r
        sDst.resize(nEndLen+1);\r
        StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nDstLen), sSrc.c_str(), nSrcLen+1);\r
        sDst.resize(nEndLen);\r
}\r
inline void     ssadd(std::wstring& sDst, PCSTR pA)\r
{\r
        int nSrcLen     = sslen(pA);\r
        int nDstLen     = sDst.size();\r
        int nEndLen     = nSrcLen + nDstLen;\r
        sDst.resize(nEndLen + 1);\r
        StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nDstLen), pA, nSrcLen+1);\r
        sDst.resize(nEndLen);\r
}\r
inline void     ssadd(std::wstring& sDst, PCWSTR pW)\r
{\r
        if ( pW )\r
        {\r
                // If the string being added is our internal string or a part of our\r
                // internal string, then we must NOT do any reallocation without\r
                // first copying that string to another object (since we're using a\r
                // direct pointer)\r
\r
                if ( pW >= sDst.c_str() && pW <= sDst.c_str()+sDst.length())\r
                {\r
                        if ( sDst.capacity() <= sDst.size()+sslen(pW) )\r
                                sDst.append(std::wstring(pW));\r
                        else\r
                                sDst.append(pW);\r
                }\r
                else\r
                {\r
                        sDst.append(pW);\r
                }\r
        }\r
}\r
\r
\r
// -----------------------------------------------------------------------------\r
// ssicmp: comparison (case insensitive )\r
// -----------------------------------------------------------------------------\r
template<typename CT>\r
inline int ssicmp(const CT* pA1, const CT* pA2)\r
{\r
    std::locale loc;\r
    const std::ctype<CT>& ct = SS_USE_FACET(loc, std::ctype<CT>);\r
    CT f;\r
    CT l;\r
\r
    do \r
    {\r
            f = ct.tolower(*(pA1++));\r
            l = ct.tolower(*(pA2++));\r
    } while ( (f) && (f == l) );\r
\r
    return (int)(f - l);\r
}\r
\r
// -----------------------------------------------------------------------------\r
// ssupr/sslwr: Uppercase/Lowercase conversion functions\r
// -----------------------------------------------------------------------------\r
\r
template<typename CT>\r
inline void sslwr(CT* pT, size_t nLen)\r
{\r
        SS_USE_FACET(std::locale(), std::ctype<CT>).tolower(pT, pT+nLen);\r
}\r
template<typename CT>\r
inline void ssupr(CT* pT, size_t nLen)\r
{\r
        SS_USE_FACET(std::locale(), std::ctype<CT>).toupper(pT, pT+nLen);\r
}\r
\r
\r
// -----------------------------------------------------------------------------\r
//  vsprintf/vswprintf or _vsnprintf/_vsnwprintf equivalents.  In standard\r
//  builds we can't use _vsnprintf/_vsnwsprintf because they're MS extensions.\r
// -----------------------------------------------------------------------------\r
#if defined(SS_ANSI) || !defined(_MSC_VER)\r
\r
    // Borland's headers put some ANSI "C" functions in the 'std' namespace.\r
    // Promote them to the global namespace so we can use them here.\r
\r
    #if defined(__BORLANDC__)\r
        using std::vsprintf;\r
        using std::vswprintf;\r
    #endif\r
        inline int ssvsprintf(PSTR pA, size_t /*nCount*/, PCSTR pFmtA, va_list vl)\r
        {\r
                return vsprintf(pA, pFmtA, vl);\r
        }\r
        inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl)\r
        {\r
                // JMO: Some distributions of the "C" have a version of vswprintf that\r
        // takes 3 arguments (e.g. Microsoft, Borland, GNU).  Others have a \r
        // version which takes 4 arguments (an extra "count" argument in the\r
        // second position.  The best stab I can take at this so far is that if\r
        // you are NOT running with MS, Borland, or GNU, then I'll assume you\r
        // have the version that takes 4 arguments.\r
        //\r
        // I'm sure that these checks don't catch every platform correctly so if\r
        // you get compiler errors on one of the lines immediately below, it's\r
        // probably because your implemntation takes a different number of\r
        // arguments.  You can comment out the offending line (and use the\r
        // alternate version) or you can figure out what compiler flag to check\r
        // and add that preprocessor check in.  Regardless, if you get an error\r
        // on these lines, I'd sure like to hear from you about it.\r
        //\r
        // Thanks to Ronny Schulz for the SGI-specific checks here.\r
\r
//      #if !defined(__MWERKS__) && !defined(__SUNPRO_CC_COMPAT) && !defined(__SUNPRO_CC)\r
    #if    !defined(_MSC_VER) \\r
        && !defined (__BORLANDC__) \\r
        && !defined(__GNUC__) \\r
        && !defined(__sgi)\r
\r
        return vswprintf(pW, nCount, pFmtW, vl);\r
\r
    // suddenly with the current SGI 7.3 compiler there is no such function as\r
    // vswprintf and the substitute needs explicit casts to compile\r
\r
    #elif defined(__sgi)\r
\r
        nCount;\r
        return vsprintf( (char *)pW, (char *)pFmtW, vl);\r
\r
    #else\r
\r
        nCount;\r
        return vswprintf(pW, pFmtW, vl);\r
\r
    #endif\r
\r
        }\r
#else\r
        inline int      ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl)\r
        {\r
                return _vsnprintf(pA, nCount, pFmtA, vl);\r
        }\r
        inline int      ssnprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl)\r
        {\r
                return _vsnwprintf(pW, nCount, pFmtW, vl);\r
        }\r
#endif\r
\r
\r
\r
// -----------------------------------------------------------------------------\r
// ssload: Type safe, overloaded ::LoadString wrappers\r
// There is no equivalent of these in non-Win32-specific builds.  However, I'm\r
// thinking that with the message facet, there might eventually be one\r
// -----------------------------------------------------------------------------\r
#if defined (SS_WIN32) && !defined(SS_ANSI)\r
        inline int ssload(HMODULE hInst, UINT uId, PSTR pBuf, int nMax)\r
        {\r
                return ::LoadStringA(hInst, uId, pBuf, nMax);\r
        }\r
        inline int ssload(HMODULE hInst, UINT uId, PWSTR pBuf, int nMax)\r
        {\r
                return ::LoadStringW(hInst, uId, pBuf, nMax);\r
        }\r
#endif\r
\r
\r
// -----------------------------------------------------------------------------\r
// sscoll/ssicoll: Collation wrappers\r
//              Note -- with MSVC I have reversed the arguments order here because the\r
//              functions appear to return the opposite of what they should\r
// -----------------------------------------------------------------------------\r
template <typename CT>\r
inline int sscoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2)\r
{\r
        const std::collate<CT>& coll =\r
                SS_USE_FACET(std::locale(), std::collate<CT>);\r
\r
        return coll.compare(sz2, sz2+nLen2, sz1, sz1+nLen1);\r
}\r
template <typename CT>\r
inline int ssicoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2)\r
{\r
        const std::locale loc;\r
        const std::collate<CT>& coll = SS_USE_FACET(loc, std::collate<CT>);\r
\r
        // Some implementations seem to have trouble using the collate<>\r
        // facet typedefs so we'll just default to basic_string and hope\r
        // that's what the collate facet uses (which it generally should)\r
\r
//      std::collate<CT>::string_type s1(sz1);\r
//      std::collate<CT>::string_type s2(sz2);\r
        const std::basic_string<CT> sEmpty;\r
    std::basic_string<CT> s1(sz1 ? sz1 : sEmpty.c_str());\r
    std::basic_string<CT> s2(sz2 ? sz2 : sEmpty.c_str());\r
\r
        sslwr(const_cast<CT*>(s1.c_str()), nLen1);\r
        sslwr(const_cast<CT*>(s2.c_str()), nLen2);\r
        return coll.compare(s2.c_str(), s2.c_str()+nLen2,\r
                                                s1.c_str(), s1.c_str()+nLen1);\r
}\r
\r
\r
// -----------------------------------------------------------------------------\r
// ssfmtmsg: FormatMessage equivalents.  Needed because I added a CString facade\r
// Again -- no equivalent of these on non-Win32 builds but their might one day\r
// be one if the message facet gets implemented\r
// -----------------------------------------------------------------------------\r
#if defined (SS_WIN32) && !defined(SS_ANSI)\r
        inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId,\r
                                                  DWORD dwLangId, PSTR pBuf, DWORD nSize,\r
                                                  va_list* vlArgs)\r
        { \r
                return FormatMessageA(dwFlags, pSrc, dwMsgId, dwLangId,\r
                                                          pBuf, nSize,vlArgs);\r
        }\r
        inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId,\r
                                                  DWORD dwLangId, PWSTR pBuf, DWORD nSize,\r
                                                  va_list* vlArgs)\r
        {\r
                return FormatMessageW(dwFlags, pSrc, dwMsgId, dwLangId,\r
                                                          pBuf, nSize,vlArgs);\r
        }\r
#else\r
#endif\r
 \r
\r
\r
// FUNCTION: sscpy.  Copies up to 'nMax' characters from pSrc to pDst.\r
// -----------------------------------------------------------------------------\r
// FUNCTION:  sscpy\r
//              inline int sscpy(PSTR pDst, PCSTR pSrc, int nMax=-1);\r
//              inline int sscpy(PUSTR pDst,  PCSTR pSrc, int nMax=-1)\r
//              inline int sscpy(PSTR pDst, PCWSTR pSrc, int nMax=-1);\r
//              inline int sscpy(PWSTR pDst, PCWSTR pSrc, int nMax=-1);\r
//              inline int sscpy(PWSTR pDst, PCSTR pSrc, int nMax=-1);\r
//\r
// DESCRIPTION:\r
//              This function is very much (but not exactly) like strcpy.  These\r
//              overloads simplify copying one C-style string into another by allowing\r
//              the caller to specify two different types of strings if necessary.\r
//\r
//              The strings must NOT overlap\r
//\r
//              "Character" is expressed in terms of the destination string, not\r
//              the source.  If no 'nMax' argument is supplied, then the number of\r
//              characters copied will be sslen(pSrc).  A NULL terminator will\r
//              also be added so pDst must actually be big enough to hold nMax+1\r
//              characters.  The return value is the number of characters copied,\r
//              not including the NULL terminator.\r
//\r
// PARAMETERS: \r
//              pSrc - the string to be copied FROM.  May be a char based string, an\r
//                         MBCS string (in Win32 builds) or a wide string (wchar_t).\r
//              pSrc - the string to be copied TO.  Also may be either MBCS or wide\r
//              nMax - the maximum number of characters to be copied into szDest.  Note\r
//                         that this is expressed in whatever a "character" means to pDst.\r
//                         If pDst is a wchar_t type string than this will be the maximum\r
//                         number of wchar_ts that my be copied.  The pDst string must be\r
//                         large enough to hold least nMaxChars+1 characters.\r
//                         If the caller supplies no argument for nMax this is a signal to\r
//                         the routine to copy all the characters in pSrc, regardless of\r
//                         how long it is.\r
//\r
// RETURN VALUE: none\r
// -----------------------------------------------------------------------------\r
template<typename CT1, typename CT2>\r
inline int sscpycvt(CT1* pDst, const CT2* pSrc, int nChars)\r
{\r
        StdCodeCvt(pDst, pSrc, nChars);\r
        pDst[SSMAX(nChars, 0)]  = '\0';\r
        return nChars;\r
}\r
\r
template<typename CT1, typename CT2>\r
inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax, int nLen)\r
{\r
        return sscpycvt(pDst, pSrc, SSMIN(nMax, nLen));\r
}\r
template<typename CT1, typename CT2>\r
inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax)\r
{\r
        return sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc)));\r
}\r
template<typename CT1, typename CT2>\r
inline int sscpy(CT1* pDst, const CT2* pSrc)\r
{\r
        return sscpycvt(pDst, pSrc, sslen(pSrc));\r
}\r
template<typename CT1, typename CT2>\r
inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc, int nMax)\r
{\r
        return sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (int)sSrc.length()));\r
}\r
template<typename CT1, typename CT2>\r
inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc)\r
{\r
        return sscpycvt(pDst, sSrc.c_str(), (int)sSrc.length());\r
}\r
\r
#ifdef SS_INC_COMDEF\r
        template<typename CT1>\r
        inline int sscpy(CT1* pDst, const _bstr_t& bs, int nMax)\r
        {\r
                return sscpycvt(pDst, static_cast<PCOLESTR>(bs),\r
            SSMIN(nMax, static_cast<int>(bs.length())));\r
        }\r
        template<typename CT1>\r
        inline int sscpy(CT1* pDst, const _bstr_t& bs)\r
        {\r
                return sscpy(pDst, bs, static_cast<int>(bs.length()));\r
        }\r
#endif\r
\r
\r
// -----------------------------------------------------------------------------\r
// Functional objects for changing case.  They also let you pass locales\r
// -----------------------------------------------------------------------------\r
\r
#ifdef SS_ANSI\r
    template<typename CT>\r
    struct SSToUpper : public std::binary_function<CT, std::locale, CT>\r
    {\r
            inline CT operator()(const CT& t, const std::locale& loc) const\r
            {\r
                    return sstoupper<CT>(t, loc);\r
            }\r
    };\r
    template<typename CT>\r
    struct SSToLower : public std::binary_function<CT, std::locale, CT>\r
    {\r
            inline CT operator()(const CT& t, const std::locale& loc) const\r
            {\r
                    return sstolower<CT>(t, loc);\r
            }\r
    };\r
#endif\r
\r
// This struct is used for TrimRight() and TrimLeft() function implementations.\r
//template<typename CT>\r
//struct NotSpace : public std::unary_function<CT, bool>\r
//{\r
//      const std::locale& loc;\r
//      inline NotSpace(const std::locale& locArg) : loc(locArg) {}\r
//      inline bool operator() (CT t) { return !std::isspace(t, loc); }\r
//};\r
template<typename CT>\r
struct NotSpace : public std::unary_function<CT, bool>\r
{\r
\r
        // DINKUMWARE BUG:\r
        // Note -- using std::isspace in a COM DLL gives us access violations\r
        // because it causes the dynamic addition of a function to be called\r
        // when the library shuts down.  Unfortunately the list is maintained\r
        // in DLL memory but the function is in static memory.  So the COM DLL\r
        // goes away along with the function that was supposed to be called,\r
        // and then later when the DLL CRT shuts down it unloads the list and\r
        // tries to call the long-gone function.\r
        // This is DinkumWare's implementation problem.  Until then, we will\r
        // use good old isspace and iswspace from the CRT unless they\r
        // specify SS_ANSI\r
    \r
        const std::locale loc;\r
        NotSpace(const std::locale& locArg=std::locale()) : loc(locArg) {}\r
        bool operator() (CT t) const { return !std::isspace(t, loc); }\r
};\r
\r
\r
\r
\r
//                      Now we can define the template (finally!)\r
// =============================================================================\r
// TEMPLATE: CStdStr\r
//              template<typename CT> class CStdStr : public std::basic_string<CT>\r
//\r
// REMARKS:\r
//              This template derives from basic_string<CT> and adds some MFC CString-\r
//              like functionality\r
//\r
//              Basically, this is my attempt to make Standard C++ library strings as\r
//              easy to use as the MFC CString class.\r
//\r
//              Note that although this is a template, it makes the assumption that the\r
//              template argument (CT, the character type) is either char or wchar_t.  \r
// =============================================================================\r
\r
//#define CStdStr _SS   // avoid compiler warning 4786\r
\r
//    template<typename ARG> ARG& FmtArg(ARG& arg)  { return arg; }\r
//    PCSTR  FmtArg(const std::string& arg)  { return arg.c_str(); }\r
//    PCWSTR FmtArg(const std::wstring& arg) { return arg.c_str(); }\r
\r
template<typename ARG>\r
struct FmtArg\r
{\r
    explicit FmtArg(const ARG& arg) : a_(arg) {}\r
    const ARG& Val() const { return a_; }\r
    const ARG& a_;\r
private:\r
    FmtArg& operator=(const FmtArg&) { return *this; }\r
};\r
\r
template<typename CT>\r
class CStdStr : public std::basic_string<CT>\r
{\r
        // Typedefs for shorter names.  Using these names also appears to help\r
        // us avoid some ambiguities that otherwise arise on some platforms\r
\r
        typedef typename std::basic_string<CT>          MYBASE;  // my base class\r
        typedef CStdStr<CT>                                                     MYTYPE;  // myself\r
        typedef typename MYBASE::const_pointer          PCMYSTR; // PCSTR or PCWSTR \r
        typedef typename MYBASE::pointer                        PMYSTR;  // PSTR or PWSTR\r
        typedef typename MYBASE::iterator                       MYITER;  // my iterator type\r
        typedef typename MYBASE::const_iterator         MYCITER; // you get the idea...\r
        typedef typename MYBASE::reverse_iterator       MYRITER;\r
        typedef typename MYBASE::size_type                      MYSIZE;   \r
        typedef typename MYBASE::value_type                     MYVAL; \r
        typedef typename MYBASE::allocator_type         MYALLOC;\r
        \r
public:\r
\r
        // shorthand conversion from PCTSTR to string resource ID\r
        #define _TRES(pctstr) (LOWORD((DWORD)(pctstr))) \r
\r
        // CStdStr inline constructors\r
        CStdStr()\r
        {\r
        }\r
\r
        CStdStr(const MYTYPE& str) : MYBASE(SSREF(str))\r
        {\r
        }\r
\r
        CStdStr(const std::string& str)\r
        {\r
                ssasn(*this, SSREF(str));\r
        }\r
\r
        CStdStr(const std::wstring& str)\r
        {\r
                ssasn(*this, SSREF(str));\r
        }\r
\r
        CStdStr(PCMYSTR pT, MYSIZE n) : MYBASE(pT, n)\r
        {\r
        }\r
\r
#ifdef SS_UNSIGNED\r
        CStdStr(PCUSTR pU)\r
        {\r
                *this = reinterpret_cast<PCSTR>(pU);\r
        }\r
#endif\r
\r
        CStdStr(PCSTR pA)\r
        {\r
        #ifdef SS_ANSI\r
                *this = pA;\r
        #else\r
                if ( 0 != HIWORD(pA) )\r
                        *this = pA;\r
                else if ( 0 != pA && !Load(_TRES(pA)) )\r
                        TRACE(_T("Can't load string %u\n"), _TRES(pA));\r
        #endif\r
        }\r
\r
        CStdStr(PCWSTR pW)\r
        {\r
        #ifdef SS_ANSI\r
                *this = pW;\r
        #else\r
                if ( 0 != HIWORD(pW) )\r
                        *this = pW;\r
                else if ( 0 != pW && !Load(_TRES(pW)) )\r
                        TRACE(_T("Can't load string %u\n"), _TRES(pW));\r
        #endif\r
        }\r
\r
        CStdStr(MYCITER first, MYCITER last)\r
                : MYBASE(first, last)\r
        {\r
        }\r
\r
        CStdStr(MYSIZE nSize, MYVAL ch, const MYALLOC& al=MYALLOC())\r
                : MYBASE(nSize, ch, al)\r
        {\r
        }\r
\r
        #ifdef SS_INC_COMDEF\r
                CStdStr(const _bstr_t& bstr)\r
                {\r
                        if ( bstr.length() > 0 )\r
                                this->append(static_cast<PCMYSTR>(bstr), bstr.length());\r
                }\r
        #endif\r
\r
        // CStdStr inline assignment operators -- the ssasn function now takes care\r
        // of fixing  the MSVC assignment bug (see knowledge base article Q172398).\r
        MYTYPE& operator=(const MYTYPE& str)\r
        { \r
                ssasn(*this, str); \r
                return *this;\r
        }\r
\r
        MYTYPE& operator=(const std::string& str)\r
        {\r
                ssasn(*this, str);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator=(const std::wstring& str)\r
        {\r
                ssasn(*this, str);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator=(PCSTR pA)\r
        {\r
                ssasn(*this, pA);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator=(PCWSTR pW)\r
        {\r
                ssasn(*this, pW);\r
                return *this;\r
        }\r
\r
#ifdef SS_UNSIGNED\r
        MYTYPE& operator=(PCUSTR pU)\r
        {\r
                ssasn(*this, reinterpret_cast<PCSTR>(pU)):\r
                return *this;\r
        }\r
#endif\r
\r
        MYTYPE& operator=(CT t)\r
        {\r
                Q172398(*this);\r
                this->assign(1, t);\r
                return *this;\r
        }\r
\r
        #ifdef SS_INC_COMDEF\r
                MYTYPE& operator=(const _bstr_t& bstr)\r
                {\r
                        if ( bstr.length() > 0 )\r
                        {\r
                                this->assign(static_cast<PCMYSTR>(bstr), bstr.length());\r
                                return *this;\r
                        }\r
                        else\r
                        {\r
                                this->erase();\r
                                return *this;\r
                        }\r
                }\r
        #endif\r
\r
\r
        // Overloads  also needed to fix the MSVC assignment bug (KB: Q172398)\r
        //  *** Thanks to Pete The Plumber for catching this one ***\r
        // They also are compiled if you have explicitly turned off refcounting\r
        #if ( defined(_MSC_VER) && ( _MSC_VER < 1200 ) ) || defined(SS_NO_REFCOUNT) \r
\r
                MYTYPE& assign(const MYTYPE& str)\r
                {\r
                        ssasn(*this, str);\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(const MYTYPE& str, MYSIZE nStart, MYSIZE nChars)\r
                {\r
                        // This overload of basic_string::assign is supposed to assign up to\r
                        // <nChars> or the NULL terminator, whichever comes first.  Since we\r
                        // are about to call a less forgiving overload (in which <nChars>\r
                        // must be a valid length), we must adjust the length here to a safe\r
                        // value.  Thanks to Ullrich Pollähne for catching this bug\r
\r
                        nChars          = SSMIN(nChars, str.length() - nStart);\r
\r
                        // Watch out for assignment to self\r
\r
                        if ( this == &str )\r
                        {\r
                                MYTYPE strTemp(str.c_str()+nStart, nChars);\r
                                MYBASE::assign(strTemp);\r
                        }\r
                        else\r
                        {\r
                                Q172398(*this);\r
                                MYBASE::assign(str.c_str()+nStart, nChars);\r
                        }\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(const MYBASE& str)\r
                {\r
                        ssasn(*this, str);\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(const MYBASE& str, MYSIZE nStart, MYSIZE nChars)\r
                {\r
                        // This overload of basic_string::assign is supposed to assign up to\r
                        // <nChars> or the NULL terminator, whichever comes first.  Since we\r
                        // are about to call a less forgiving overload (in which <nChars>\r
                        // must be a valid length), we must adjust the length here to a safe\r
                        // value. Thanks to Ullrich Pollähne for catching this bug\r
\r
                        nChars          = SSMIN(nChars, str.length() - nStart);\r
\r
                        // Watch out for assignment to self\r
\r
                        if ( this == &str )     // watch out for assignment to self\r
                        {\r
                                MYTYPE strTemp(str.c_str() + nStart, nChars);\r
                                MYBASE::assign(strTemp);\r
                        }\r
                        else\r
                        {\r
                                Q172398(*this);\r
                                MYBASE::assign(str.c_str()+nStart, nChars);\r
                        }\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(const CT* pC, MYSIZE nChars)\r
                {\r
                        // Q172398 only fix -- erase before assigning, but not if we're\r
                        // assigning from our own buffer\r
\r
        #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )\r
                        if ( !this->empty() &&\r
                                ( pC < this->data() || pC > this->data() + this->capacity() ) )\r
                        {\r
                                this->erase();\r
                        }\r
        #endif\r
                        Q172398(*this);\r
                        MYBASE::assign(pC, nChars);\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(MYSIZE nChars, MYVAL val)\r
                {\r
                        Q172398(*this);\r
                        MYBASE::assign(nChars, val);\r
                        return *this;\r
                }\r
\r
                MYTYPE& assign(const CT* pT)\r
                {\r
                        return this->assign(pT, MYBASE::traits_type::length(pT));\r
                }\r
\r
                MYTYPE& assign(MYCITER iterFirst, MYCITER iterLast)\r
                {\r
        #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) \r
                        // Q172398 fix.  don't call erase() if we're assigning from ourself\r
                        if ( iterFirst < this->begin() ||\r
                 iterFirst > this->begin() + this->size() )\r
            {\r
                                this->erase()\r
            }\r
        #endif\r
                        this->replace(this->begin(), this->end(), iterFirst, iterLast);\r
                        return *this;\r
                }\r
        #endif\r
\r
\r
        // -------------------------------------------------------------------------\r
        // CStdStr inline concatenation.\r
        // -------------------------------------------------------------------------\r
        MYTYPE& operator+=(const MYTYPE& str)\r
        {\r
                ssadd(*this, str);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator+=(const std::string& str)\r
        {\r
                ssadd(*this, str);\r
                return *this; \r
        }\r
\r
        MYTYPE& operator+=(const std::wstring& str)\r
        {\r
                ssadd(*this, str);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator+=(PCSTR pA)\r
        {\r
                ssadd(*this, pA);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator+=(PCWSTR pW)\r
        {\r
                ssadd(*this, pW);\r
                return *this;\r
        }\r
\r
        MYTYPE& operator+=(CT t)\r
        {\r
                this->append(1, t);\r
                return *this;\r
        }\r
        #ifdef SS_INC_COMDEF    // if we have _bstr_t, define a += for it too.\r
                MYTYPE& operator+=(const _bstr_t& bstr)\r
                {\r
                        return this->operator+=(static_cast<PCMYSTR>(bstr));\r
                }\r
        #endif\r
\r
\r
        // -------------------------------------------------------------------------\r
        // Case changing functions\r
        // -------------------------------------------------------------------------\r
\r
    MYTYPE& ToUpper()\r
        {\r
                //  Strictly speaking, this would be about the most portable way\r
\r
                //      std::transform(begin(),\r
                //                                 end(),\r
                //                                 begin(),\r
                //                                 std::bind2nd(SSToUpper<CT>(), std::locale()));\r
\r
                // But practically speaking, this works faster\r
\r
                if ( !empty() )\r
                        ssupr(GetBuf(), this->size());\r
\r
                return *this;\r
        }\r
\r
\r
\r
        MYTYPE& ToLower()\r
        {\r
                //  Strictly speaking, this would be about the most portable way\r
\r
                //      std::transform(begin(),\r
                //                                 end(),\r
                //                                 begin(),\r
                //                                 std::bind2nd(SSToLower<CT>(), std::locale()));\r
\r
                // But practically speaking, this works faster\r
\r
                if ( !empty() )\r
                        sslwr(GetBuf(), this->size());\r
\r
                return *this;\r
        }\r
\r
\r
\r
        MYTYPE& Normalize()\r
        {\r
                return Trim().ToLower();\r
        }\r
\r
\r
        // -------------------------------------------------------------------------\r
        // CStdStr -- Direct access to character buffer.  In the MS' implementation,\r
        // the at() function that we use here also calls _Freeze() providing us some\r
        // protection from multithreading problems associated with ref-counting.\r
    // In VC 7 and later, of course, the ref-counting stuff is gone.\r
        // -------------------------------------------------------------------------\r
\r
        CT* GetBuf(int nMinLen=-1)\r
        {\r
                if ( static_cast<int>(size()) < nMinLen )\r
                        this->resize(static_cast<MYSIZE>(nMinLen));\r
\r
                return this->empty() ? const_cast<CT*>(this->data()) : &(this->at(0));\r
        }\r
\r
        CT* SetBuf(int nLen)\r
        {\r
                nLen = ( nLen > 0 ? nLen : 0 );\r
                if ( this->capacity() < 1 && nLen == 0 )\r
                        this->resize(1);\r
\r
                this->resize(static_cast<MYSIZE>(nLen));\r
                return const_cast<CT*>(this->data());\r
        }\r
        void RelBuf(int nNewLen=-1)\r
        {\r
                this->resize(static_cast<MYSIZE>(nNewLen > -1 ? nNewLen :\r
                                                        sslen(this->c_str())));\r
        }\r
\r
        void BufferRel()                 { RelBuf(); }                  // backwards compatability\r
        CT*  Buffer()                    { return GetBuf(); }   // backwards compatability\r
        CT*  BufferSet(int nLen) { return SetBuf(nLen);}// backwards compatability\r
\r
        bool Equals(const CT* pT, bool bUseCase=false) const\r
        {       // get copy, THEN compare (thread safe)\r
                return  bUseCase ? this->compare(pT) == 0 :\r
                           ssicmp(MYTYPE(*this).c_str(), pT) == 0;\r
        } \r
\r
        // -------------------------------------------------------------------------\r
        // FUNCTION:  CStdStr::Load\r
        // REMARKS:\r
        //              Loads string from resource specified by nID\r
        //\r
        // PARAMETERS:\r
        //              nID - resource Identifier.  Purely a Win32 thing in this case\r
        //\r
        // RETURN VALUE:\r
        //              true if successful, false otherwise\r
        // -------------------------------------------------------------------------\r
\r
#ifndef SS_ANSI\r
\r
        bool Load(UINT nId, HMODULE hModule=NULL)\r
        {\r
                bool bLoaded            = false;        // set to true of we succeed.\r
\r
        #ifdef _MFC_VER         // When in Rome (or MFC land)...\r
\r
                CString strRes;\r
                bLoaded                         = FALSE != strRes.LoadString(nId);\r
                if ( bLoaded )\r
                        *this                   = strRes;\r
\r
        #else // otherwise make our own hackneyed version of CString's Load\r
                \r
                // Get the resource name and module handle\r
\r
                if ( NULL == hModule )\r
                        hModule                 = GetResourceHandle();\r
\r
                PCTSTR szName           = MAKEINTRESOURCE((nId>>4)+1); // lifted \r
                DWORD dwSize            = 0;\r
\r
                // No sense continuing if we can't find the resource\r
\r
                HRSRC hrsrc                     = ::FindResource(hModule, szName, RT_STRING);\r
\r
                if ( NULL == hrsrc )\r
                {\r
                        TRACE(_T("Cannot find resource %d: 0x%X"), nId, ::GetLastError());\r
                }\r
                else if ( 0 == (dwSize = ::SizeofResource(hModule, hrsrc) / sizeof(CT)))\r
                {\r
                        TRACE(_T("Cant get size of resource %d 0x%X\n"),nId,GetLastError());\r
                }\r
                else\r
                {\r
                        bLoaded                 = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize);\r
                        ReleaseBuffer();\r
                }\r
\r
        #endif  // #ifdef _MFC_VER\r
\r
                if ( !bLoaded )\r
                        TRACE(_T("String not loaded 0x%X\n"), ::GetLastError());\r
\r
                return bLoaded;\r
        }\r
\r
#endif  // #ifdef SS_ANSI\r
        \r
        // -------------------------------------------------------------------------\r
        // FUNCTION:  CStdStr::Format\r
        //              void _cdecl Formst(CStdStringA& PCSTR szFormat, ...)\r
        //              void _cdecl Format(PCSTR szFormat);\r
        //           \r
        // DESCRIPTION:\r
        //              This function does sprintf/wsprintf style formatting on CStdStringA\r
        //              objects.  It looks a lot like MFC's CString::Format.  Some people\r
        //              might even call this identical.  Fortunately, these people are now\r
        //              dead... heh heh.\r
        //\r
        // PARAMETERS: \r
        //              nId - ID of string resource holding the format string\r
        //              szFormat - a PCSTR holding the format specifiers\r
        //              argList - a va_list holding the arguments for the format specifiers.\r
        //\r
        // RETURN VALUE:  None.\r
        // -------------------------------------------------------------------------\r
        // formatting (using wsprintf style formatting)\r
\r
    // If they want a Format() function that safely handles string objects\r
    // without casting\r
 \r
#ifdef SS_SAFE_FORMAT       \r
    \r
    // Question:  Joe, you wacky coder you, why do you have so many overloads\r
    //      of the Format() function\r
    // Answer:  One reason only - CString compatability.  In short, by making\r
    //      the Format() function a template this way, I can do strong typing\r
    //      and allow people to pass CStdString arguments as fillers for\r
    //      "%s" format specifiers without crashing their program!  The downside\r
    //      is that I need to overload on the number of arguments.   If you are\r
    //      passing more arguments than I have listed below in any of my\r
    //      overloads, just add another one.\r
    //\r
    //      Yes, yes, this is really ugly.  In essence what I am doing here is\r
    //      protecting people from a bad (and incorrect) programming practice\r
    //      that they should not be doing anyway.  I am protecting them from\r
    //      themselves.  Why am I doing this?  Well, if you had any idea the\r
    //      number of times I've been emailed by people about this\r
    //      "incompatability" in my code, you wouldn't ask.\r
\r
        void Fmt(const CT* szFmt, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, szFmt);\r
                FormatV(szFmt, argList);\r
                va_end(argList);\r
        }\r
\r
#ifndef SS_ANSI\r
\r
    void Format(UINT nId)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) ) \r
            this->swap(strFmt);\r
    }\r
    template<class A1>\r
    void Format(UINT nId, const A1& v)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
            Fmt(strFmt, FmtArg<A1>(v).Val());\r
    }\r
    template<class A1, class A2>\r
    void Format(UINT nId, const A1& v1, const A2& v2)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
           Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val());\r
    }\r
    template<class A1, class A2, class A3>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(),FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(),FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
           Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(),FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val(), FmtArg<A13>(v13).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val(), FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
                FmtArg<A15>(v15).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15, class A16>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15,\r
                const A16& v16)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
                FmtArg<A15>(v15).Val(), FmtArg<A16>(v16).Val());\r
        }\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15, class A16, class A17>\r
    void Format(UINT nId, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15,\r
                const A16& v16, const A17& v17)\r
    {\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
        {\r
            Fmt(strFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
                FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
                FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
                FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
                FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
                FmtArg<A15>(v15).Val(),FmtArg<A16>(v16).Val(),FmtArg<A17>(v17).Val());\r
        }\r
    }\r
    \r
#endif // #ifndef SS_ANSI\r
\r
    // ...now the other overload of Format: the one that takes a string literal\r
\r
    void Format(const CT* szFmt)\r
    {\r
        *this = szFmt;\r
    }\r
    template<class A1>\r
    void Format(const CT* szFmt, A1 v)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v).Val());\r
    }\r
    template<class A1, class A2>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val());\r
    }\r
    template<class A1, class A2, class A3>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(),FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val(), FmtArg<A13>(v13).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val(), FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
            FmtArg<A15>(v15).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15, class A16>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15,\r
                const A16& v16)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
            FmtArg<A15>(v15).Val(), FmtArg<A16>(v16).Val());\r
    }\r
    template<class A1, class A2, class A3, class A4, class A5, class A6,\r
        class A7, class A8, class A9, class A10, class A11, class A12,\r
        class A13, class A14, class A15, class A16, class A17>\r
    void Format(const CT* szFmt, const A1& v1, const A2& v2, const A3& v3,\r
                const A4& v4, const A5& v5, const A6& v6, const A7& v7,\r
                const A8& v8, const A9& v9, const A10& v10, const A11& v11,\r
                const A12& v12, const A13& v13, const A14& v14, const A15& v15,\r
                const A16& v16, const A17& v17)\r
    {\r
        Fmt(szFmt, FmtArg<A1>(v1).Val(), FmtArg<A2>(v2).Val(),\r
            FmtArg<A3>(v3).Val(), FmtArg<A4>(v4).Val(), FmtArg<A5>(v5).Val(),\r
            FmtArg<A6>(v6).Val(), FmtArg<A7>(v7).Val(), FmtArg<A8>(v8).Val(),\r
            FmtArg<A9>(v9).Val(), FmtArg<A10>(v10).Val(),FmtArg<A11>(v11).Val(),\r
            FmtArg<A12>(v12).Val(),FmtArg<A13>(v13).Val(),FmtArg<A14>(v14).Val(),\r
            FmtArg<A15>(v15).Val(),FmtArg<A16>(v16).Val(),FmtArg<A17>(v17).Val());\r
    }\r
\r
#else  // #ifdef SS_SAFE_FORMAT\r
\r
\r
#ifndef SS_ANSI\r
\r
        void Format(UINT nId, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, nId);\r
                va_start(argList, nId);\r
\r
                MYTYPE strFmt;\r
                if ( strFmt.Load(nId) )\r
                        FormatV(strFmt, argList);\r
\r
                va_end(argList);\r
        }\r
    \r
#endif  // #ifdef SS_ANSI\r
\r
        void Format(const CT* szFmt, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, szFmt);\r
                FormatV(szFmt, argList);\r
                va_end(argList);\r
        }\r
\r
#endif // #ifdef SS_SAFE_FORMAT\r
\r
        void AppendFormat(const CT* szFmt, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, szFmt);\r
                AppendFormatV(szFmt, argList);\r
                va_end(argList);\r
        }\r
\r
        #define MAX_FMT_TRIES           5        // #of times we try \r
        #define FMT_BLOCK_SIZE          2048 // # of bytes to increment per try\r
        #define BUFSIZE_1ST     256\r
        #define BUFSIZE_2ND 512\r
        #define STD_BUF_SIZE            1024\r
\r
        // an efficient way to add formatted characters to the string.  You may only\r
        // add up to STD_BUF_SIZE characters at a time, though\r
        void AppendFormatV(const CT* szFmt, va_list argList)\r
        {\r
                CT szBuf[STD_BUF_SIZE];\r
        #if defined(SS_ANSI) || !defined(_MSC_VER)\r
                int nLen = ssvsprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList);\r
        #else\r
                int nLen = ssnprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList);\r
        #endif\r
                if ( 0 < nLen )\r
                        this->append(szBuf, nLen);\r
        }\r
\r
        // -------------------------------------------------------------------------\r
        // FUNCTION:  FormatV\r
        //              void FormatV(PCSTR szFormat, va_list, argList);\r
        //           \r
        // DESCRIPTION:\r
        //              This function formats the string with sprintf style format-specs. \r
        //              It makes a general guess at required buffer size and then tries\r
        //              successively larger buffers until it finds one big enough or a\r
        //              threshold (MAX_FMT_TRIES) is exceeded.\r
        //\r
        // PARAMETERS:\r
        //              szFormat - a PCSTR holding the format of the output\r
        //              argList - a Microsoft specific va_list for variable argument lists\r
        //\r
        // RETURN VALUE:\r
        // -------------------------------------------------------------------------\r
\r
        void FormatV(const CT* szFormat, va_list argList)\r
        {\r
        #if defined(SS_ANSI) || !defined(_MSC_VER)\r
                int nLen        = sslen(szFormat) + STD_BUF_SIZE;\r
                ssvsprintf(GetBuffer(nLen), nLen-1, szFormat, argList);\r
                ReleaseBuffer();\r
\r
        #else\r
\r
                CT* pBuf                        = NULL;\r
                int nChars                      = 1;\r
                int nUsed                       = 0;\r
                size_type nActual       = 0;\r
                int nTry                        = 0;\r
\r
                do\r
                {\r
                        // Grow more than linearly (e.g. 512, 1536, 3072, etc)\r
\r
                        nChars                  += ((nTry+1) * FMT_BLOCK_SIZE);\r
                        pBuf                    = reinterpret_cast<CT*>(_alloca(sizeof(CT)*nChars));\r
                        nUsed                   = ssnprintf(pBuf, nChars-1, szFormat, argList);\r
\r
                        // Ensure proper NULL termination.\r
\r
                        nActual                 = nUsed == -1 ? nChars-1 : SSMIN(nUsed, nChars-1);\r
                        pBuf[nActual+1]= '\0';\r
\r
\r
                } while ( nUsed < 0 && nTry++ < MAX_FMT_TRIES );\r
\r
                // assign whatever we managed to format\r
\r
                this->assign(pBuf, nActual);\r
\r
        #endif\r
        }\r
        \r
\r
        // -------------------------------------------------------------------------\r
        // CString Facade Functions:\r
        //\r
        // The following methods are intended to allow you to use this class as a\r
        // drop-in replacement for CString.\r
        // -------------------------------------------------------------------------\r
        #ifdef SS_WIN32\r
                BSTR AllocSysString() const\r
                {\r
                        ostring os;\r
                        ssasn(os, *this);\r
                        return ::SysAllocString(os.c_str());\r
                }\r
        #endif\r
\r
        int Collate(PCMYSTR szThat) const\r
        {\r
                return sscoll(this->c_str(), this->length(), szThat, sslen(szThat));\r
        }\r
\r
        int CollateNoCase(PCMYSTR szThat) const\r
        {\r
                return ssicoll(this->c_str(), this->length(), szThat, sslen(szThat));\r
        }\r
\r
        int Compare(PCMYSTR szThat) const\r
        {\r
                return this->compare(szThat);   \r
        }\r
\r
        int CompareNoCase(PCMYSTR szThat)       const\r
        {\r
                return ssicmp(this->c_str(), szThat);\r
        }\r
\r
        int Delete(int nIdx, int nCount=1)\r
        {\r
        if ( nIdx < 0 )\r
                        nIdx = 0;\r
\r
                if ( nIdx < GetLength() )\r
                        this->erase(static_cast<MYSIZE>(nIdx), static_cast<MYSIZE>(nCount));\r
\r
                return GetLength();\r
        }\r
\r
        void Empty()\r
        {\r
                this->erase();\r
        }\r
\r
        int Find(CT ch) const\r
        {\r
                MYSIZE nIdx     = this->find_first_of(ch);\r
                return static_cast<int>(MYBASE::npos == nIdx  ? -1 : nIdx);\r
        }\r
\r
        int Find(PCMYSTR szSub) const\r
        {\r
                MYSIZE nIdx     = this->find(szSub);\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
        int Find(CT ch, int nStart) const\r
        {\r
                // CString::Find docs say add 1 to nStart when it's not zero\r
                // CString::Find code doesn't do that however.  We'll stick\r
                // with what the code does\r
\r
                MYSIZE nIdx     = this->find_first_of(ch, static_cast<MYSIZE>(nStart));\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
        int Find(PCMYSTR szSub, int nStart) const\r
        {\r
                // CString::Find docs say add 1 to nStart when it's not zero\r
                // CString::Find code doesn't do that however.  We'll stick\r
                // with what the code does\r
\r
                MYSIZE nIdx     = this->find(szSub, static_cast<MYSIZE>(nStart));\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
        int FindOneOf(PCMYSTR szCharSet) const\r
        {\r
                MYSIZE nIdx = this->find_first_of(szCharSet);\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
#ifndef SS_ANSI\r
        void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception)\r
        {\r
                va_list argList;\r
                va_start(argList, szFormat);\r
                PMYSTR szTemp;\r
                if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,\r
                                           szFormat, 0, 0,\r
                                           reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 ||\r
                         szTemp == 0 )\r
                {\r
                        throw std::runtime_error("out of memory");\r
                }\r
                *this = szTemp;\r
                LocalFree(szTemp);\r
                va_end(argList);\r
        }\r
\r
        void FormatMessage(UINT nFormatId, ...) throw(std::exception)\r
        {\r
                MYTYPE sFormat;\r
                VERIFY(sFormat.LoadString(nFormatId) != 0);\r
                va_list argList;\r
                va_start(argList, nFormatId);\r
                PMYSTR szTemp;\r
                if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,\r
                                           sFormat, 0, 0,\r
                                           reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 ||\r
                        szTemp == 0)\r
                {\r
                        throw std::runtime_error("out of memory");\r
                }\r
                *this = szTemp;\r
                LocalFree(szTemp);\r
                va_end(argList);\r
        }\r
#endif\r
\r
\r
        // -------------------------------------------------------------------------\r
        // GetXXXX -- Direct access to character buffer\r
        // -------------------------------------------------------------------------\r
        CT GetAt(int nIdx) const\r
        {\r
                return this->at(static_cast<MYSIZE>(nIdx));\r
        }\r
\r
        CT* GetBuffer(int nMinLen=-1)\r
        {\r
                return GetBuf(nMinLen);\r
        }\r
\r
        CT* GetBufferSetLength(int nLen)\r
        {\r
                return BufferSet(nLen);\r
        }\r
\r
        // GetLength() -- MFC docs say this is the # of BYTES but\r
        // in truth it is the number of CHARACTERs (chars or wchar_ts)\r
        int GetLength() const\r
        {\r
                return static_cast<int>(this->length());\r
        }\r
\r
        \r
        int Insert(int nIdx, CT ch)\r
        {\r
                if ( static_cast<MYSIZE>(nIdx) > this->size() -1 )\r
                        this->append(1, ch);\r
                else\r
                        this->insert(static_cast<MYSIZE>(nIdx), 1, ch);\r
\r
                return GetLength();\r
        }\r
        int Insert(int nIdx, PCMYSTR sz)\r
        {\r
                if ( nIdx >= this->size() )\r
                        this->append(sz, sslen(sz));\r
                else\r
                        this->insert(static_cast<MYSIZE>(nIdx), sz);\r
\r
                return GetLength();\r
        }\r
\r
        bool IsEmpty() const\r
        {\r
                return this->empty();\r
        }\r
\r
        MYTYPE Left(int nCount) const\r
        {\r
        // Range check the count.\r
\r
                nCount = SSMAX(0, SSMIN(nCount, static_cast<int>(this->size())));\r
                return this->substr(0, static_cast<MYSIZE>(nCount)); \r
        }\r
\r
#ifndef SS_ANSI\r
        bool LoadString(UINT nId)\r
        {\r
                return this->Load(nId);\r
        }\r
#endif\r
\r
        void MakeLower()\r
        {\r
                ToLower();\r
        }\r
\r
        void MakeReverse()\r
        {\r
                std::reverse(this->begin(), this->end());\r
        }\r
\r
        void MakeUpper()\r
        { \r
                ToUpper();\r
        }\r
\r
        MYTYPE Mid(int nFirst ) const\r
        {\r
                return Mid(nFirst, size()-nFirst);\r
        }\r
\r
        MYTYPE Mid(int nFirst, int nCount) const\r
        {\r
                // CString does range checking here.  Since we're trying to emulate it,\r
                // we must check too.\r
\r
                if ( nFirst < 0 )\r
                        nFirst = 0;\r
                if ( nCount < 0 )\r
                        nCount = 0;\r
\r
                if ( nFirst + nCount > size() )\r
                        nCount = size() - nFirst;\r
\r
                if ( nFirst > size() )\r
                        return MYTYPE();\r
\r
                ASSERT(nFirst >= 0);\r
                ASSERT(nFirst + nCount <= size());\r
\r
                return this->substr(static_cast<MYSIZE>(nFirst),\r
                                                        static_cast<MYSIZE>(nCount));\r
        }\r
\r
        void ReleaseBuffer(int nNewLen=-1)\r
        {\r
                RelBuf(nNewLen);\r
        }\r
\r
        int Remove(CT ch)\r
        {\r
                MYSIZE nIdx             = 0;\r
                int nRemoved    = 0;\r
                while ( (nIdx=this->find_first_of(ch)) != MYBASE::npos )\r
                {\r
                        this->erase(nIdx, 1);\r
                        nRemoved++;\r
                }\r
                return nRemoved;\r
        }\r
\r
        int Replace(CT chOld, CT chNew)\r
        {\r
                int nReplaced   = 0;\r
                for ( MYITER iter=this->begin(); iter != this->end(); iter++ )\r
                {\r
                        if ( *iter == chOld )\r
                        {\r
                                *iter = chNew;\r
                                nReplaced++;\r
                        }\r
                }\r
                return nReplaced;\r
        }\r
\r
        int Replace(PCMYSTR szOld, PCMYSTR szNew)\r
        {\r
                int nReplaced           = 0;\r
                MYSIZE nIdx                     = 0;\r
                MYSIZE nOldLen          = sslen(szOld);\r
                if ( 0 == nOldLen )\r
                        return 0;\r
\r
                static const CT ch      = CT(0);\r
                MYSIZE nNewLen          = sslen(szNew);\r
                PCMYSTR szRealNew       = szNew == 0 ? &ch : szNew;\r
\r
                while ( (nIdx=this->find(szOld, nIdx)) != MYBASE::npos )\r
                {\r
                        replace(this->begin()+nIdx, this->begin()+nIdx+nOldLen, szRealNew);\r
                        nReplaced++;\r
                        nIdx += nNewLen;\r
                }\r
                return nReplaced;\r
        }\r
\r
        int ReverseFind(CT ch) const\r
        {\r
                MYSIZE nIdx     = this->find_last_of(ch);\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
        // ReverseFind overload that's not in CString but might be useful\r
        int ReverseFind(PCMYSTR szFind, MYSIZE pos=MYBASE::npos) const\r
        {\r
                MYSIZE nIdx     = this->rfind(0 == szFind ? MYTYPE() : szFind, pos);\r
                return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);\r
        }\r
\r
        MYTYPE Right(int nCount) const\r
        {\r
        // Range check the count.\r
\r
                nCount = SSMAX(0, SSMIN(nCount, static_cast<int>(this->size())));\r
                return this->substr(this->size()-static_cast<MYSIZE>(nCount));\r
        }\r
\r
        void SetAt(int nIndex, CT ch)\r
        {\r
                ASSERT(this->size() > static_cast<MYSIZE>(nIndex));\r
                this->at(static_cast<MYSIZE>(nIndex))           = ch;\r
        }\r
\r
#ifndef SS_ANSI\r
        BSTR SetSysString(BSTR* pbstr) const\r
        {\r
                ostring os;\r
                ssasn(os, *this);\r
                if ( !::SysReAllocStringLen(pbstr, os.c_str(), os.length()) )\r
                        throw std::runtime_error("out of memory");\r
\r
                ASSERT(*pbstr != 0);\r
                return *pbstr;\r
        }\r
#endif\r
\r
        MYTYPE SpanExcluding(PCMYSTR szCharSet) const\r
        {\r
        MYSIZE pos = this->find_first_of(szCharSet);\r
        return pos == MYBASE::npos ? *this : Left(pos);\r
        }\r
\r
        MYTYPE SpanIncluding(PCMYSTR szCharSet) const\r
        {\r
        MYSIZE pos = this->find_first_not_of(szCharSet);\r
        return pos == MYBASE::npos ? *this : Left(pos);\r
        }\r
\r
#if !defined(UNICODE) && !defined(SS_ANSI)\r
\r
        // CString's OemToAnsi and AnsiToOem functions are available only in\r
        // Unicode builds.  However since we're a template we also need a\r
        // runtime check of CT and a reinterpret_cast to account for the fact\r
        // that CStdStringW gets instantiated even in non-Unicode builds.\r
\r
        void AnsiToOem()\r
        {\r
                if ( sizeof(CT) == sizeof(char) && !empty() )\r
                {\r
                        ::CharToOem(reinterpret_cast<PCSTR>(this->c_str()),\r
                                                reinterpret_cast<PSTR>(GetBuf()));\r
                }\r
                else\r
                {\r
                        ASSERT(false);\r
                }\r
        }\r
\r
        void OemToAnsi()\r
        {\r
                if ( sizeof(CT) == sizeof(char) && !empty() )\r
                {\r
                        ::OemToChar(reinterpret_cast<PCSTR>(this->c_str()),\r
                                                reinterpret_cast<PSTR>(GetBuf()));\r
                }\r
                else\r
                {\r
                        ASSERT(false);\r
                }\r
        }\r
\r
#endif\r
        \r
\r
        // -------------------------------------------------------------------------\r
        // Trim and its variants\r
        // -------------------------------------------------------------------------\r
        MYTYPE& Trim()\r
        {\r
                return TrimLeft().TrimRight();\r
        }\r
\r
        MYTYPE& TrimLeft()\r
        {\r
                this->erase(this->begin(),\r
                        std::find_if(this->begin(), this->end(), NotSpace<CT>()));\r
\r
                return *this;\r
        }\r
\r
        MYTYPE&  TrimLeft(CT tTrim)\r
        {\r
                this->erase(0, this->find_first_not_of(tTrim));\r
                return *this;\r
        }\r
\r
        MYTYPE&  TrimLeft(PCMYSTR szTrimChars)\r
        {\r
                this->erase(0, this->find_first_not_of(szTrimChars));\r
                return *this;\r
        }\r
\r
        MYTYPE& TrimRight()\r
        {\r
                // NOTE:  When comparing reverse_iterators here (MYRITER), I avoid using\r
                // operator!=.  This is because namespace rel_ops also has a template\r
                // operator!= which conflicts with the global operator!= already defined\r
                // for reverse_iterator in the header <utility>.\r
                // Thanks to John James for alerting me to this.\r
\r
                MYRITER it = std::find_if(this->rbegin(), this->rend(), NotSpace<CT>());\r
                if ( !(this->rend() == it) )\r
                        this->erase(this->rend() - it);\r
\r
                this->erase(!(it == this->rend()) ? this->find_last_of(*it) + 1 : 0);\r
                return *this;\r
        }\r
\r
        MYTYPE&  TrimRight(CT tTrim)\r
        {\r
                MYSIZE nIdx     = this->find_last_not_of(tTrim);\r
                this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);\r
                return *this;\r
        }\r
\r
        MYTYPE&  TrimRight(PCMYSTR szTrimChars)\r
        {\r
                MYSIZE nIdx     = this->find_last_not_of(szTrimChars);\r
                this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);\r
                return *this;\r
        }\r
\r
        void                    FreeExtra()\r
        {\r
                MYTYPE mt;\r
                this->swap(mt);\r
                if ( !mt.empty() )\r
                        this->assign(mt.c_str(), mt.size());\r
        }\r
\r
        // I have intentionally not implemented the following CString\r
        // functions.   You cannot make them work without taking advantage\r
        // of implementation specific behavior.  However if you absolutely\r
        // MUST have them, uncomment out these lines for "sort-of-like"\r
        // their behavior.  You're on your own.\r
\r
//      CT*                             LockBuffer()    { return GetBuf(); }// won't really lock\r
//      void                    UnlockBuffer(); { }     // why have UnlockBuffer w/o LockBuffer?\r
\r
        // Array-indexing operators.  Required because we defined an implicit cast\r
        // to operator const CT* (Thanks to Julian Selman for pointing this out)\r
        CT& operator[](int nIdx)\r
        {\r
                return MYBASE::operator[](static_cast<MYSIZE>(nIdx));\r
        }\r
\r
        const CT& operator[](int nIdx) const\r
        {\r
                return MYBASE::operator[](static_cast<MYSIZE>(nIdx));\r
        }\r
\r
        CT& operator[](unsigned int nIdx)\r
        {\r
                return MYBASE::operator[](static_cast<MYSIZE>(nIdx));\r
        }\r
\r
        const CT& operator[](unsigned int nIdx) const\r
        {\r
                return MYBASE::operator[](static_cast<MYSIZE>(nIdx));\r
        }\r
\r
#ifndef SS_NO_IMPLICIT_CAST\r
        operator const CT*() const\r
        {\r
                return this->c_str();\r
        }\r
#endif\r
\r
        // IStream related functions.  Useful in IPersistStream implementations\r
\r
#ifdef SS_INC_COMDEF\r
\r
        // struct SSSHDR - useful for non Std C++ persistence schemes.\r
        typedef struct SSSHDR\r
        {\r
                BYTE    byCtrl;\r
                ULONG   nChars;\r
        } SSSHDR;       // as in "Standard String Stream Header"\r
\r
        #define SSSO_UNICODE    0x01    // the string is a wide string\r
        #define SSSO_COMPRESS   0x02    // the string is compressed\r
\r
        // -------------------------------------------------------------------------\r
        // FUNCTION: StreamSize\r
        // REMARKS:\r
        //              Returns how many bytes it will take to StreamSave() this CStdString\r
        //              object to an IStream.\r
        // -------------------------------------------------------------------------\r
        ULONG StreamSize() const\r
        {\r
                // Control header plus string\r
                ASSERT(this->size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));\r
                return (this->size() * sizeof(CT)) + sizeof(SSSHDR);\r
        }\r
\r
        // -------------------------------------------------------------------------\r
        // FUNCTION: StreamSave\r
        // REMARKS:\r
        //              Saves this CStdString object to a COM IStream.\r
        // -------------------------------------------------------------------------\r
        HRESULT StreamSave(IStream* pStream) const\r
        {\r
                ASSERT(size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));\r
                HRESULT hr              = E_FAIL;\r
                ASSERT(pStream != 0);\r
                SSSHDR hdr;\r
                hdr.byCtrl              = sizeof(CT) == 2 ? SSSO_UNICODE : 0;\r
                hdr.nChars              = this->size();\r
\r
\r
                if ( FAILED(hr=pStream->Write(&hdr, sizeof(SSSHDR), 0)) )\r
                        TRACE(_T("StreamSave: Cannot write control header, ERR=0x%X\n"),hr);\r
                else if ( empty() )\r
                        ;               // nothing to write\r
                else if ( FAILED(hr=pStream->Write(this->c_str(), this->size()*sizeof(CT), 0)) )\r
                        TRACE(_T("StreamSave: Cannot write string to stream 0x%X\n"), hr);\r
\r
                return hr;\r
        }\r
\r
\r
        // -------------------------------------------------------------------------\r
        // FUNCTION: StreamLoad\r
        // REMARKS:\r
        //              This method loads the object from an IStream.\r
        // -------------------------------------------------------------------------\r
        HRESULT StreamLoad(IStream* pStream)\r
        {\r
                ASSERT(pStream != 0);\r
                SSSHDR hdr;\r
                HRESULT hr                      = E_FAIL;\r
\r
                if ( FAILED(hr=pStream->Read(&hdr, sizeof(SSSHDR), 0)) )\r
                {\r
                        TRACE(_T("StreamLoad: Cant read control header, ERR=0x%X\n"), hr);\r
                }\r
                else if ( hdr.nChars > 0 )\r
                {\r
                        ULONG nRead             = 0;\r
                        PMYSTR pMyBuf   = BufferSet(hdr.nChars);\r
\r
                        // If our character size matches the character size of the string\r
                        // we're trying to read, then we can read it directly into our\r
                        // buffer. Otherwise, we have to read into an intermediate buffer\r
                        // and convert.\r
                        \r
                        if ( (hdr.byCtrl & SSSO_UNICODE) != 0 )\r
                        {\r
                                ULONG nBytes    = hdr.nChars * sizeof(wchar_t);\r
                                if ( sizeof(CT) == sizeof(wchar_t) )\r
                                {\r
                                        if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) )\r
                                                TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr);\r
                                }\r
                                else\r
                                {       \r
                                        PWSTR pBufW = reinterpret_cast<PWSTR>(_alloca((nBytes)+1));\r
                                        if ( FAILED(hr=pStream->Read(pBufW, nBytes, &nRead)) )\r
                                                TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr);\r
                                        else\r
                                                sscpy(pMyBuf, pBufW, hdr.nChars);\r
                                }\r
                        }\r
                        else\r
                        {\r
                                ULONG nBytes    = hdr.nChars * sizeof(char);\r
                                if ( sizeof(CT) == sizeof(char) )\r
                                {\r
                                        if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) )\r
                                                TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr);\r
                                }\r
                                else\r
                                {\r
                                        PSTR pBufA = reinterpret_cast<PSTR>(_alloca(nBytes));\r
                                        if ( FAILED(hr=pStream->Read(pBufA, hdr.nChars, &nRead)) )\r
                                                TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr);\r
                                        else\r
                                                sscpy(pMyBuf, pBufA, hdr.nChars);\r
                                }\r
                        }\r
                }\r
                else\r
                {\r
                        this->erase();\r
                }\r
                return hr;\r
        }\r
#endif // #ifdef SS_INC_COMDEF\r
\r
#ifndef SS_ANSI\r
\r
        // SetResourceHandle/GetResourceHandle.  In MFC builds, these map directly\r
        // to AfxSetResourceHandle and AfxGetResourceHandle.  In non-MFC builds they\r
        // point to a single static HINST so that those who call the member\r
        // functions that take resource IDs can provide an alternate HINST of a DLL\r
        // to search.  This is not exactly the list of HMODULES that MFC provides\r
        // but it's better than nothing.\r
\r
#ifdef _MFC_VER\r
        static void SetResourceHandle(HMODULE hNew)\r
        {\r
                AfxSetResourceHandle(hNew);\r
        }\r
        static HMODULE GetResourceHandle()\r
        {\r
                return AfxGetResourceHandle();\r
        }\r
#else\r
        static void SetResourceHandle(HMODULE hNew)\r
        {\r
                SSResourceHandle() = hNew;\r
        }\r
        static HMODULE GetResourceHandle()\r
        {\r
                return SSResourceHandle();\r
        }\r
#endif\r
\r
\r
    template<typename CT2>\r
    MYTYPE operator+(const CStdStr<CT2>& s2)\r
    {\r
            MYTYPE strRet(SSREF(*this));\r
        strRet += s2.c_str();\r
            return strRet;\r
    }\r
\r
\r
#endif\r
};\r
\r
\r
\r
// -----------------------------------------------------------------------------\r
// CStdStr friend addition functions defined as inline\r
// -----------------------------------------------------------------------------\r
template<typename CT>\r
inline\r
CStdStr<CT> operator+(const  CStdStr<CT>& str1, const CStdStr<CT>& str2)\r
{\r
        CStdStr<CT> strRet(SSREF(str1));\r
        strRet.append(str2);\r
        return strRet;\r
}\r
\r
template<typename CT>   \r
inline\r
CStdStr<CT> operator+(const  CStdStr<CT>& str, CT t)\r
{\r
        // this particular overload is needed for disabling reference counting\r
        // though it's only an issue from line 1 to line 2\r
\r
        CStdStr<CT> strRet(SSREF(str)); // 1\r
        strRet.append(1, t);                            // 2\r
        return strRet;\r
}\r
\r
template<typename CT>\r
inline\r
CStdStr<CT> operator+(const  CStdStr<CT>& str, PCSTR pA)\r
{\r
        return CStdStr<CT>(str) + CStdStr<CT>(pA);\r
}\r
\r
template<typename CT>\r
inline\r
CStdStr<CT> operator+(PCSTR pA, const CStdStr<CT>& str)\r
{\r
        CStdStr<CT> strRet(pA);\r
        strRet.append(str);\r
        return strRet;\r
}\r
\r
template<typename CT>\r
inline\r
CStdStr<CT> operator+(const CStdStr<CT>& str, PCWSTR pW)\r
{ \r
        return CStdStr<CT>(SSREF(str)) + CStdStr<CT>(pW);\r
}\r
\r
template<typename CT>\r
inline\r
CStdStr<CT> operator+(PCWSTR pW, const CStdStr<CT>& str)\r
{\r
        CStdStr<CT> strRet(pW);\r
        strRet.append(str);\r
        return strRet;\r
}\r
\r
#ifdef SS_INC_COMDEF\r
        template<typename CT>\r
        inline\r
        CStdStr<CT> operator+(const _bstr_t& bstr, const CStdStr<CT>& str)\r
        {\r
                return static_cast<const CT*>(bstr) + str;\r
        }\r
\r
        template<typename CT>\r
        inline\r
        CStdStr<CT> operator+(const CStdStr<CT>& str, const _bstr_t& bstr)\r
        {\r
                return str + static_cast<const CT*>(bstr);\r
        }\r
#endif\r
\r
// -----------------------------------------------------------------------------\r
// HOW TO EXPORT CSTDSTRING FROM A DLL\r
//\r
// If you want to export CStdStringA and CStdStringW from a DLL, then all you\r
// need to\r
//              1.      make sure that all components link to the same DLL version\r
//                      of the CRT (not the static one).\r
//              2.      Uncomment the 3 lines of code below\r
//              3.      #define 2 macros per the instructions in MS KnowledgeBase\r
//                      article Q168958.  The macros are:\r
//\r
//              MACRO           DEFINTION WHEN EXPORTING                DEFINITION WHEN IMPORTING\r
//              -----           ------------------------                -------------------------\r
//              SSDLLEXP        (nothing, just #define it)              extern\r
//              SSDLLSPEC       __declspec(dllexport)                   __declspec(dllimport)\r
//\r
//              Note that these macros must be available to ALL clients who want to \r
//              link to the DLL and use the class.  If they \r
// -----------------------------------------------------------------------------\r
//#pragma warning(disable:4231) // non-standard extension ("extern template")\r
//      SSDLLEXP template class SSDLLSPEC CStdStr<char>;\r
//      SSDLLEXP template class SSDLLSPEC CStdStr<wchar_t>;\r
\r
// =============================================================================\r
//                                              END OF CStdStr INLINE FUNCTION DEFINITIONS\r
// =============================================================================\r
\r
//      Now typedef our class names based upon this humongous template\r
\r
typedef CStdStr<char>           CStdStringA;    // a better std::string\r
typedef CStdStr<wchar_t>        CStdStringW;    // a better std::wstring\r
typedef CStdStr<OLECHAR>        CStdStringO;    // almost always CStdStringW\r
\r
\r
// New-style format function is a template\r
\r
#ifdef SS_SAFE_FORMAT\r
\r
template<>\r
struct FmtArg<CStdStringA>\r
{\r
    explicit FmtArg(const CStdStringA& arg) : a_(arg) {}\r
    PCSTR Val() const { return a_.c_str(); }\r
    const CStdStringA& a_;\r
private:\r
    FmtArg<CStdStringA>& operator=(const FmtArg<CStdStringA>&) { return *this; }\r
};\r
template<>\r
struct FmtArg<CStdStringW>\r
{\r
    explicit FmtArg(const CStdStringW& arg) : a_(arg) {}\r
    PCWSTR Val() const { return a_.c_str(); }\r
    const CStdStringW& a_;\r
private:\r
    FmtArg<CStdStringW>& operator=(const FmtArg<CStdStringW>&) { return *this; }\r
};\r
\r
template<>\r
struct FmtArg<std::string>\r
{\r
    explicit FmtArg(const std::string& arg) : a_(arg) {}\r
    PCSTR Val() const { return a_.c_str(); }\r
    const std::string& a_;\r
private:\r
    FmtArg<std::string>& operator=(const FmtArg<std::string>&) { return *this; }\r
};\r
template<>\r
struct FmtArg<std::wstring>\r
{\r
    explicit FmtArg(const std::wstring& arg) : a_(arg) {}\r
    PCWSTR Val() const { return a_.c_str(); }\r
    const std::wstring& a_;\r
private:\r
    FmtArg<std::wstring>& operator=(const FmtArg<std::wstring>&) {return *this;}\r
};\r
#endif // #ifdef SS_SAFEFORMAT\r
\r
#ifndef SS_ANSI\r
        // SSResourceHandle: our MFC-like resource handle\r
        inline HMODULE& SSResourceHandle()\r
        {\r
                static HMODULE hModuleSS        = GetModuleHandle(0);\r
                return hModuleSS;\r
        }\r
#endif\r
\r
\r
\r
\r
// In MFC builds, define some global serialization operators\r
// Special operators that allow us to serialize CStdStrings to CArchives.\r
// Note that we use an intermediate CString object in order to ensure that\r
// we use the exact same format.\r
\r
#ifdef _MFC_VER\r
        inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringA& strA)\r
        {\r
                CString strTemp = strA;\r
                return ar << strTemp;\r
        }\r
        inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringW& strW)\r
        {\r
                CString strTemp = strW;\r
                return ar << strTemp;\r
        }\r
\r
        inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringA& strA)\r
        {\r
                CString strTemp;\r
                ar >> strTemp;\r
                strA = strTemp;\r
                return ar;\r
        }\r
        inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringW& strW)\r
        {\r
                CString strTemp;\r
                ar >> strTemp;\r
                strW = strTemp;\r
                return ar;\r
        }\r
#endif  // #ifdef _MFC_VER -- (i.e. is this MFC?)\r
\r
\r
\r
// -----------------------------------------------------------------------------\r
// GLOBAL FUNCTION:  WUFormat\r
//              CStdStringA WUFormat(UINT nId, ...);\r
//              CStdStringA WUFormat(PCSTR szFormat, ...);\r
//\r
// REMARKS:\r
//              This function allows the caller for format and return a CStdStringA\r
//              object with a single line of code.\r
// -----------------------------------------------------------------------------\r
#ifdef SS_ANSI\r
#else\r
\r
        inline CStdStringA WUFormatA(UINT nId, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, nId);\r
\r
                CStdStringA strFmt;\r
                CStdStringA strOut;\r
                if ( strFmt.Load(nId) )\r
                        strOut.FormatV(strFmt, argList);\r
\r
                va_end(argList);\r
                return strOut;\r
        }\r
        inline CStdStringA WUFormatA(PCSTR szFormat, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, szFormat);\r
                CStdStringA strOut;\r
                strOut.FormatV(szFormat, argList);\r
                va_end(argList);\r
                return strOut;\r
        }\r
\r
        inline CStdStringW WUFormatW(UINT nId, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, nId);\r
\r
                CStdStringW strFmt;\r
                CStdStringW strOut;\r
                if ( strFmt.Load(nId) )\r
                        strOut.FormatV(strFmt, argList);\r
\r
                va_end(argList);\r
                return strOut;\r
        }\r
        inline CStdStringW WUFormatW(PCWSTR szwFormat, ...)\r
        {\r
                va_list argList;\r
                va_start(argList, szwFormat);\r
                CStdStringW strOut;\r
                strOut.FormatV(szwFormat, argList);\r
                va_end(argList);\r
                return strOut;\r
        }\r
#endif // #ifdef SS_ANSI\r
\r
#ifdef SS_WIN32\r
        // -------------------------------------------------------------------------\r
        // FUNCTION: WUSysMessage\r
        //       CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);\r
        //       CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);\r
        //           \r
        // DESCRIPTION:\r
        //       This function simplifies the process of obtaining a string equivalent\r
        //       of a system error code returned from GetLastError().  You simply\r
        //       supply the value returned by GetLastError() to this function and the\r
        //       corresponding system string is returned in the form of a CStdStringA.\r
        //\r
        // PARAMETERS: \r
        //       dwError - a DWORD value representing the error code to be translated\r
        //       dwLangId - the language id to use.  defaults to english.\r
        //\r
        // RETURN VALUE: \r
        //       a CStdStringA equivalent of the error code.  Currently, this function\r
        //       only returns either English of the system default language strings.  \r
        // -------------------------------------------------------------------------\r
        #define SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT)\r
        inline CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID)\r
        {\r
                CHAR szBuf[512];\r
\r
                if ( 0 != ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,\r
                                                                   dwLangId, szBuf, 511, NULL) )\r
                        return WUFormatA("%s (0x%X)", szBuf, dwError);\r
                else\r
                        return WUFormatA("Unknown error (0x%X)", dwError);\r
        }\r
        inline CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID)\r
        {\r
                WCHAR szBuf[512];\r
\r
                if ( 0 != ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,\r
                                                                   dwLangId, szBuf, 511, NULL) )\r
                        return WUFormatW(L"%s (0x%X)", szBuf, dwError);\r
                else\r
                        return WUFormatW(L"Unknown error (0x%X)", dwError);\r
        }\r
#endif\r
\r
// Define TCHAR based friendly names for some of these functions\r
\r
#ifdef UNICODE\r
        #define CStdString                              CStdStringW\r
        #define WUSysMessage                    WUSysMessageW\r
        #define WUFormat                                WUFormatW\r
#else\r
        #define CStdString                              CStdStringA\r
        #define WUSysMessage                    WUSysMessageA\r
        #define WUFormat                                WUFormatA\r
#endif\r
\r
// ...and some shorter names for the space-efficient\r
\r
#define WUSysMsg                                        WUSysMessage\r
#define WUSysMsgA                                       WUSysMessageA\r
#define WUSysMsgW                                       WUSysMessageW\r
#define WUFmtA                                          WUFormatA\r
#define WUFmtW                                          WUFormatW\r
#define WUFmt                                           WUFormat\r
#define WULastErrMsg()                          WUSysMessage(::GetLastError())\r
#define WULastErrMsgA()                         WUSysMessageA(::GetLastError())\r
#define WULastErrMsgW()                         WUSysMessageW(::GetLastError())\r
\r
\r
// -----------------------------------------------------------------------------\r
// FUNCTIONAL COMPARATORS:\r
// REMARKS:\r
//              These structs are derived from the std::binary_function template.  They\r
//              give us functional classes (which may be used in Standard C++ Library\r
//              collections and algorithms) that perform case-insensitive comparisons of\r
//              CStdString objects.  This is useful for maps in which the key may be the\r
//               proper string but in the wrong case.\r
// -----------------------------------------------------------------------------\r
#define StdStringLessNoCaseW            SSLNCW  // avoid VC compiler warning 4786\r
#define StdStringEqualsNoCaseW          SSENCW          \r
#define StdStringLessNoCaseA            SSLNCA          \r
#define StdStringEqualsNoCaseA          SSENCA          \r
\r
#ifdef UNICODE\r
        #define StdStringLessNoCase             SSLNCW          \r
        #define StdStringEqualsNoCase   SSENCW          \r
#else\r
        #define StdStringLessNoCase             SSLNCA          \r
        #define StdStringEqualsNoCase   SSENCA          \r
#endif\r
\r
struct StdStringLessNoCaseW\r
        : std::binary_function<CStdStringW, CStdStringW, bool>\r
{\r
        inline\r
        bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const\r
        { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; }\r
};\r
struct StdStringEqualsNoCaseW\r
        : std::binary_function<CStdStringW, CStdStringW, bool>\r
{\r
        inline\r
        bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const\r
        { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; }\r
};\r
struct StdStringLessNoCaseA\r
        : std::binary_function<CStdStringA, CStdStringA, bool>\r
{\r
        inline\r
        bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const\r
        { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; }\r
};\r
struct StdStringEqualsNoCaseA\r
        : std::binary_function<CStdStringA, CStdStringA, bool>\r
{\r
        inline\r
        bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const\r
        { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; }\r
};\r
\r
// If we had to define our own version of TRACE above, get rid of it now\r
\r
#ifdef TRACE_DEFINED_HERE\r
        #undef TRACE\r
        #undef TRACE_DEFINED_HERE\r
#endif\r
\r
\r
// These std::swap specializations come courtesy of Mike Crusader. \r
\r
//namespace std\r
//{\r
//      inline void swap(CStdStringA& s1, CStdStringA& s2) throw()\r
//      {\r
//              s1.swap(s2);\r
//      }\r
//      template<>\r
//      inline void swap(CStdStringW& s1, CStdStringW& s2) throw()\r
//      {\r
//              s1.swap(s2);\r
//      }\r
//}\r
\r
// Turn back on any Borland warnings we turned off.\r
\r
#ifdef __BORLANDC__\r
    #pragma option pop  // Turn back on inline function warnings\r
//      #pragma warn +inl   // Turn back on inline function warnings\r
#endif\r
\r
#endif  // #ifndef STDSTRING_H