Initial commit

engines/bagel/boflib/string.h

@@ -0,0 +1,274 @@
+
+/* 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