OdString.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
 
 
#ifndef __ODSTRING_H__
#define __ODSTRING_H__
 
#include <stdarg.h>
#include <stdio.h>
 
#include "OdMutex.h"
#include "OdPlatformSettings.h"
#include "OdCodePage.h"
#include "OdAnsiString.h"
 
#define odaIsValidString(lpch)    (true)
 
#include "TD_PackPush.h"
 
#ifdef sgi
#include <string>
using namespace std;  // va_XXXX items are in std namespace for newest SGI compiler
#endif
 
struct OdStringData
{            
  OdRefCounter nRefs;      
 
  int nDataLength; 
 
  int nAllocLength;       
 
  OdChar* unicodeBuffer;
  
  char* ansiString;
};
 
class FIRSTDLL_EXPORT OdString
{
public:
 
  FIRSTDLL_EXPORT_STATIC const static OdString kEmpty;
 
  OdString()
  { init(); }
 
  OdString(const OdString& source);
 
  OdString(OdChar ch, int length);
 
  OdString(const OdChar* source);
  OdString(const OdChar* source, int length);
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString(const __wchar_t* source);
  OdString(const __wchar_t* source, int length);
#endif
 
 
  OdString(const char* lpch, OdCodePageId codepage = CP_CNT);
#ifndef ODA_WINDOWS
  OdString(const OdChar16_t* lpch, OdCodePageId codepage = CP_CNT);
#endif
  OdString(const char* lpch, int nLength, OdCodePageId codepage = CP_CNT);
  OdString(const OdAnsiString&);
protected:
  explicit OdString(OdStringData* pData);
public:
 
  int getLength() const
  { 
    if (isUnicodeNotInSync())
      syncUnicode();
    return getData()->nDataLength; 
  }
  int getLengthA() const;
 
  bool isEmpty() const
  {
    return (getData()->nDataLength == 0 && 
      (getData()->ansiString == 0 || getAnsiString()->isEmpty()));
  }
 
  void empty();
 
  OdChar getAt(int charIndex) const
  {
#ifdef TD_UNICODE
    if (isUnicodeNotInSync())
      syncUnicode();
#endif
    ODA_ASSERT(charIndex >= 0);
    ODA_ASSERT(charIndex < getData()->nDataLength);
    return getData()->unicodeBuffer[charIndex];
  }
 
  OdChar operator[](int charIndex) const
  {
    return getAt(charIndex);
  }
 
  void setAt(int charIndex, OdChar ch);
 
#if defined(_MSC_VER) && defined(_WIN32) && defined(_DEBUG) && defined(ODA_LINT)
#define UPDATECONSTSTRINGDIAGNISTIC
private:
  void updateConstStringDiagnostic(const OdChar* pAddr) const;
public:
#else
  #define updateConstStringDiagnostic(pAddr)
#endif
 
  const OdChar* c_str() const
  { 
    if (isUnicodeNotInSync())
      syncUnicode();
    const OdChar* pRet = getData()->unicodeBuffer;
    updateConstStringDiagnostic(pRet);
    return pRet;
  }
 
  inline operator const OdChar*() const
  { 
    return c_str();
  }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  operator const __wchar_t*() const
  { 
    return reinterpret_cast<const __wchar_t*>(c_str());
  }
#endif
 
  operator const char*() const;
 
  OdString& operator=(const OdString& source);
 
  OdString& operator=(OdChar ch);
  
  OdString& operator=(const OdChar* source);
 
#ifndef ODA_WINDOWS
  OdString& operator=(const OdChar16_t* source);
#endif
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString& operator=(const __wchar_t* source){ return operator=((const OdChar*)source); }
#endif
 
  OdString& operator=(const OdAnsiString& source);
 
  OdString& operator=(const char* source);
 
  OdString& operator+=(const OdString& string);
 
  OdString& operator+=(OdChar ch);
 
  OdString& operator+=(const OdChar* string);
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString& operator+=(const __wchar_t* string){ return operator+=((const OdChar*)string); }
#endif
 
  OdString& operator+=(const char* string);
 
  friend FIRSTDLL_EXPORT OdString operator+(const OdString& string1, const OdString& string2);
  friend FIRSTDLL_EXPORT OdString operator+(const OdString& string, OdChar ch);
  friend FIRSTDLL_EXPORT OdString operator+(OdChar ch, const OdString& string);
 
