SbString.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
** Modified by : Nick Thompson (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _SB_STRING_
#define _SB_STRING_
 
#include <string.h>
#include <wchar.h>
#include <stdarg.h>
 
#include <Inventor/SoInventorBase.h>
#include <Inventor/SbBase.h>
#include <Inventor/STL/string>
#include <Inventor/STL/ostream>
#include <Inventor/STL/vector>
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4251)
#endif
 
class  SbString {
 public:
 
  SbString();
 
  SbString(const std::string &std_string);
 
  SbString(const std::wstring &std_wstring);
 
  SbString(const char *str);
 
  SbString(const char *str, int start, int end);
 
  SbString(const wchar_t *str, int start, int end);
 
 
  SbString(const SbString &str);
 
  SbString( const wchar_t* str );
 
  ~SbString();
 
  static const int npos;
 
  SbBool isEmpty() const;
 
  SbBool isNull() const;
 
  int getLength() const;
 
  void makeEmpty( const SbBool freeOld = TRUE );
 
  void makeNull();
 
  SbString getSubString(int startChar, int endChar = -1) const;
 
  void deleteSubString(int startChar, int endChar = -1);
 
  SbBool contains( const SbString& str ) const;
 
  bool endsWith( const SbString& str ) const;
 
  int find( const SbString& str ) const;
 
  int rfind( const SbString& str ) const;
 
  int findLast( const SbString& str ) const;
 
  SbBool containsAny( const SbString& str ) const;
 
  int findAny( const SbString& str ) const;
 
  void replace( const SbString& patternStr, const SbString& substStr );
 
  // Conversion functions
 
  SbString lower() const;
 
  SbString upper() const;
 
  SbString& setNum( short value, int base = 10 );
 
  SbString& setNum( unsigned short value, int base = 10 );
 
  SbString& setNum( int value, int base = 10 );
 
  SbString& setNum( unsigned int value, int base = 10 );
 
  SbString& setNum( long value, int base = 10 );
 
  SbString& setNum( unsigned long value, int base = 10 );
 
  SbString& setNum( double value );
 
  SbString& setNum( float value );
 
  unsigned short toUShort( SbBool* ok = NULL ) const;
 
  short toShort( SbBool* ok = NULL ) const;
 
  unsigned int toUInt( SbBool* ok = NULL ) const;
 
  int toInt( SbBool* ok = NULL ) const;
 
  unsigned long toULong( SbBool* ok = NULL ) const;
 
  long toLong( SbBool* ok = NULL ) const;
 
  float toFloat( SbBool* ok = NULL ) const;
 
  double toDouble( SbBool* ok = NULL ) const;
 
 
  // Unicode conversion functions
 
  // - Unicode managment functions
 
  SbBool isUnicode() const;
 
  // - From
 
  SbString& fromLatin1( const char* str );
 
  SbString& fromUtf16( const unsigned short* str );
 
  SbString& fromWideChar( const wchar_t* str );
 
  // - To
 
  const char* toLatin1() const;
 
  unsigned short* toUtf16() const;
 
  const wchar_t* toWideChar() const;
 
  std::wstring toStdWString() const;
 
  std::string toStdString() const;
 
  // Operators
 
  SbString &operator +=( const SbString& str );
 
  SbString &operator +=( const char *str );
 
  SbString &operator =(const SbString &str);
 
  SbString &operator =(const char *str);
 
 
   friend const SbString operator+( const SbString &s1, const SbString &s2 );
 
   friend int operator ==(const SbString &str1, const SbString &str2);
 
   friend int operator ==(const SbString &str, const char *s);
 
   friend int operator ==(const char *s, const SbString &str);
 
   friend int operator !=(const SbString &str1, const SbString &str2);
 
   friend bool operator < (const SbString &str1, const SbString &str2);
 
   friend bool operator > (const SbString &str1, const SbString &str2);
 
   friend bool operator <= (const SbString &str1, const SbString &str2);
 
   friend bool operator >= (const SbString &str1, const SbString &str2);
 
