stdstring.h

FastDb是高效的内存数据库系统

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

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

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

#ifndef STDSTRING_H
#define STDSTRING_H

//#define SS_NOLOCALE // prevents use/inclusion of <locale> header
//#define SS_UNSIGNED // add CString ctor/assign op. for usigned characters

// MACRO: SS_NO_REFCOUNT:
//  turns off reference counting at the assignment level.  Only needed
//  for the version of basic_string<> that comes with Visual C++ versions
//  6.0 or earlier, and only then in some heavily multithreaded scenarios.
//  Uncomment it if you feel you need it.

//#define SS_NO_REFCOUNT

// In non-Visual C++ and/or non-Win32 builds, we can't use some cool stuff.

#if !defined(_MSC_VER) || !defined(_WIN32)
 #define SS_ANSI
#endif

// Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well

#if defined (_UNICODE) && !defined (UNICODE)
 #define UNICODE
#endif
#if defined (UNICODE) && !defined (_UNICODE)
 #define _UNICODE
#endif

// -----------------------------------------------------------------------------
// MIN and MAX.  The Standard C++ template versions go by so many names (at
// at least in the MS implementation) that you never know what's available
// -----------------------------------------------------------------------------

template<class Type>
inline const Type& SSMIN(const Type& arg1, const Type& arg2)
{
  return arg2 < arg1 ? arg2 : arg1;
}

template<class Type>
inline const Type& SSMAX(const Type& arg1, const Type& arg2)
{
  return arg2 > arg1 ? arg2 : arg1;
}

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

#if !defined(W32BASE_H)

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

#ifdef SS_ANSI

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

#ifndef _WIN32

typedef const char*  PCSTR;

typedef char*   PSTR;

typedef const wchar_t* PCWSTR;

typedef wchar_t*  PWSTR;

#ifdef UNICODE

typedef wchar_t  TCHAR;

#else

typedef char  TCHAR;

#endif

typedef wchar_t   OLECHAR;

#else

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

#endif // #ifndef _WIN32


// Make sure ASSERT and verify are defined in an ANSI fashion

#ifndef ASSERT
   #include <assert.h>
   #define ASSERT(f) assert((f))
  #endif
  #ifndef VERIFY
   #ifdef _DEBUG
    #define VERIFY(x) ASSERT((x))
   #else
    #define VERIFY(x) x
   #endif
  #endif

#else // #ifdef SS_ANSI

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

// Make sure ASSERT and verify are defined

#ifndef ASSERT
   #include <crtdbg.h>
   #define ASSERT(f) _ASSERTE((f))
  #endif
  #ifndef VERIFY
   #ifdef _DEBUG
    #define VERIFY(x) ASSERT((x))
   #else
    #define VERIFY(x) x
   #endif
  #endif

#endif // #ifdef SS_ANSI

#ifndef UNUSED
  #define UNUSED(x) x
 #endif

#endif // #ifndef W32BASE_H

// Standard headers needed

#include <string>   // basic_string
#include <algorithm>  // for_each, etc.
#include <functional>  // for StdStringLessNoCase, et al

#ifndef SS_NOLOCALE
 #include <locale>  // for various facets
#endif

// If this is a recent enough version of VC include comdef.h, so we can write
// member functions to deal with COM types & compiler support classes e.g. _bstr_t

#if defined (_MSC_VER) && (_MSC_VER >= 1100)
 #include <comdef.h>
 #define SS_INC_COMDEF  // signal that we #included MS comdef.h file
 #define STDSTRING_INC_COMDEF
 #define SS_NOTHROW __declspec(nothrow)
#else
 #define SS_NOTHROW
#endif

#ifndef TRACE
 #define TRACE_DEFINED_HERE
 #define TRACE
#endif

// Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR.  I hate to use the
// versions with the "L" in front of them because that's a leftover from Win 16
// days, even though it evaluates to the same thing.  Therefore, Define a PCSTR
// as an LPCTSTR.

#if !defined(PCTSTR) && !defined(PCTSTR_DEFINED)

typedef const TCHAR*   PCTSTR;

#define PCTSTR_DEFINED
#endif

#if !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED)

typedef const OLECHAR*   PCOLESTR;

#define PCOLESTR_DEFINED
#endif

#if !defined(POLESTR) && !defined(POLESTR_DEFINED)

typedef OLECHAR*    POLESTR;

#define POLESTR_DEFINED
#endif

#if !defined(PCUSTR) && !defined(PCUSTR_DEFINED)

typedef const unsigned char* PCUSTR;

typedef unsigned char*   PUSTR;

#define PCUSTR_DEFINED
#endif

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

#ifndef SS_USE_FACET
// STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for
// all MSVC builds, erroneously in my opinion.  It causes problems for
// my SS_ANSI builds.  In my code, I always comment out that line.  You'll
// find it in   \stlport\config\stl_msvc.h
#if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 )
  #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER)