string.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <algorithm>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <promeki/core/namespace.h>
#include <promeki/core/util.h>
#include <promeki/core/error.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/char.h>
#include <promeki/core/stringdata.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class StringList;
 
class String {
        public:
                using List = promeki::List<String>;
 
                class CharIterator {
                        public:
                                using iterator_category = std::random_access_iterator_tag;
                                using value_type        = Char;
                                using difference_type   = std::ptrdiff_t;
                                using pointer           = void;
                                using reference         = Char;
 
                                CharIterator() : _data(nullptr), _idx(0) {}
                                CharIterator(const StringData *data, size_t idx) : _data(data), _idx(idx) {}
 
                                Char operator*() const { return _data->charAt(_idx); }
                                Char operator[](difference_type n) const { return _data->charAt(_idx + n); }
 
                                CharIterator &operator++() { ++_idx; return *this; }
                                CharIterator operator++(int) { auto tmp = *this; ++_idx; return tmp; }
                                CharIterator &operator--() { --_idx; return *this; }
                                CharIterator operator--(int) { auto tmp = *this; --_idx; return tmp; }
                                CharIterator &operator+=(difference_type n) { _idx += n; return *this; }
                                CharIterator &operator-=(difference_type n) { _idx -= n; return *this; }
                                CharIterator operator+(difference_type n) const { return {_data, _idx + n}; }
                                CharIterator operator-(difference_type n) const { return {_data, _idx - n}; }
                                difference_type operator-(const CharIterator &o) const {
                                        return static_cast<difference_type>(_idx) - static_cast<difference_type>(o._idx);
                                }
                                friend CharIterator operator+(difference_type n, const CharIterator &it) {
                                        return it + n;
                                }
 
                                bool operator==(const CharIterator &o) const { return _idx == o._idx; }
                                bool operator!=(const CharIterator &o) const { return _idx != o._idx; }
                                bool operator<(const CharIterator &o) const { return _idx < o._idx; }
                                bool operator<=(const CharIterator &o) const { return _idx <= o._idx; }
                                bool operator>(const CharIterator &o) const { return _idx > o._idx; }
                                bool operator>=(const CharIterator &o) const { return _idx >= o._idx; }
 
                        private:
                                const StringData *_data;
                                size_t _idx;
                };
 
                using ConstIterator = CharIterator;
 
                static constexpr size_t npos = StringData::npos;
 
                static constexpr const char *WhitespaceChars = " \t\n\r\f\v";
 
                enum Encoding {
                        Latin1,  
                        Unicode  
                };
 
                // ============================================================
                // Static factory methods (implemented in string.cpp)
                // ============================================================
 
