string.h

 
/* 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
    CBofString();
 
    CBofString(const char *pszBuf);
 
    CBofString(const CBofString &stringSrc);
 
    CBofString(char ch, int nRepeat = 1);
 
    CBofString(int nLength);
 
    CBofString(char *pszBuff, int pszBuffLen);
 
    virtual ~CBofString();
 
    // Attributes & Operations
 
    int getBufferSize() const {
        return NORMALIZEBUFFERSIZE();
    }
    int getLength() const {
        return _nLength;
    }
    bool isEmpty() const {
        return _nLength == 0;
    }
 
    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
    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
 
    void init();
 
    void allocCopy(CBofString &dest, int nCopyLen, int nCopyIndex, int nExtraLen) const;
 
    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