   friend std::ostream& operator << (std::ostream& os, const SbString& str)
  {
    if (str.isUnicode())
      return os << str.toUtf8();
 
    return os << str.toLatin1();
  }
 
 
  uint32_t hash() const;
 
  // Deprecated functions
 
  SoNONUNICODE SbString( const int digitString );
 
  SoNONUNICODE const char *getString() const;
 
  SoNONUNICODE const std::string &getSString() const;
 
  SoNONUNICODE SbString & sprintf(const char * cformat, ... );
 
  SoNONUNICODE SbString & vprintf(const char * cformat, va_list arg);
 
  SoNONUNICODE  friend const SbString operator+( const SbString &s1, const char *s2 );
 
  SoNONUNICODE  friend const SbString operator+( const char *s1, const SbString &s2 );
 
  SoNONUNICODE char operator[]( int i ) const;
 
  SoNONUNICODE int operator !() const;
 
  SoNONUNICODE  friend int operator ==(const SbString &str, const std::string &s);
 
  SoNONUNICODE  friend int operator ==(const std::string &s, const SbString &str);
 
  SoNONUNICODE  friend int operator !=(const SbString &str, const char *s);
 
  SoNONUNICODE  friend int operator !=(const char *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator < (const SbString &str, const char *s);
 
  SoNONUNICODE  friend bool operator < (const char *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator < (const SbString &str, const std::string &s);
 
  SoNONUNICODE  friend bool operator < (const std::string &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator > (const SbString &str, const char *s);
 
  SoNONUNICODE  friend bool operator > (const char *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator > (const SbString &str, const std::string &s);
 
  SoNONUNICODE  friend bool operator > (const std::string &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator <= (const SbString &str, const char *s);
 
  SoNONUNICODE  friend bool operator <= (const char *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator <= (const SbString &str, const std::string &s);
 
  SoNONUNICODE  friend bool operator <= (const std::string &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator >= (const SbString &str, const char *s);
 
  SoNONUNICODE  friend bool operator >= (const char *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator >= (const SbString &str, const std::string &s);
 
  SoNONUNICODE  friend bool operator >= (const std::string &s, const SbString &str);
 
// Wide String
 
  SoNONUNICODE const SO_WCHAR_T *wgetString() const;
 
   SoNONUNICODE const std::wstring &wgetSString() const;
 
  SoNONUNICODE SbString &operator =(const SO_WCHAR_T *str);
 
  SoNONUNICODE SbString &operator +=(const SO_WCHAR_T *str);
 
  SoNONUNICODE  friend int operator ==(const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend int operator ==(const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend int operator ==(const SbString &str, const std::wstring &s);
 
  SoNONUNICODE  friend int operator ==(const std::wstring &s, const SbString &str);
 
  SoNONUNICODE  friend int operator !=(const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend int operator !=(const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator < (const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend bool operator < (const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator < (const SbString &str, const std::wstring &s);
 
  SoNONUNICODE  friend bool operator < (const std::wstring &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator > (const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend bool operator > (const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator > (const SbString &str, const std::wstring &s);
 
  SoNONUNICODE  friend bool operator > (const std::wstring &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator <= (const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend bool operator <= (const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator <= (const SbString &str, const std::wstring &s);
 
  SoNONUNICODE  friend bool operator <= (const std::wstring &s, const SbString &str);
 
  SoNONUNICODE  friend bool operator >= (const SbString &str, const SO_WCHAR_T *s);
 
  SoNONUNICODE  friend bool operator >= (const SO_WCHAR_T *s, const SbString &str);
 
  SoNONUNICODE  friend bool operator >= (const SbString &str, const std::wstring &s);
 
  SoNONUNICODE  friend bool operator >= (const std::wstring &s, const SbString &str);
 
private:
 
  SbString& fromUtf8( const char* str );
 
 
  const char* toUtf8() const;
 
  static uint32_t hash(const char *s);    // Hash function
  static uint32_t hash(const SO_WCHAR_T *s); // Hash function
 
  static inline bool isDigit(const int c);
  static inline bool isSpace(const int c);
 
  void split(std::vector<SbString>& tokens) const;
 
  void setCapacity( int nBytes );
 
  const std::string& nonUnicodeToStdString() const { return m_cdata; }
 
private:
 
  static void initClass();
 
  static void exitClass();
 
#ifdef _WIN32
# define SB_LOCALE_DATA_TYPE _locale_t
# define SB_LOCALE_ALLOC_FUNC _create_locale
# define SB_LOCALE_FREE_FUNC _free_locale
# define SB_LOCALE_STRTOD_FUNC _strtod_l
# define SB_LOCALE_STRTOL_FUNC _strtol_l
# define SB_LOCALE_SPRINTF_FUNC _sprintf_l
# define SB_LOCALE_SNPRINTF_FUNC _snprintf_l
# define SB_LOCALE_SCANF_FUNC _scanf_l
# define SB_LOCALE_SSCANF_FUNC _sscanf_l
# define SB_LOCALE_FSCANF_FUNC _fscanf_l
# define SB_LOCALE_VPRINTF _vprintf_l
# define SB_LOCALE_FPRINTF_FUNC _fprintf_l
# define SB_LOCALE   , (SB_LOCALE_DATA_TYPE)SbString::getLocaleObject()
#else
# define SB_LOCALE_DATA_TYPE locale_t
# define SB_LOCALE_ALLOC_FUNC newlocale
# define SB_LOCALE_FREE_FUNC freelocale
# define SB_LOCALE_STRTOD_FUNC strtod
# define SB_LOCALE_STRTOL_FUNC strtol
# define SB_LOCALE_SPRINTF_FUNC ::sprintf
# define SB_LOCALE_FPRINTF_FUNC fprintf
# define SB_LOCALE_SNPRINTF_FUNC snprintf
# define SB_LOCALE_SCANF_FUNC scanf
# define SB_LOCALE_SSCANF_FUNC sscanf
# define SB_LOCALE_FSCANF_FUNC fscanf
# define SB_LOCALE_VPRINTF vprintf
# define SB_LOCALE
#endif
 
  static float toFloat_l( const char* str, SbBool* ok = NULL );
 
  static double toDouble_l( const char* str, SbBool* ok = NULL );
 
  static long toLong_l( const char* str, SbBool* ok = NULL );
 
  static void toString_l( char* str, const char* format, float num );
 
  static void toString_l( char* str, const char* format, double num );
 
  static void* getLocaleObject();
 
  //****************************************************************************************
  // Returns a new SbString from the input string, without any tailing blank char
  static SbString trimRight( const SbString & _str ); 
 
  //****************************************************************************************
  // Returns a new SbString from the input string, without any leading blank char
  static SbString trimLeft( const SbString & _str );
 
  //****************************************************************************************
  // Returns a new SbString from the input string, without any leading nor tailing blank char
  static SbString trim( const SbString & _str );
 
private:
 
  // For old functions
  static void buildLocaleCache();
  static bool localeCacheInitialized;
  static bool localeDigitCache[256];
  static bool localeSpaceCache[256];
  static char* s_tmpstr;
  static size_t s_tmpStrSize;
 
  std::wstring m_data;
  std::string m_cdata;
 
  mutable std::wstring m_tmpData;
  mutable std::string m_tmpCData;
 
  bool m_isNull;
 
 
#if !defined(_WIN32)
  // On non win32 platforms wchar_t uses 4 bytes so we must keep
  // a utf16 buffer for the toUtf16 function.
  mutable unsigned short* m_utf16Buffer;
#endif
};
 
 
inline SbBool
SbString::isEmpty() const
{
  return (isNull() || (getLength() == 0));
}
 
inline SbBool
SbString::isNull() const
{
  return m_isNull;
}
 
inline bool SbString::isDigit(const int c)
{
  if ((c < 0) || (c>=256))
    return false;
 
  if (!localeCacheInitialized)
    buildLocaleCache();
  return localeDigitCache[c];
}
 
inline bool SbString::isSpace(const int c)
{
  if (!localeCacheInitialized)
    buildLocaleCache();
  return localeSpaceCache[c];
}
 
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#include <Inventor/SbName.h>
 
#endif // _SB_STRING_