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