  friend FIRSTDLL_EXPORT OdString operator+(const OdString& string1, const OdChar* string2);
  friend FIRSTDLL_EXPORT OdString operator+(const OdChar* string1, const OdString& string2);
 
  int compare(const OdChar* otherString) const
  { 
    if (isUnicodeNotInSync())
      syncUnicode();
    return odStrCmp((const wchar_t*)getData()->unicodeBuffer, (const wchar_t*)otherString);
  }
 
  inline int compare(const OdString& otherString) const{ return compare(otherString.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  int compare(const __wchar_t* otherString) const { return compare((const OdChar*)otherString);}
#endif
 
  int compare(const char* otherString) const;
 
  int iCompare(const OdChar* otherString) const
  { 
    if (isUnicodeNotInSync())
      syncUnicode();
    return odStrICmp(getData()->unicodeBuffer, otherString); 
  }   
  
  inline int iCompare(const OdString& otherString) const{ return iCompare(otherString.c_str()); }
#if defined(_MSC_VER) && _MSC_VER >= 1300
  __forceinline int iCompare(const __wchar_t* otherString) const {return iCompare((const OdChar*)otherString);}
#endif   
 
  OdString mid(int startIndex, int length) const;
 
  OdString mid(int startIndex) const;
 
  OdString left(int length) const;
 
  OdString right(int length) const;
 
  OdString spanIncluding(const OdChar* charSet) const;
  
  inline OdString spanIncluding(const OdString& charSet) const { return spanIncluding(charSet.c_str()); }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString spanIncluding(const __wchar_t* charSet) const{return spanIncluding((const OdChar*)charSet);}
#endif
 
  OdString spanExcluding(const OdChar* charSet) const;
 
  inline OdString spanExcluding(const OdString& charSet) const{ return spanExcluding(charSet.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString spanExcluding(const __wchar_t* charSet) const{return spanExcluding((const OdChar*)charSet);}
#endif
  
  OdString& makeUpper();
 
  OdString& makeLower();
 
  OdString& makeReverse();
 
 
  OdString& trimRight();
 
  OdString& trimLeft();
 
  OdString& trimRight(OdChar whiteChar);
 
  OdString& trimRight(const OdChar* whiteChars);
 
  inline OdString& trimRight(const OdString& whiteChars){ return trimRight(whiteChars.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString& trimRight(const __wchar_t* whiteChars){return trimRight((const OdChar*)whiteChars);}
#endif
 
  OdString& trimLeft(OdChar whiteChar);
 
  OdString& trimLeft(const OdChar* whiteChars);
  
  inline OdString& trimLeft(const OdString& whiteChars){ return trimLeft(whiteChars.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString& trimLeft(const __wchar_t* whiteChars){return trimLeft((const OdChar*)whiteChars);}
#endif
  int replace(OdChar oldChar, OdChar newChar);
 
  int replace(const OdChar* oldString, const OdChar* newString);
  
  inline int replace(const OdString& oldString, const OdString& newString){ return replace(oldString.c_str(), newString.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  
  int replace(const __wchar_t* oldString, const __wchar_t* newString){return replace((const OdChar*)oldString, (const OdChar*)newString);}
#endif
  int remove(OdChar chRemove);
 
  int insert(int insertIndex, OdChar insertChar);
 
  int insert(int insertIndex, const OdChar* insertString);
  
  int insert(int insertIndex, const OdString& insertString){return insert(insertIndex, insertString.c_str());}
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  int insert(int insertIndex, const __wchar_t* insertString){return insert(insertIndex,(const OdChar*)insertString);}
#endif
  int deleteChars(int deleteIndex, int count = 1);
 
 
  int find(OdChar searchChar) const;
 
  int reverseFind(OdChar searchChar) const;
 
  int reverseFind(OdChar searchChar, int startIndex) const;
 
  int find(OdChar searchChar, int startIndex) const;
 
  int findOneOf(const OdChar* charSet) const;
 
  int find(const OdChar* searchString) const;
 
  int find(const OdChar* searchString, int startIndex) const;
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  int findOneOf(const __wchar_t* charSet) const{return findOneOf((const OdChar*)charSet);}
  
  int findOneOf(const OdString& charSet) const{return findOneOf((const OdChar*)charSet);}
 
  int find(const __wchar_t* searchString) const{return find((const OdChar*)searchString);}
 
  int find(const OdString& searchString) const{return find((const OdChar*)searchString);}
 
  int find(const __wchar_t* searchString, int startIndex) const{return find((const OdChar*)searchString,startIndex);}
 
  int find(const OdString& searchString, int startIndex) const{return find((const OdChar*)searchString,startIndex);}
#endif
  OdString& format(const OdChar* formatString, ...);
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  OdString& format(const __wchar_t* formatString, ...);
#endif
 
  OdString& formatV(const OdChar* formatString, va_list argList); 
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
  inline OdString& formatV(const __wchar_t* formatString, va_list argList)
  {
    return formatV((const OdChar*)formatString, argList);
  }
#endif
                                                                
  OdChar* getBuffer(int minBufLength);
 
  void releaseBuffer(int newLength = -1);
 
  OdChar* getBufferSetLength(int length);
 
  void freeExtra();
 
  OdChar* lockBuffer();
 
  void unlockBuffer();
 
/*   disable wide char functionalities
   Constructor.  This OdString will receive a copy of the wide character string referenced
   by lpsz.
  OdString(const OdCharW* lpsz);
 
  Constructor. This OdString will receive a copy of the first nLength wide characters of
  the string referenced by lpch.
  OdString(const OdCharW* lpch, int nLength);
 
   Assignment operator.  This OdString is assigned the value of lpsz.
  const OdString& operator=(const OdCharW* lpsz);
 
*/
 
#ifdef NOT_IMPLEMENTED
 
  int collate(const OdChar* otherString) const;
 
  int iCollate(const OdChar* otherString) const;
 
  OdString& ODA_CDECL format(unsigned int formatID, ...);
#endif
 
 
public:
  ~OdString();
 
  int getAllocLength() const
  { return getData()->nAllocLength; }
 
  inline void preallocate(int length)
  {
    allocBeforeWrite(length);
    m_pData->nDataLength = 0;
  }
 
protected:
  FIRSTDLL_EXPORT_STATIC static OdStringData kEmptyData;
 
  OdStringData* m_pData;  
  
  OdStringData* getData() const
    { ODA_ASSERT(m_pData!= NULL); return m_pData; }
 
  void init();
 
  void allocCopy(OdString& destString, int copyLength, int copyIndex, int extraLength) const;
 
  void allocBuffer(int length, bool allocAlways = false);
 
    void assignCopy(int sourceLength, const OdChar* source);
 
    void concatCopy(int sourceLength1, const OdChar* source1, int sourceLength2, const OdChar* source2);
 
    void concatInPlace(int sourceLength, const OdChar* source);
 
  void copyBeforeWrite();
 
  void allocBeforeWrite(int newLength);
 
  void release();
 
  static void release(OdStringData* pStringData);
 
  static int safeStrlen(const OdChar* string)
  { return (string == NULL) ? (int)0 : (int)odStrLen((const wchar_t*)string); }
 
  static void freeData(OdStringData* pStringData);
 
  bool isUnicodeNotInSync() const
  {
    return !getData()->unicodeBuffer && getData()->ansiString;
  }
  void syncUnicode() const;
  OdAnsiString* getAnsiString() const
  {
    if (getData()->ansiString)
      return reinterpret_cast<OdAnsiString*>(&getData()->ansiString);
    else 
      return 0;
  }
  void freeAnsiString()const;
  friend class OdAnsiString;
public:
  struct lessnocase { bool operator()(const OdString& x, const OdString& y) const { return x.iCompare(y) < 0; } };
};
 
typedef OdChar OdCharW;
typedef OdString OdString;
 
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline OdString operator+(const OdString& string1, const __wchar_t* string2)
{
  return operator+(string1, (const OdChar*)string2);
}
inline OdString operator+(const __wchar_t* string1, const OdString& string2)
{
  return operator+((const OdChar*)string1, string2);
}
#endif
 
inline bool operator==(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) == 0; }
 
inline bool operator==(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) == 0; }
 
inline bool operator==(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) == 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator==(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) == 0; }
 
inline bool operator==(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) == 0; }
#endif
 
inline bool operator==(const OdString& s1, const char* s2)
{ return s1.compare(s2) == 0; }
 
inline bool operator==(const char* s1, const OdString& s2)
{ return odStrCmpA((const char*)s2, s1) == 0; }
 
inline bool operator!=(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) != 0; }
 
inline bool operator!=(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) != 0; }
 
inline bool operator!=(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) != 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator!=(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) != 0; }
 
inline bool operator!=(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) != 0; }
#endif
 
inline bool operator!=(const OdString& s1, const char* s2)
{ return s1.compare(s2) != 0; }
 
inline bool operator!=(const char* s1, const OdString& s2)
{ return s2.compare(s1) != 0; }
 
inline bool operator<(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) < 0; }
 
inline bool operator<(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) < 0; }
 
