str-base.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 COMMON_STR_BASE_H
#define COMMON_STR_BASE_H

#include "common/scummsys.h"
#include "common/str-enc.h"

#include <stdarg.h>

namespace Common {
template<class T>
class BaseString {
public:
    static void releaseMemoryPoolMutex();

    static const uint32 npos = 0xFFFFFFFF;
    typedef T          value_type;
    typedef T *        iterator;
    typedef const T *  const_iterator;
    typedef size_t     size_type;

protected:
    static const uint32 _builtinCapacity = 32 - (sizeof(uint32) + sizeof(char *)) / sizeof(value_type);

    uint32 _size;

    value_type  *_str;


    union {
        value_type _storage[_builtinCapacity];
        struct {
            mutable int *_refCount;
            uint32       _capacity;
        } _extern;
    };

    inline bool isStorageIntern() const {
        return _str == _storage;
    }

public:
    constexpr BaseString() : _size(0), _str(_storage), _storage{0} {}

    explicit constexpr BaseString(value_type c) : _size((c == 0) ? 0 : 1), _str(_storage), _storage{c, 0} {}

    BaseString(size_t n, value_type c);

    BaseString(const BaseString &str);

    BaseString(BaseString &&str);

    explicit BaseString(const value_type *str);

    BaseString(const value_type *str, uint32 len);

    BaseString(const value_type *beginP, const value_type *endP);

    bool operator==(const BaseString &x) const;
    bool operator==(const value_type *x) const;
    bool operator!=(const BaseString &x) const;
    bool operator!=(const value_type *x) const;

    bool operator<(const BaseString &x) const;
    bool operator<(const value_type *x) const;
    bool operator<=(const BaseString &x) const;
    bool operator<=(const value_type *x) const;
    bool operator>(const BaseString &x) const;
    bool operator>(const value_type *x) const;
    bool operator>=(const BaseString &x) const;
    bool operator>=(const value_type *x) const;

    bool equals(const BaseString &x) const;
    bool equals(const value_type *x) const;
    bool equalsC(const char *x) const;
    int compareTo(const BaseString &x) const;           // strcmp clone
    int compareTo(const value_type *x) const;             // strcmp clone
    int compareToC(const char *x) const;             // strcmp clone

    void setChar(value_type c, uint32 p);

    void deleteChar(uint32 p);

    inline void deleteLastChar() { chop(1); }

    void erase(uint32 p, uint32 len = npos);

    iterator erase(iterator it);

    void chop(uint32 len = 1);

    void clear();

    iterator begin() {
        // Since the user could potentially
        // change the string via the returned
        // iterator we have to assure we are
        // pointing to a unique storage.
        makeUnique();

        return _str;
    }

    iterator end() {
        return begin() + size();
    }

    const_iterator begin() const {
        return _str;
    }

    const_iterator end() const {
        return begin() + size();
    }

    inline const value_type *c_str() const { return _str; }
    inline uint size() const         { return _size; }

    inline bool empty() const { return (_size == 0); }
    value_type firstChar() const    { return (_size > 0) ? _str[0] : 0; }
    value_type lastChar() const     { return (_size > 0) ? _str[_size - 1] : 0; }

    value_type &operator[](size_t idx) {
        assert(_str);
        assert(idx < _size);
        return _str[idx];
    }

    value_type operator[](size_t idx) const {
        assert(_str);
        assert(idx < _size);
        return _str[idx];
    }

    value_type at(size_t idx) const { return operator[](idx); }

    bool contains(const BaseString &otherString) const;
    bool contains(value_type x) const;

    void insertChar(value_type c, uint32 p);
    void insertString(const value_type *s, uint32 p);
    void insertString(const BaseString &s, uint32 p);

    uint32 find(value_type x, uint32 pos = 0) const;
    size_t find(const value_type *s, uint32 pos = 0) const;
    uint32 find(const BaseString &str, uint32 pos = 0) const;

