OdAnsiString.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 __ODANSISTRING_H__
#define __ODANSISTRING_H__
 
#ifdef TD_UNICODE
#define ODA_CDECL 
#define ODA_PASCAL 
 
#include <stdarg.h>
#include <stdio.h>
 
#include "OdMutex.h"
#include "OdPlatform.h"
#include "OdArrayPreDef.h"
#include "OdCodePage.h"
 
#define odaIsValidString(lpch)    (true)
 
#include "TD_PackPush.h"
class OdString;
 
#ifdef sgi
#include <string>
 // va_XXXX items are in std namespace for newest SGI compiler
 
using namespace std; 
#endif
 
struct OdStringDataA
{            
  OdRefCounter nRefs;      
 
  int nDataLength; 
 
  int nAllocLength;       
  
  OdCodePageId codepage;
 
  char* data()           
  { return (char*)(this+1); }
};
 
#ifdef _WIN32_WCE
ODA_ASSUME((sizeof(OdStringDataA)%8)==0);
#endif
 
      struct OdEmptyStringDataA
{
  OdStringDataA  kStrData;
  char        kChar;
};
 
class FIRSTDLL_EXPORT OdAnsiString
{
public:
 
  OdAnsiString()
  { init(); }
 
  OdAnsiString(const OdAnsiString& source);
 
  OdAnsiString(char ch, int length);
 
  OdAnsiString(const char* source);
 
  OdAnsiString(const char* source, int length);
  OdAnsiString(const char* source, OdCodePageId);
  OdAnsiString(const char* source, int length, OdCodePageId);
  OdAnsiString(const OdString& , OdCodePageId);
 
  void setCodepage(OdCodePageId id);
  
  OdCodePageId codepage() const
  { return getData()->codepage; }
 
  int getLength() const
  { return getData()->nDataLength; }
 
  bool isEmpty() const
  { return getData()->nDataLength == 0; }
 
  void empty();
 
  char getAt(int charIndex) const
  {
    ODA_ASSERT(charIndex >= 0);
    ODA_ASSERT(charIndex < getData()->nDataLength);
    return m_pchData[charIndex];
  }
 
  char operator[](int charIndex) const
  {
    ODA_ASSERT(charIndex >= 0);
    ODA_ASSERT(charIndex < getData()->nDataLength);
    return m_pchData[charIndex];
  }
 
  void setAt(int charIndex, char ch);
 
  const char* c_str() const
  { return m_pchData; }
 
  operator const char*() const
  { return m_pchData; }
 
  OdAnsiString& operator=(const OdAnsiString& source);
 
  OdAnsiString& operator=(char ch);
 
  OdAnsiString& operator=(const char* source);
 
  OdAnsiString& operator=(const OdString& source);
 
  OdAnsiString& operator+=(const OdAnsiString& string);
 
  OdAnsiString& operator+=(char ch);
 
  OdAnsiString& operator+=(const char* string);
 
  friend FIRSTDLL_EXPORT OdAnsiString operator+(const OdAnsiString& string1, const OdAnsiString& string2);
  friend FIRSTDLL_EXPORT OdAnsiString operator+(const OdAnsiString& string, char ch);
  friend FIRSTDLL_EXPORT OdAnsiString operator+(char ch, const OdAnsiString& string);
 
  friend FIRSTDLL_EXPORT OdAnsiString operator+(const OdAnsiString& string1, const char* string2);
  friend FIRSTDLL_EXPORT OdAnsiString operator+(const char* string1, const OdAnsiString& string2);
 
  int compare(const char* otherString) const
  { ODA_ASSERT(odaIsValidString(otherString)); return odStrCmpA(m_pchData, otherString); }    // MBCS/Unicode aware 
 
  int iCompare(const char* otherString) const
  { ODA_ASSERT(odaIsValidString(otherString)); return odStrICmpA(m_pchData, otherString); }   
 
  OdAnsiString mid(int startIndex, int length) const;
 
  OdAnsiString mid(int startIndex) const;
 
  OdAnsiString left(int length) const;
 
  OdAnsiString right(int length) const;
 