inline bool operator<(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) > 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator<(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) < 0; }
 
inline bool operator<(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) > 0; }
#endif
 
inline bool operator<(const OdString& s1, const char* s2)
{ return s1.compare(s2) < 0; }
 
inline bool operator<(const char* s1, const OdString& s2)
{ return s2.compare(s1) > 0; }
 
inline bool operator>(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) > 0; }
 
inline bool operator>(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) > 0; }
 
inline bool operator>(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) < 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator>(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) > 0; }
inline bool operator>(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) < 0; }
#endif
 
inline bool operator>(const OdString& s1, const char* s2)
{ return s1.compare(s2) > 0; }
 
inline bool operator>(const char* s1, const OdString& s2)
{ return s2.compare(s1) < 0; }
 
inline bool operator<=(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) <= 0; }
 
inline bool operator<=(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) <= 0; }
 
inline bool operator<=(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) >= 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator<=(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) <= 0; }
inline bool operator<=(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) >= 0; }
#endif
 
inline bool operator<=(const OdString& s1, const char* s2)
{ return s1.compare(s2) <= 0; }
 
inline bool operator<=(const char* s1, const OdString& s2)
{ return s2.compare(s1) >= 0; }
 
inline bool operator>=(const OdString& s1, const OdString& s2)
  { return s1.compare(s2) >= 0; }
 