                static String number(int8_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(uint8_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(int16_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(uint16_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(int32_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(uint32_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(int64_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
                static String number(uint64_t value, int base = 10, int padding = 0,
                                char padchar = ' ', bool addPrefix = false);
 
                static String number(bool value) {
                        return value ? "true" : "false";
                }
 
                static String number(float value, int precision = 9);
                static String number(double value, int precision = 9);
 
                template <typename T>
                static String dec(const T &val, int padding = 0, char padchar = ' ') {
                        return number(static_cast<int64_t>(val), 10, padding, padchar);
                }
 
                template <typename T>
                static String hex(const T &val, int padding = 0, bool addPrefix = true) {
                        int totalWidth = (addPrefix && padding > 0) ? padding + 2 : padding;
                        return number(static_cast<uint64_t>(val), 16, totalWidth, '0', addPrefix);
                }
 
                template <typename T>
                static String bin(const T &val, int digits = 32, bool addPrefix = true) {
                        std::string ret;
                        if(addPrefix) ret += "0b";
                        T mask = static_cast<T>(1) << (digits - 1);
                        for(int i = 0; i < digits; i++) {
                                ret.push_back(val & mask ? '1' : '0');
                                mask >>= 1;
                        }
                        return ret;
                }
 
                PROMEKI_PRINTF_FUNC(1, 2) static String sprintf(const char *fmt, ...);
 
                static String fromUtf8(const char *data, size_t len) {
                        return String(StringUnicodeData::fromUtf8(data, len));
                }
 
                static String fromLiteralData(StringData *data) {
                        return String(data);
                }
 
                // ============================================================
                // Constructors
                // ============================================================
 
                String()
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data())) {}
 
                String(std::nullptr_t) : String() {}
 
                String(const char *str)
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data(str ? str : ""))) {}
 
                String(const char *str, size_t len)
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data(str, len))) {}
 
                String(size_t ct, char c)
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data(ct, c))) {}
 
                String(const std::string &str)
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data(str))) {}
 
                String(std::string &&str)
                        : d(SharedPtr<StringData>::takeOwnership(new StringLatin1Data(std::move(str)))) {}
 
                // ============================================================
                // Const access (pure delegation)
                // ============================================================
 
                const std::string &str() const { return d->str(); }
 
                const char *cstr() const { return d->cstr(); }
 
                size_t size() const { return d->length(); }
 
                size_t length() const { return d->length(); }
 
                size_t byteCount() const { return d->byteCount(); }
 
                uint8_t byteAt(size_t idx) const { return d->byteAt(idx); }
 
                Char charAt(size_t idx) const { return d->charAt(idx); }
 
                bool isEmpty() const { return d->isEmpty(); }
 
                int referenceCount() const { return d.referenceCount(); }
 
                bool isLiteral() const { return d->isLiteral(); }
 
                Encoding encoding() const {
                        return d->isLatin1() ? Latin1 : Unicode;
                }
 
                // ============================================================
                // Character iterators
                // ============================================================
 
                ConstIterator begin() const noexcept { return {d.ptr(), 0}; }
                ConstIterator cbegin() const noexcept { return {d.ptr(), 0}; }
                ConstIterator end() const noexcept { return {d.ptr(), d->length()}; }
                ConstIterator cend() const noexcept { return {d.ptr(), d->length()}; }
 
                // ============================================================
                // Implicit conversions
                // ============================================================
 
                operator const std::string &() const { return d->str(); }
 
                operator const char *() const { return d->cstr(); }
 
                // ============================================================
                // Find / contains
                // ============================================================
 
                size_t find(char val, size_t from = 0) const { return d->find(Char(val), from); }
                size_t find(Char val, size_t from = 0) const { return d->find(val, from); }
                size_t find(const char *val, size_t from = 0) const { return d->find(*String(val).d, from); }
                size_t find(const String &val, size_t from = 0) const { return d->find(*val.d, from); }
 
                size_t rfind(char val, size_t from = npos) const { return d->rfind(Char(val), from); }
                size_t rfind(Char val, size_t from = npos) const { return d->rfind(val, from); }
                size_t rfind(const char *val, size_t from = npos) const { return d->rfind(*String(val).d, from); }
                size_t rfind(const String &val, size_t from = npos) const { return d->rfind(*val.d, from); }
 
                bool contains(char val) const { return d->find(Char(val)) != npos; }
                bool contains(Char val) const { return d->find(val) != npos; }
                bool contains(const String &val) const { return d->find(*val.d) != npos; }
                bool contains(const char *val) const { return contains(String(val)); }
 
                size_t count(const String &substr) const { return d->count(*substr.d); }
 
                // ============================================================
                // Substring
                // ============================================================
 
                String substr(size_t pos = 0, size_t len = npos) const {
                        if(pos >= d->length()) return String();
                        if(len == npos) len = d->length() - pos;
                        return String(d->createSubstr(pos, len));
                }
 
                String mid(size_t pos, size_t count = npos) const { return substr(pos, count); }
 
                String left(size_t count) const { return substr(0, count); }
 
                String right(std::size_t count) const {
                        if(count >= length()) return *this;
                        return substr(length() - count, count);
                }
 
                // ============================================================
                // Mutation (COW)
                // ============================================================
 
                void clear() { d.modify()->clear(); }
 
                void resize(size_t val) { d.modify()->resize(val); }
 
                void erase(size_t pos, size_t count = 1) { d.modify()->erase(pos, count); }
 
                void setCharAt(size_t idx, Char ch) {
                        if(d->isLatin1() && ch.codepoint() > 0xFF) {
                                auto *ud = StringUnicodeData::fromLatin1(d->str());
                                d = SharedPtr<StringData>::takeOwnership(ud);
                        }
                        d.modify()->setCharAt(idx, ch);
                }
 
                void insert(size_t pos, const String &s) {
                        if(d->isLatin1() && !s.d->isLatin1()) {
                                auto *ud = StringUnicodeData::fromLatin1(d->str());
                                d = SharedPtr<StringData>::takeOwnership(ud);
                        }
                        d.modify()->insert(pos, *s.d);
                }
 
                // ============================================================
                // Assignment
                // ============================================================
 
                String &operator=(const std::string &str) {
                        d = SharedPtr<StringData>::takeOwnership(new StringLatin1Data(str));
                        return *this;
                }
 
                String &operator=(std::string &&str) {
                        d = SharedPtr<StringData>::takeOwnership(new StringLatin1Data(std::move(str)));
                        return *this;
                }
 
                String &operator=(const char *str) {
                        d = SharedPtr<StringData>::takeOwnership(new StringLatin1Data(str ? str : ""));
                        return *this;
                }
 
                // ============================================================
                // Concatenation
                // ============================================================
 
                String &operator+=(const String &val) {
                        if(val.isEmpty()) return *this;
                        if(d->isLatin1() && !val.d->isLatin1()) {
                                auto *ud = StringUnicodeData::fromLatin1(d->str());
                                d = SharedPtr<StringData>::takeOwnership(ud);
                        }
                        d.modify()->append(*val.d);
                        return *this;
                }
 
                String &operator+=(const std::string &val) { return *this += String(val); }
                String &operator+=(const char *val) { return *this += String(val); }
                String &operator+=(char val) { return *this += String(1, val); }
 
                String operator+(const String &val) const {
                        String result = *this;
                        result += val;
                        return result;
                }
 
                String operator+(const std::string &val) const { return *this + String(val); }
                String operator+(const char *val) const { return *this + String(val); }
                String operator+(char val) const { return *this + String(1, val); }
 
                // ============================================================
                // Comparison
                // ============================================================
 
                bool operator==(const String &val) const {
                        if(d->length() != val.d->length()) return false;
                        if(d->isLatin1() && val.d->isLatin1()) return d->str() == val.d->str();
                        for(size_t i = 0; i < d->length(); ++i) {
                                if(d->charAt(i) != val.d->charAt(i)) return false;
                        }
                        return true;
                }
 
                bool operator==(const char *val) const { return d->str() == val; }
                bool operator==(char val) const { return d->length() == 1 && d->charAt(0) == val; }
 
                bool operator!=(const String &val) const { return !(*this == val); }
                bool operator!=(const char *val) const { return !(*this == val); }
                bool operator!=(char val) const { return !(*this == val); }
 
                friend bool operator<(const String &lhs, const String &rhs) {
                        return lhs.str() < rhs.str();
                }
 
                friend bool operator<=(const String &lhs, const String &rhs) {
                        return !(rhs < lhs);
                }
 
                friend bool operator>(const String &lhs, const String &rhs) {
                        return rhs < lhs;
                }
 
                friend bool operator>=(const String &lhs, const String &rhs) {
                        return !(lhs < rhs);
                }
 
                // ============================================================
                // Case / whitespace
                // ============================================================
 
                String toUpper() const {
                        if(d->isLatin1()) {
                                std::string s = d->str();
                                std::transform(s.begin(), s.end(), s.begin(), ::toupper);
                                return String(std::move(s));
                        }
                        promeki::List<Char> chars;
                        for(size_t i = 0; i < d->length(); ++i)
                                chars.pushToBack(d->charAt(i).toUpper());
                        return String(new StringUnicodeData(std::move(chars)));
                }
 
                String toLower() const {
                        if(d->isLatin1()) {
                                std::string s = d->str();
                                std::transform(s.begin(), s.end(), s.begin(), ::tolower);
                                return String(std::move(s));
                        }
                        promeki::List<Char> chars;
                        for(size_t i = 0; i < d->length(); ++i)
                                chars.pushToBack(d->charAt(i).toLower());
                        return String(new StringUnicodeData(std::move(chars)));
                }
 
                String trim() const {
                        size_t len = length();
                        if(len == 0) return String();
                        size_t first = 0;
                        while(first < len && d->charAt(first).isSpace()) ++first;
                        if(first == len) return String();
                        size_t last = len - 1;
                        while(last > first && d->charAt(last).isSpace()) --last;
                        return substr(first, last - first + 1);
                }
 
                // ============================================================
                // Starts / ends / reverse / numeric
                // ============================================================
 
                bool startsWith(const String &prefix) const {
                        if(prefix.length() > length()) return false;
                        for(size_t i = 0; i < prefix.length(); ++i) {
                                if(d->charAt(i) != prefix.d->charAt(i)) return false;
                        }
                        return true;
                }
 
                bool startsWith(char c) const {
                        return !isEmpty() && d->charAt(0) == c;
                }
 
                bool endsWith(const String &suffix) const {
                        if(suffix.length() > length()) return false;
                        size_t offset = length() - suffix.length();
                        for(size_t i = 0; i < suffix.length(); ++i) {
                                if(d->charAt(offset + i) != suffix.d->charAt(i)) return false;
                        }
                        return true;
                }
 
                String reverse() const {
                        String result = *this;
                        result.d.modify()->reverseInPlace();
                        return result;
                }
 
                bool isNumeric() const {
                        if(isEmpty()) return false;
                        for(size_t i = 0; i < d->length(); ++i) {
                                if(!d->charAt(i).isDigit()) return false;
                        }
                        return true;
                }
 
                String replace(const String &find, const String &replacement) const;
 
                int compareIgnoreCase(const String &other) const {
                        size_t len = std::min(length(), other.length());
                        for(size_t i = 0; i < len; ++i) {
                                char32_t a = d->charAt(i).toLower().codepoint();
                                char32_t b = other.d->charAt(i).toLower().codepoint();
                                if(a != b) return a < b ? -1 : 1;
                        }
                        if(length() < other.length()) return -1;
                        if(length() > other.length()) return 1;
                        return 0;
                }
 
                uint64_t hash() const {
                        return d->hash();
                }
 
                // ============================================================
                // Encoding conversion
                // ============================================================
 
                String toLatin1() const {
                        if(d->isLatin1()) return *this;
                        std::string s;
                        s.reserve(d->length());
                        for(size_t i = 0; i < d->length(); ++i) {
                                char32_t cp = d->charAt(i).codepoint();
                                s += static_cast<char>(cp <= 0xFF ? cp : '?');
                        }
                        return String(std::move(s));
                }
 
                String toUnicode() const {
                        if(!d->isLatin1()) return *this;
                        return String(StringUnicodeData::fromLatin1(d->str()));
                }
 
                // ============================================================
                // Arg replacement (implemented in string.cpp)
                // ============================================================
 
                String &arg(const String &str);
 
                String &arg(int8_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(uint8_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(int16_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(uint16_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(int32_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(uint32_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(int64_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                String &arg(uint64_t value, int base = 10, int padding = 0,
                            char padchar = ' ', bool addPrefix = false) {
                        return arg(number(value, base, padding, padchar, addPrefix));
                }
 
                // ============================================================
                // Conversion (implemented in string.cpp)
                // ============================================================
 
                template <typename OutputType> OutputType to(Error *err = nullptr) const {
                        const char *s = cstr();
                        char *end = nullptr;
                        OutputType ret{};
                        if constexpr (std::is_integral_v<OutputType> && std::is_signed_v<OutputType>) {
                                long long v = std::strtoll(s, &end, 10);
                                ret = static_cast<OutputType>(v);
                        } else if constexpr (std::is_integral_v<OutputType> && std::is_unsigned_v<OutputType>) {
                                unsigned long long v = std::strtoull(s, &end, 10);
                                ret = static_cast<OutputType>(v);
                        } else if constexpr (std::is_floating_point_v<OutputType>) {
                                double v = std::strtod(s, &end);
                                ret = static_cast<OutputType>(v);
                        } else {
                                if(err != nullptr) *err = Error::Invalid;
                                return ret;
                        }
                        if(end == s || *end != '\0') {
                                if(err != nullptr) *err = Error::Invalid;
                                return OutputType{};
                        }
                        if(err != nullptr) *err = Error::Ok;
                        return ret;
                }
 
                bool toBool(Error *err = nullptr) const;
 
                int toInt(Error *err = nullptr) const;
 
                unsigned int toUInt(Error *err = nullptr) const;
 
                double toDouble(Error *err = nullptr) const;
 
                int64_t parseNumberWords(Error *err = nullptr) const;
 
                StringList split(const std::string& delimiter) const;
 
        private:
                SharedPtr<StringData> d;
 
                explicit String(StringData *data)
                        : d(SharedPtr<StringData>::takeOwnership(data)) {}
};
 
inline String operator+(const char *lhs, const String &rhs) {
        return String(lhs) + rhs;
}
 
PROMEKI_NAMESPACE_END
 
template<>
struct std::hash<promeki::String> {
        size_t operator()(const promeki::String &s) const noexcept {
                return static_cast<size_t>(s.hash());
        }
};
 
PROMEKI_NAMESPACE_BEGIN
 
template<size_t N>
class CompiledString {
        public:
                consteval CompiledString(const char (&str)[N])
                        : _bytes{}, _codepoints{}, _charCount(0), _isAscii(true) {
                        for(size_t i = 0; i < N; ++i) _bytes[i] = str[i];
                        size_t pos = 0;
                        while(pos < N - 1) {
                                unsigned char b = static_cast<unsigned char>(str[pos]);
                                if(b > 0x7F) _isAscii = false;
                                char32_t cp;
                                size_t seqLen;
                                if(b < 0x80)      { cp = b; seqLen = 1; }
                                else if(b < 0xE0) { cp = b & 0x1F; seqLen = 2; }
                                else if(b < 0xF0) { cp = b & 0x0F; seqLen = 3; }
                                else              { cp = b & 0x07; seqLen = 4; }
                                for(size_t j = 1; j < seqLen && pos + j < N - 1; ++j)
                                        cp = (cp << 6) | (static_cast<unsigned char>(str[pos + j]) & 0x3F);
                                _codepoints[_charCount++] = cp;
                                pos += seqLen;
                        }
                }
 
                constexpr bool isAscii() const { return _isAscii; }
                constexpr size_t charCount() const { return _charCount; }
                constexpr size_t byteCount() const { return N - 1; }
                constexpr const char *bytes() const { return _bytes; }
                constexpr const char32_t *codepoints() const { return _codepoints; }
 
                constexpr uint64_t hash() const {
                        if(_isAscii) return fnv1aData(_bytes, N - 1);
                        return fnv1aData(_codepoints, _charCount * sizeof(char32_t));
                }
 
        private:
                char     _bytes[N];
                char32_t _codepoints[N];  // worst case: N-1 codepoints
                size_t   _charCount;
                bool     _isAscii;
};
 
template<size_t Count>
class CompiledCodepoints {
        public:
                template<size_t N>
                consteval CompiledCodepoints(const CompiledString<N> &cs) : _data{} {
                        for(size_t i = 0; i < Count; ++i) _data[i] = cs.codepoints()[i];
                }
                constexpr const char32_t *data() const { return _data; }
                constexpr size_t size() const { return Count; }
        private:
                char32_t _data[Count];
};
 
namespace literals {
        inline String operator""_ps(const char *str, size_t len) {
                for(size_t i = 0; i < len; ++i) {
                        if(static_cast<unsigned char>(str[i]) > 0x7F)
                                return String::fromUtf8(str, len);
                }
                return String(str, len);
        }
} // namespace literals
 
PROMEKI_NAMESPACE_END
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
 
#define PROMEKI_STRING(str)                                                     \
    ([]() -> ::promeki::String {                                                \
        constexpr auto _cs =                                                    \
            ::promeki::CompiledString<sizeof(str)>(str);                        \
        if constexpr (_cs.isAscii()) {                                          \
            static ::promeki::StringLiteralData _lit(                           \
                str, _cs.byteCount(), _cs.hash());                              \
            return ::promeki::String::fromLiteralData(&_lit);                   \
        } else {                                                                \
            static constexpr auto _cp =                                         \
                ::promeki::CompiledCodepoints<_cs.charCount()>(_cs);            \
            static ::promeki::StringUnicodeLiteralData _lit(                    \
                _cp.data(), _cp.size(),                                          \
                str, _cs.byteCount(), _cs.hash());                              \
            return ::promeki::String::fromLiteralData(&_lit);                   \
        }                                                                       \
    }())