  OdAnsiString spanIncluding(const char* charSet) const;
 
  OdAnsiString spanExcluding(const char* charSet) const;
 
  OdAnsiString& makeUpper();
 
  OdAnsiString& makeLower();
 
  OdAnsiString& makeReverse();
 
 
  OdAnsiString& trimRight();
 
  OdAnsiString& trimLeft();
 
  OdAnsiString& trimRight(char whiteChar);
 
  OdAnsiString& trimRight(const char* whiteChars);
 
  OdAnsiString& trimLeft(char whiteChar);
 
  OdAnsiString& trimLeft(const char* whiteChars);
 
  int replace(char oldChar, char newChar);
 
  int replace(const char* oldString, const char* newString);
 
  int remove(char chRemove);
 
  int insert(int insertIndex, char insertChar);
 
  int insert(int insertIndex, const char* insertString);
 
  int deleteChars(int deleteIndex, int count = 1);
 
 
  int find(char searchChar) const;
 
  int reverseFind(char searchChar) const;
 
  int find(char searchChar, int startIndex) const;
 
  int findOneOf(const char* charSet) const;
 
  int find(const char* searchString) const;
 
  int find(const char* searchString, int startIndex) const;
 
  OdAnsiString& format(const char* formatString, ...);
 
  OdAnsiString& formatV(const char* formatString, va_list argList); 
 
  char* getBuffer(int minBufLength);
 
  void releaseBuffer(int newLength = -1);
 
  char* getBufferSetLength(int length);
 
  void freeExtra();
 
  char* lockBuffer();
 
  void unlockBuffer();
 
public:
  ~OdAnsiString();
 
  int getAllocLength() const
  { return getData()->nAllocLength; }
 
protected:
  FIRSTDLL_EXPORT_STATIC static OdEmptyStringDataA kEmptyData;
 
  char* m_pchData;  
 
  OdStringDataA* getData() const
  { ODA_ASSERT(m_pchData != NULL); return ((OdStringDataA*)m_pchData)-1; }
 
  void init();
 
  void allocCopy(OdAnsiString& destString, int copyLength, int copyIndex, int extraLength) const;
 
  void allocBuffer(int length);
 
    void assignCopy(int sourceLength, const char* source);
 
    void concatCopy(int sourceLength1, const char* source1, int sourceLength2, const char* source2);
 
    void concatInPlace(int sourceLength, const char* source);
 
  void copyBeforeWrite();
 
  void allocBeforeWrite(int newLength);
 
  void release();
 
  static void ODA_PASCAL release(OdStringDataA* pStringData);
 
  static int ODA_PASCAL safeStrlen(const char* string)
  { return (string == NULL) ? (int)0 : (int)odStrLenA(string); }
 
  static void freeData(OdStringDataA* pStringData);
  friend class OdString;
};
 
inline bool operator==(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) == 0; }
 
inline bool operator==(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) == 0; }
 
inline bool operator==(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) == 0; }
 
inline bool operator!=(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) != 0; }
 
inline bool operator!=(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) != 0; }
 
inline bool operator!=(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) != 0; }
 
inline bool operator<(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) < 0; }
 
inline bool operator<(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) < 0; }
 
inline bool operator<(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) > 0; }
 
inline bool operator>(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) > 0; }
 
inline bool operator>(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) > 0; }
 
inline bool operator>(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) < 0; }
 
inline bool operator<=(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) <= 0; }
 
inline bool operator<=(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) <= 0; }
 
inline bool operator<=(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) >= 0; }
 
inline bool operator>=(const OdAnsiString& s1, const OdAnsiString& s2)
{ return s1.compare(s2) >= 0; }
 
inline bool operator>=(const OdAnsiString& s1, const char* s2)
{ return s1.compare(s2) >= 0; }
 
inline bool operator>=(const char* s1, const OdAnsiString& s2)
{ return s2.compare(s1) <= 0; }
 
typedef OdArray<OdAnsiString> OdAnsiStringArray;
 
#include "TD_PackPop.h"
 
#endif // TD_UNICODE
 
#endif // __ODANSISTRING_H__