500 lines
17 KiB
C++
500 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef UTLSTRING_H
|
|
#define UTLSTRING_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "limits.h"
|
|
#include "strtools.h"
|
|
#include "utlmemory.h"
|
|
|
|
#if defined(OSX)
|
|
inline wchar_t *wcsdup(const wchar_t *pString) {
|
|
wchar_t *pMemory;
|
|
|
|
if (!pString) return NULL;
|
|
|
|
size_t len = (wcslen(pString) + 1);
|
|
if ((pMemory = (wchar_t *)malloc(len * sizeof(wchar_t))) != NULL) {
|
|
return wcscpy(pMemory, pString);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
inline size_t strnlen(const char *s, size_t n) {
|
|
const char *p = (const char *)memchr(s, 0, n);
|
|
return (p ? p - s : n);
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Simple string class.
|
|
// NOTE: This is *not* optimal! Use in tools, but not runtime code
|
|
//-----------------------------------------------------------------------------
|
|
class CUtlString {
|
|
public:
|
|
typedef enum {
|
|
PATTERN_NONE = 0x00000000,
|
|
PATTERN_DIRECTORY = 0x00000001
|
|
} TUtlStringPattern;
|
|
|
|
public:
|
|
CUtlString();
|
|
CUtlString(const char *pString);
|
|
CUtlString(const char *pString, int length);
|
|
CUtlString(const CUtlString &string);
|
|
|
|
#ifdef MOVE_CONSTRUCTOR_SUPPORT
|
|
// Support moving of CUtlString objects. Long live C++11
|
|
// This move constructor will get called when appropriate, such as when
|
|
// returning objects from functions, or otherwise copying from temporaries
|
|
// which are about to be destroyed. It can also be explicitly invoked with
|
|
// std::move().
|
|
// Move constructor:
|
|
CUtlString(CUtlString &&rhs) {
|
|
// Move the string pointer from the source to this -- be sure to
|
|
// zero out the source to avoid double frees.
|
|
m_pString = rhs.m_pString;
|
|
rhs.m_pString = 0;
|
|
}
|
|
// Move assignment operator:
|
|
CUtlString &operator=(CUtlString &&rhs) {
|
|
// Move the string pointer from the source to this -- be sure to
|
|
// zero out the source to avoid double frees.
|
|
m_pString = rhs.m_pString;
|
|
rhs.m_pString = 0;
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
~CUtlString();
|
|
|
|
const char *Get() const;
|
|
void Set(const char *pValue);
|
|
operator const char *() const;
|
|
|
|
// Set directly and don't look for a null terminator in pValue.
|
|
// nChars does not include the nul and this will only copy
|
|
// at most nChars (even if pValue is longer). If nChars
|
|
// is >strlen(pValue) it will copy past the end, don't do it
|
|
// Does nothing if pValue == String()
|
|
void SetDirect(const char *pValue, int nChars);
|
|
|
|
// for compatibility switching items from UtlSymbol
|
|
const char *String() const { return Get(); }
|
|
|
|
// Returns strlen
|
|
int Length() const;
|
|
// IsEmpty() is more efficient than Length() == 0
|
|
bool IsEmpty() const;
|
|
|
|
// Sets the length (used to serialize into the buffer )
|
|
// Note: If nLen != 0, then this adds an extra byte for a null-terminator.
|
|
void SetLength(int nLen);
|
|
char *GetForModify();
|
|
void Clear();
|
|
void Purge();
|
|
|
|
// Case Change
|
|
void ToLower();
|
|
void ToUpper();
|
|
void Append(const char *pAddition, int nChars);
|
|
|
|
void Append(const char *pchAddition);
|
|
void Append(const char chAddition) {
|
|
char temp[2] = {chAddition, 0};
|
|
Append(temp);
|
|
}
|
|
// Strips the trailing slash
|
|
void StripTrailingSlash();
|
|
void FixSlashes(char cSeparator = CORRECT_PATH_SEPARATOR);
|
|
|
|
// Trim whitespace
|
|
void TrimLeft(char cTarget);
|
|
void TrimLeft(const char *szTargets = "\t\r\n ");
|
|
void TrimRight(char cTarget);
|
|
void TrimRight(const char *szTargets = "\t\r\n ");
|
|
void Trim(char cTarget);
|
|
void Trim(const char *szTargets = "\t\r\n ");
|
|
|
|
bool IsEqual_CaseSensitive(const char *src) const;
|
|
bool IsEqual_CaseInsensitive(const char *src) const;
|
|
|
|
CUtlString &operator=(const CUtlString &src);
|
|
CUtlString &operator=(const char *src);
|
|
|
|
// Test for equality
|
|
bool operator==(const CUtlString &src) const;
|
|
bool operator!=(const CUtlString &src) const { return !operator==(src); }
|
|
|
|
CUtlString &operator+=(const CUtlString &rhs);
|
|
CUtlString &operator+=(const char *rhs);
|
|
CUtlString &operator+=(char c);
|
|
CUtlString &operator+=(int rhs);
|
|
CUtlString &operator+=(double rhs);
|
|
|
|
CUtlString operator+(const char *pOther) const;
|
|
CUtlString operator+(const CUtlString &other) const;
|
|
CUtlString operator+(int rhs) const;
|
|
|
|
bool MatchesPattern(const CUtlString &Pattern, int nFlags = 0)
|
|
const; // case SENSITIVE, use * for wildcard in pattern string
|
|
|
|
char operator[](int i) const;
|
|
|
|
#if !defined(SWIG)
|
|
// Don't let SWIG see the PRINTF_FORMAT_STRING attribute or it will
|
|
// complain.
|
|
int Format(PRINTF_FORMAT_STRING const char *pFormat, ...) FMTFUNCTION(2, 3);
|
|
int FormatV(PRINTF_FORMAT_STRING const char *pFormat, va_list marker);
|
|
#else
|
|
int Format(const char *pFormat, ...);
|
|
int FormatV(const char *pFormat, va_list marker);
|
|
#endif
|
|
|
|
// Defining AltArgumentType_t hints that associative container classes
|
|
// should also implement Find/Insert/Remove functions that take const char*
|
|
// params.
|
|
typedef const char *AltArgumentType_t;
|
|
|
|
// Get a copy of part of the string.
|
|
// If you only specify nStart, it'll go from nStart to the end.
|
|
// You can use negative numbers and it'll wrap around to the start.
|
|
CUtlString Slice(int32 nStart = 0, int32 nEnd = INT_MAX) const;
|
|
|
|
// Get a substring starting from the left or the right side.
|
|
CUtlString Left(int32 nChars) const;
|
|
CUtlString Right(int32 nChars) const;
|
|
|
|
// Get a string with all instances of one character replaced with another.
|
|
CUtlString Replace(char cFrom, char cTo) const;
|
|
|
|
// Replace all instances of specified string with another.
|
|
CUtlString Replace(const char *pszFrom, const char *pszTo) const;
|
|
|
|
// Get this string as an absolute path (calls right through to
|
|
// V_MakeAbsolutePath).
|
|
CUtlString AbsPath(const char *pStartingDir = NULL) const;
|
|
|
|
// Gets the filename (everything except the path.. c:\a\b\c\somefile.txt ->
|
|
// somefile.txt).
|
|
CUtlString UnqualifiedFilename() const;
|
|
|
|
// Gets a string with one directory removed. Uses V_StripLastDir but strips
|
|
// the last slash also!
|
|
CUtlString DirName() const;
|
|
|
|
// Get a string with the extension removed (with V_StripExtension).
|
|
CUtlString StripExtension() const;
|
|
|
|
// Get a string with the filename removed (uses V_UnqualifiedFileName and
|
|
// also strips the last slash)
|
|
CUtlString StripFilename() const;
|
|
|
|
// Get a string with the base filename (with V_FileBase).
|
|
CUtlString GetBaseFilename() const;
|
|
|
|
// Get a string with the file extension (with V_FileBase).
|
|
CUtlString GetExtension() const;
|
|
|
|
// Works like V_ComposeFileName.
|
|
static CUtlString PathJoin(const char *pStr1, const char *pStr2);
|
|
|
|
// These can be used for utlvector sorts.
|
|
static int __cdecl SortCaseInsensitive(const CUtlString *pString1,
|
|
const CUtlString *pString2);
|
|
static int __cdecl SortCaseSensitive(const CUtlString *pString1,
|
|
const CUtlString *pString2);
|
|
|
|
// Empty string for those times when you need to return an empty string and
|
|
// either don't want to pay the construction cost, or are returning a
|
|
// const CUtlString& and cannot just return "".
|
|
static const CUtlString &GetEmptyString();
|
|
|
|
private:
|
|
// INTERNALS
|
|
// AllocMemory allocates enough space for length characters plus a
|
|
// terminating zero. Previous characters are preserved, the buffer is
|
|
// null-terminated, but new characters are not touched.
|
|
void *AllocMemory(uint32 length);
|
|
|
|
// If m_pString is not NULL, it points to the start of the string, and the
|
|
// memory allocation.
|
|
char *m_pString;
|
|
};
|
|
|
|
// // If these are not defined, CUtlConstString as rhs will auto-convert
|
|
// // to const char* and do logical operations on the raw pointers. Ugh.
|
|
// inline friend bool operator<( const T *lhs, const CUtlConstStringBase
|
|
//&rhs ) { return rhs.Compare( lhs ) > 0; } inline friend bool operator==( const
|
|
//T *lhs, const CUtlConstStringBase &rhs ) { return rhs.Compare( lhs ) == 0; }
|
|
// inline friend bool operator!=( const T *lhs, const CUtlConstStringBase
|
|
//&rhs ) { return rhs.Compare( lhs ) != 0; }
|
|
|
|
inline bool operator==(const char *pString, const CUtlString &utlString) {
|
|
return utlString.IsEqual_CaseSensitive(pString);
|
|
}
|
|
|
|
inline bool operator!=(const char *pString, const CUtlString &utlString) {
|
|
return !utlString.IsEqual_CaseSensitive(pString);
|
|
}
|
|
|
|
inline bool operator==(const CUtlString &utlString, const char *pString) {
|
|
return utlString.IsEqual_CaseSensitive(pString);
|
|
}
|
|
|
|
inline bool operator!=(const CUtlString &utlString, const char *pString) {
|
|
return !utlString.IsEqual_CaseSensitive(pString);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inline methods
|
|
//-----------------------------------------------------------------------------
|
|
inline CUtlString::CUtlString() : m_pString(NULL) {}
|
|
|
|
inline CUtlString::CUtlString(const char *pString) : m_pString(NULL) {
|
|
Set(pString);
|
|
}
|
|
|
|
inline CUtlString::CUtlString(const char *pString, int length)
|
|
: m_pString(NULL) {
|
|
SetDirect(pString, length);
|
|
}
|
|
|
|
inline CUtlString::CUtlString(const CUtlString &string) : m_pString(NULL) {
|
|
Set(string.Get());
|
|
}
|
|
|
|
inline CUtlString::~CUtlString() { Purge(); }
|
|
|
|
inline int CUtlString::Length() const {
|
|
if (m_pString) {
|
|
return V_strlen(m_pString);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline bool CUtlString::IsEmpty() const {
|
|
return !m_pString || m_pString[0] == 0;
|
|
}
|
|
|
|
inline int __cdecl CUtlString::SortCaseInsensitive(const CUtlString *pString1,
|
|
const CUtlString *pString2) {
|
|
return V_stricmp(pString1->String(), pString2->String());
|
|
}
|
|
|
|
inline int __cdecl CUtlString::SortCaseSensitive(const CUtlString *pString1,
|
|
const CUtlString *pString2) {
|
|
return V_strcmp(pString1->String(), pString2->String());
|
|
}
|
|
|
|
// Converts to c-strings
|
|
inline CUtlString::operator const char *() const { return Get(); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Implementation of low-level string functionality for character
|
|
// types.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
class StringFuncs {
|
|
public:
|
|
static T *Duplicate(const T *pValue);
|
|
// Note that this function takes a character count, and does not guarantee
|
|
// null-termination.
|
|
static void Copy(T *out_pOut, const T *pIn, int iLengthInChars);
|
|
static int Compare(const T *pLhs, const T *pRhs);
|
|
static int CaselessCompare(const T *pLhs, const T *pRhs);
|
|
static int Length(const T *pValue);
|
|
static const T *FindChar(const T *pStr, const T cSearch);
|
|
static const T *EmptyString();
|
|
static const T *NullDebugString();
|
|
};
|
|
|
|
template <>
|
|
class StringFuncs<char> {
|
|
public:
|
|
static char *Duplicate(const char *pValue) { return strdup(pValue); }
|
|
// Note that this function takes a character count, and does not guarantee
|
|
// null-termination.
|
|
static void Copy(OUT_CAP(iLengthInChars) char *out_pOut, const char *pIn,
|
|
int iLengthInChars) {
|
|
strncpy(out_pOut, pIn, iLengthInChars);
|
|
}
|
|
static int Compare(const char *pLhs, const char *pRhs) {
|
|
return strcmp(pLhs, pRhs);
|
|
}
|
|
static int CaselessCompare(const char *pLhs, const char *pRhs) {
|
|
return Q_strcasecmp(pLhs, pRhs);
|
|
}
|
|
static int Length(const char *pValue) { return (int)strlen(pValue); }
|
|
static const char *FindChar(const char *pStr, const char cSearch) {
|
|
return strchr(pStr, cSearch);
|
|
}
|
|
static const char *EmptyString() { return ""; }
|
|
static const char *NullDebugString() { return "(null)"; }
|
|
};
|
|
|
|
template <>
|
|
class StringFuncs<wchar_t> {
|
|
public:
|
|
static wchar_t *Duplicate(const wchar_t *pValue) { return wcsdup(pValue); }
|
|
// Note that this function takes a character count, and does not guarantee
|
|
// null-termination.
|
|
static void Copy(OUT_CAP(iLengthInChars) wchar_t *out_pOut,
|
|
const wchar_t *pIn, int iLengthInChars) {
|
|
wcsncpy(out_pOut, pIn, iLengthInChars);
|
|
}
|
|
static int Compare(const wchar_t *pLhs, const wchar_t *pRhs) {
|
|
return wcscmp(pLhs, pRhs);
|
|
}
|
|
static int CaselessCompare(const wchar_t *pLhs,
|
|
const wchar_t *pRhs); // no implementation?
|
|
static int Length(const wchar_t *pValue) { return (int)wcslen(pValue); }
|
|
static const wchar_t *FindChar(const wchar_t *pStr, const wchar_t cSearch) {
|
|
return wcschr(pStr, cSearch);
|
|
}
|
|
static const wchar_t *EmptyString() { return L""; }
|
|
static const wchar_t *NullDebugString() { return L"(null)"; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Dirt-basic auto-release string class. Not intended for manipulation,
|
|
// can be stored in a container or forwarded as a functor parameter.
|
|
// Note the benefit over CUtlString: sizeof(CUtlConstString) == sizeof(char*).
|
|
// Also note: null char* pointers are treated identically to empty strings.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename T = char>
|
|
class CUtlConstStringBase {
|
|
public:
|
|
CUtlConstStringBase() : m_pString(NULL) {}
|
|
explicit CUtlConstStringBase(const T *pString) : m_pString(NULL) {
|
|
Set(pString);
|
|
}
|
|
CUtlConstStringBase(const CUtlConstStringBase &src) : m_pString(NULL) {
|
|
Set(src.m_pString);
|
|
}
|
|
~CUtlConstStringBase() { Set(NULL); }
|
|
|
|
void Set(const T *pValue);
|
|
void Clear() { Set(NULL); }
|
|
|
|
const T *Get() const {
|
|
return m_pString ? m_pString : StringFuncs<T>::EmptyString();
|
|
}
|
|
operator const T *() const {
|
|
return m_pString ? m_pString : StringFuncs<T>::EmptyString();
|
|
}
|
|
|
|
bool IsEmpty() const {
|
|
return m_pString == NULL;
|
|
} // Note: empty strings are never stored by Set
|
|
|
|
int Compare(const T *rhs) const;
|
|
|
|
// Logical ops
|
|
bool operator<(const T *rhs) const { return Compare(rhs) < 0; }
|
|
bool operator==(const T *rhs) const { return Compare(rhs) == 0; }
|
|
bool operator!=(const T *rhs) const { return Compare(rhs) != 0; }
|
|
bool operator<(const CUtlConstStringBase &rhs) const {
|
|
return Compare(rhs.m_pString) < 0;
|
|
}
|
|
bool operator==(const CUtlConstStringBase &rhs) const {
|
|
return Compare(rhs.m_pString) == 0;
|
|
}
|
|
bool operator!=(const CUtlConstStringBase &rhs) const {
|
|
return Compare(rhs.m_pString) != 0;
|
|
}
|
|
|
|
// If these are not defined, CUtlConstString as rhs will auto-convert
|
|
// to const char* and do logical operations on the raw pointers. Ugh.
|
|
inline friend bool operator<(const T *lhs, const CUtlConstStringBase &rhs) {
|
|
return rhs.Compare(lhs) > 0;
|
|
}
|
|
inline friend bool operator==(const T *lhs,
|
|
const CUtlConstStringBase &rhs) {
|
|
return rhs.Compare(lhs) == 0;
|
|
}
|
|
inline friend bool operator!=(const T *lhs,
|
|
const CUtlConstStringBase &rhs) {
|
|
return rhs.Compare(lhs) != 0;
|
|
}
|
|
|
|
CUtlConstStringBase &operator=(const T *src) {
|
|
Set(src);
|
|
return *this;
|
|
}
|
|
CUtlConstStringBase &operator=(const CUtlConstStringBase &src) {
|
|
Set(src.m_pString);
|
|
return *this;
|
|
}
|
|
|
|
// Defining AltArgumentType_t is a hint to containers that they should
|
|
// implement Find/Insert/Remove functions that take const char* params.
|
|
typedef const T *AltArgumentType_t;
|
|
|
|
protected:
|
|
const T *m_pString;
|
|
};
|
|
|
|
template <typename T>
|
|
void CUtlConstStringBase<T>::Set(const T *pValue) {
|
|
if (pValue != m_pString) {
|
|
free((void *)m_pString);
|
|
m_pString =
|
|
pValue && pValue[0] ? StringFuncs<T>::Duplicate(pValue) : NULL;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
int CUtlConstStringBase<T>::Compare(const T *rhs) const {
|
|
// Empty or null RHS?
|
|
if (!rhs || !rhs[0]) return m_pString ? 1 : 0;
|
|
|
|
// Empty *this, non-empty RHS?
|
|
if (!m_pString) return -1;
|
|
|
|
// Neither empty
|
|
return StringFuncs<T>::Compare(m_pString, rhs);
|
|
}
|
|
|
|
typedef CUtlConstStringBase<char> CUtlConstString;
|
|
typedef CUtlConstStringBase<wchar_t> CUtlConstWideString;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper functor objects.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
struct UTLConstStringCaselessStringLessFunctor {
|
|
bool operator()(const CUtlConstStringBase<T> &a, const char *b) const {
|
|
return StringFuncs<T>::CaselessCompare(a.Get(), b) < 0;
|
|
}
|
|
};
|
|
template <typename T>
|
|
struct UTLConstStringCaselessStringEqualFunctor {
|
|
bool operator()(const CUtlConstStringBase<T> &a, const char *b) const {
|
|
return StringFuncs<T>::CaselessCompare(a.Get(), b) == 0;
|
|
}
|
|
};
|
|
|
|
// Helper function for CUtlMaps with a CUtlString key
|
|
inline bool UtlStringLessFunc(const CUtlString &lhs, const CUtlString &rhs) {
|
|
return V_strcmp(lhs.Get(), rhs.Get()) < 0;
|
|
}
|
|
inline bool UtlStringCaseInsensitiveLessFunc(const CUtlString &lhs,
|
|
const CUtlString &rhs) {
|
|
return V_stricmp(lhs.Get(), rhs.Get()) < 0;
|
|
}
|
|
|
|
#endif // UTLSTRING_H
|