inline bool operator>=(const OdString& s1, const OdChar* s2)
  { return s1.compare(s2) >= 0; }
 
inline bool operator>=(const OdChar* s1, const OdString& s2)
  { return s2.compare(s1) <= 0; }
 
#if defined(_MSC_VER) && _MSC_VER >= 1300
inline bool operator>=(const OdString& s1, const __wchar_t* s2)
{ return s1.compare((const OdChar*)s2) >= 0; }
 
inline bool operator>=(const __wchar_t* s1, const OdString& s2)
{ return s2.compare((const OdChar*)s1) <= 0; }
#endif
 
inline bool operator>=(const OdString& s1, const char* s2)
{ return s1.compare(s2) >= 0; }
 
inline bool operator>=(const char* s1, const OdString& s2)
{ return s2.compare(s1) <= 0; }
 
#if defined(ODA_UNIXOS)
class OdW2US
{
  OdUInt16* _buf;
public:
  OdW2US(const wchar_t* pStr)
  {
    size_t len = Od_wcslen(pStr);
    _buf = new OdUInt16[len+1];
    for (size_t i = 0; i < len; i++)
    {
      _buf[i] = (OdUInt16)pStr[i];
    }
    _buf[len] = 0;
  }
  ~OdW2US() 
  {
    delete[]_buf;
  }
  operator const OdUInt16*() const { return _buf; }
};
 
class OdUS2W
{
  wchar_t* _buf;
public:
  OdUS2W(const OdUInt16* pStr)
  {
    size_t len = 0;
    if (const OdUInt16* p = pStr)
    {
      while (*p++)
        len++;
    }
    _buf = new wchar_t[len+1];
    for (size_t i = 0; i < len; i++)
    {
      _buf[i] = (wchar_t)pStr[i];
    }
    _buf[len] = 0;
  }
  ~OdUS2W() 
  {
    delete[] _buf;
  }
  operator const wchar_t*() const { return _buf; }
};
 
#else
 
#define OdUS2W(a) (const wchar_t*)(a)
#define OdW2US(a) (const OdUInt16*)(a)
 
#endif
 
 
class FIRSTDLL_EXPORT OdConstString : public OdString
{
public:
  OdConstString(const OdChar* pSource = NULL);
  // Destructor of base class OdString is not virtual (critical for performance).
  // Therefore ~OdConstString is missing
 
  OdConstString& operator=(const OdConstString& pSource);
  OdString& operator=(const OdString& pSource);
  OdString& operator=(OdChar ch);
  OdString& operator=(const OdChar* pSource);
  OdString& operator=(const OdAnsiString& pSource);
  OdString& operator=(const char* pSource);
  operator const OdChar*() const;
 
protected:
  OdStringData m_data;  
};
 
 
#include "TD_PackPop.h"
 
#endif // __ODSTRING_H__