mirror of
https://github.com/scummvm/scummvm.git
synced 2025-04-02 10:52:32 -04:00
274 lines
7.2 KiB
C++
274 lines
7.2 KiB
C++
|
|
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#ifndef BAGEL_BOFLIB_STRING_H
|
|
#define BAGEL_BOFLIB_STRING_H
|
|
|
|
#include "common/system.h"
|
|
#include "bagel/boflib/object.h"
|
|
|
|
namespace Bagel {
|
|
|
|
// The buffer size and string len members are shorts, and use the high byte
|
|
// of the buffer size to tell us if it is stack memory being used.
|
|
#define mUseStackMem 0x8000
|
|
#define NORMALIZEBUFFERSIZE() (_nBufferSize & ~mUseStackMem)
|
|
#define SETBUFFERSIZE(size, usestackmem) (_nBufferSize = (uint16)((size) + ((usestackmem) ? mUseStackMem : 0)))
|
|
#define USESSTACKMEM() (_nBufferSize & mUseStackMem)
|
|
|
|
class CBofString : public CBofObject {
|
|
public:
|
|
// Constructors
|
|
/**
|
|
* Default constructor
|
|
*/
|
|
CBofString();
|
|
|
|
/**
|
|
* Construct a string from a null terminated string
|
|
* @param pszBuf Source string
|
|
*/
|
|
CBofString(const char *pszBuf);
|
|
|
|
/**
|
|
* Construct a string based on a source string
|
|
*/
|
|
CBofString(const CBofString &stringSrc);
|
|
|
|
/**
|
|
* Construct a string with a single character repeated a number of times
|
|
* @param ch Character to use
|
|
* @param nRepeat Number of repeats
|
|
*/
|
|
CBofString(char ch, int nRepeat = 1);
|
|
|
|
/**
|
|
* Constructs a string, and sets initial buffer size
|
|
* @param nLength String length
|
|
*/
|
|
CBofString(int nLength);
|
|
|
|
/**
|
|
* Construct a string based on a subset of a passed null terminated string
|
|
* @brief This modifies the passed source string to null terminate the substring
|
|
* @param pszBuff Source string
|
|
* @param pszBuffLen Substring length
|
|
*/
|
|
CBofString(char *pszBuff, int pszBuffLen);
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
virtual ~CBofString();
|
|
|
|
// Attributes & Operations
|
|
|
|
int getBufferSize() const {
|
|
return NORMALIZEBUFFERSIZE();
|
|
}
|
|
int getLength() const {
|
|
return _nLength;
|
|
}
|
|
bool isEmpty() const {
|
|
return _nLength == 0;
|
|
}
|
|
|
|
/**
|
|
* De-Allocates internal buffer for current CBofString
|
|
*/
|
|
void free();
|
|
|
|
void growTo(int nNewSize); // Resize the buffer
|
|
|
|
char getAt(int nIndex); // 0 based
|
|
char operator[](int nIndex); // same as getAt
|
|
|
|
operator const char *() const {
|
|
return (const char *)_pszData;
|
|
}
|
|
const char *getBuffer() const {
|
|
return _pszData;
|
|
}
|
|
|
|
// Hashing support.
|
|
//
|
|
int hash() const;
|
|
|
|
// Overloaded assignment
|
|
/**
|
|
* Copies specified string into current CBofString
|
|
* @param pszSourceBuf Buffer to copy
|
|
*/
|
|
void copy(const char *pszSourceBuf);
|
|
|
|
const CBofString &operator=(const CBofString &cStringSrc);
|
|
const CBofString &operator=(char ch);
|
|
const CBofString &operator=(const char *psz);
|
|
|
|
// String concatenation
|
|
const CBofString &operator+=(const CBofString &cString);
|
|
const CBofString &operator+=(char ch);
|
|
const CBofString &operator+=(const char *psz);
|
|
|
|
friend CBofString operator+(const CBofString &string1, const CBofString &string2);
|
|
friend CBofString operator+(const CBofString &string, char ch);
|
|
friend CBofString operator+(char ch, const CBofString &string);
|
|
friend CBofString operator+(const CBofString &string, const char *lpsz);
|
|
friend CBofString operator+(const char *lpsz, const CBofString &string);
|
|
|
|
// String comparison
|
|
int compare(const char *lpsz) const; // straight character
|
|
int compareNoCase(const char *lpsz) const; // ignore case
|
|
|
|
// Simple sub-string extraction
|
|
//
|
|
CBofString mid(int nFirst, int nCount) const;
|
|
CBofString mid(int nFirst) const;
|
|
CBofString left(int nCount) const;
|
|
CBofString right(int nCount) const;
|
|
|
|
void deleteLastChar();
|
|
|
|
// Upper/lower/reverse conversion
|
|
void makeUpper();
|
|
|
|
// Searching (return starting index, or -1 if not found)
|
|
// Look for a specific sub-string
|
|
int find(const char *lpszSub) const; // like "C" strstr
|
|
int findNumOccurrences(const char *pszSub);
|
|
|
|
// Search and replace routines
|
|
void replaceCharAt(int, char);
|
|
void replaceChar(char chOld, char chNew);
|
|
void replaceStr(const char *pszOld, const char *pszNew);
|
|
|
|
// Access to string implementation buffer as "C" character array
|
|
char *getBuffer();
|
|
|
|
protected:
|
|
// implementation helpers
|
|
|
|
/**
|
|
* initialize current CBofString members
|
|
*/
|
|
void init();
|
|
|
|
/**
|
|
* Allocates specified string into specified destination
|
|
*/
|
|
void allocCopy(CBofString &dest, int nCopyLen, int nCopyIndex, int nExtraLen) const;
|
|
|
|
/**
|
|
* Allocates internal buffer for current CBofString
|
|
* @param nLen Initial buffer size
|
|
*/
|
|
void allocBuffer(int nLen);
|
|
|
|
void concatCopy(int nSrc1Len, const char *lpszSrc1Data, int nSrc2Len, const char *lpszSrc2Data, int nAllocLen = 0);
|
|
void concatInPlace(int nSrcLen, const char *lpszSrcData);
|
|
static int safeStrlen(const char *lpsz);
|
|
|
|
// Lengths/sizes in characters
|
|
// (note: an extra character is always allocated)
|
|
//
|
|
char *_pszData; // actual string (zero terminated)
|
|
uint16 _nLength; // does not include terminating 0
|
|
uint16 _nBufferSize; // does not include terminating 0
|
|
};
|
|
|
|
// Inline Comparison operators
|
|
//
|
|
inline bool operator==(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) == 0;
|
|
}
|
|
|
|
inline bool operator==(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) == 0;
|
|
}
|
|
|
|
inline bool operator==(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) == 0;
|
|
}
|
|
|
|
inline bool operator!=(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) != 0;
|
|
}
|
|
|
|
inline bool operator!=(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) != 0;
|
|
}
|
|
|
|
inline bool operator!=(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) != 0;
|
|
}
|
|
|
|
inline bool operator<(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) < 0;
|
|
}
|
|
|
|
inline bool operator<(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) < 0;
|
|
}
|
|
|
|
inline bool operator<(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) > 0;
|
|
}
|
|
|
|
inline bool operator>(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) > 0;
|
|
}
|
|
|
|
inline bool operator>(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) > 0;
|
|
}
|
|
|
|
inline bool operator>(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) < 0;
|
|
}
|
|
|
|
inline bool operator<=(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) <= 0;
|
|
}
|
|
|
|
inline bool operator<=(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) <= 0;
|
|
}
|
|
|
|
inline bool operator<=(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) >= 0;
|
|
}
|
|
|
|
inline bool operator>=(const CBofString &s1, const CBofString &s2) {
|
|
return s1.compare(s2) >= 0;
|
|
}
|
|
|
|
inline bool operator>=(const CBofString &s1, const char *s2) {
|
|
return s1.compare(s2) >= 0;
|
|
}
|
|
|
|
inline bool operator>=(const char *s1, const CBofString &s2) {
|
|
return s2.compare(s1) <= 0;
|
|
}
|
|
|
|
} // namespace Bagel
|
|
|
|
#endif
|