    size_t rfind(const value_type *s) const;
    size_t rfind(const BaseString &s) const {
        return rfind(s.c_str());
    }

    size_t rfind(value_type c, size_t pos = npos) const;

    size_t findFirstOf(value_type c, size_t pos = 0) const;

    size_t findFirstOf(const value_type *chars, size_t pos = 0) const;
    size_t findFirstOf(const BaseString &chars, size_t pos = 0) const {
        return findFirstOf(chars.c_str(), pos);
    }

    size_t findLastOf(value_type c, size_t pos = npos) const;

    size_t findLastOf(const value_type *chars, size_t pos = npos) const;
    size_t findLastOf(const BaseString &chars, size_t pos = npos) const {
        return findLastOf(chars.c_str(), pos);
    }

    size_t findFirstNotOf(value_type c, size_t pos = 0) const;

    size_t findFirstNotOf(const value_type *chars, size_t pos = 0) const;
    size_t findFirstNotOf(const BaseString &chars, size_t pos = 0) const {
        return findFirstNotOf(chars.c_str(), pos);
    }

    size_t findLastNotOf(value_type c) const;

    size_t findLastNotOf(const value_type *chars) const;
    size_t findLastNotOf(const BaseString &chars) const {
        return findLastNotOf(chars.c_str());
    }

    // Replace 'count' bytes, starting from 'pos' with str.
    void replace(uint32 pos, uint32 count, const BaseString &str);
    // The same as above, but accepts a C-like array of characters.
    void replace(uint32 pos, uint32 count, const value_type *str);
    // Replace the characters in [begin, end) with str._str.
    void replace(iterator begin, iterator end, const BaseString &str);
    // Replace the characters in [begin, end) with str.
    void replace(iterator begin, iterator end, const value_type *str);
    // Replace _str[posOri, posOri + countOri) with
    // str._str[posDest, posDest + countDest)
    void replace(uint32 posOri, uint32 countOri, const BaseString &str,
                    uint32 posDest, uint32 countDest);
    // Replace _str[posOri, posOri + countOri) with
    // str[posDest, posDest + countDest)
    void replace(uint32 posOri, uint32 countOri, const value_type *str,
                    uint32 posDest, uint32 countDest);
    void replace(value_type from, value_type to);

    void assign(const BaseString &str);
    void assign(BaseString &&str);
    void assign(size_t count, value_type c);
    void assign(const value_type *str);
    void assign(const value_type *str, size_t count);

    void append(const value_type *str);
    void append(size_t count, value_type c);
    void append(const BaseString &str);

    void append(const value_type *begin, const value_type *end);

    inline void push_back(value_type c) {
        append(1, c);
    }

    void wordWrap(const uint32 maxLength);

    uint64 asUint64() const;

    uint64 asUint64Ext() const;

    void toLowercase();

    void toUppercase();

    void trim();

    uint hash() const;

protected:
    ~BaseString();

    void makeUnique() {
        ensureCapacity(_size, true);
    }

    void ensureCapacity(uint32 new_size, bool keep_old);
    void incRefCount() const;
    void decRefCount(int *oldRefCount);
    void initWithValueTypeChar(size_t count, value_type c);
    void initWithValueTypeStr(const value_type *str, uint32 len);

    void assignInsert(const value_type *str, uint32 p);
    void assignInsert(value_type c, uint32 p);
    void assignInsert(const BaseString &str, uint32 p);

    bool pointerInOwnBuffer(const value_type *str) const;

    uint getUnsignedValue(uint pos) const;

    void toCase(int (*caseChangeFunc)(int));

    static size_t cStrLen(const value_type *str);
    static const value_type *cMemChr(const value_type *ptr, value_type c, size_t count);
    static       value_type *cMemChr(value_type *ptr,       value_type c, size_t count);
    static int cMemCmp(const value_type* ptr1, const value_type* ptr2, size_t count);
    static void cMemSet(value_type *ptr, value_type c, size_t count);
};
}
#endif