stringdata.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <cstdint>
#include <mutex>
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/char.h>
#include <promeki/core/list.h>
#include <promeki/core/fnv1a.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class StringData {
        public:
                RefCount _promeki_refct;
 
                virtual StringData *_promeki_clone() const = 0;
 
                virtual ~StringData();
 
 
                virtual size_t  length() const = 0;
 
                virtual Char    charAt(size_t idx) const = 0;
 
                virtual void    setCharAt(size_t idx, Char ch) = 0;
 
                virtual bool    isLatin1() const = 0;
 
                virtual bool    isLiteral() const { return false; }
 
 
 
                virtual size_t  find(Char ch, size_t from = 0) const = 0;
 
                virtual size_t  find(const StringData &s, size_t from = 0) const = 0;
 
                virtual size_t  rfind(Char ch, size_t from = npos) const = 0;
 
                virtual size_t  rfind(const StringData &s, size_t from = npos) const = 0;
 
                virtual StringData *createSubstr(size_t pos, size_t len) const = 0;
 
                virtual void    reverseInPlace() = 0;
 
                virtual size_t  count(const StringData &substr) const = 0;
 
 
 
                virtual void    append(const StringData &other) = 0;
 
                virtual void    append(Char ch) = 0;
 
                virtual void    insert(size_t pos, const StringData &s) = 0;
 
                virtual void    erase(size_t pos, size_t count) = 0;
 
                virtual void    clear() = 0;
 
                virtual void    resize(size_t len, Char fill = Char()) = 0;
 
 
 
                virtual size_t          byteCount() const = 0;
 
                virtual uint8_t         byteAt(size_t idx) const = 0;
 
                virtual const char     *cstr() const = 0;
 
                virtual const std::string &str() const = 0;
 
 
                bool isEmpty() const { return length() == 0; }
 
                virtual uint64_t hash() const = 0;
 
                static constexpr size_t npos = static_cast<size_t>(-1);
};
 
class StringLatin1Data : public StringData {
        PROMEKI_SHARED_DERIVED(StringData, StringLatin1Data)
        public:
                StringLatin1Data() = default;
 
                StringLatin1Data(const std::string &s) : _s(s) {}
 
                StringLatin1Data(std::string &&s) : _s(std::move(s)) {}
 
                StringLatin1Data(const char *s) : _s(s ? s : "") {}
 
                StringLatin1Data(const char *s, size_t len) : _s(s, len) {}
 
                StringLatin1Data(size_t ct, char c) : _s(ct, c) {}
 
                size_t  length() const override { return _s.size(); }
                Char    charAt(size_t idx) const override;
                void    setCharAt(size_t idx, Char ch) override;
                bool    isLatin1() const override { return true; }
 
                size_t  find(Char ch, size_t from = 0) const override;
                size_t  find(const StringData &s, size_t from = 0) const override;
                size_t  rfind(Char ch, size_t from = npos) const override;
                size_t  rfind(const StringData &s, size_t from = npos) const override;
                StringData *createSubstr(size_t pos, size_t len) const override;
                void    reverseInPlace() override;
                size_t  count(const StringData &substr) const override;
 
                void    append(const StringData &other) override;
                void    append(Char ch) override;
                void    insert(size_t pos, const StringData &s) override;
                void    erase(size_t pos, size_t count) override;
                void    clear() override { _s.clear(); }
                void    resize(size_t len, Char fill = Char()) override;
 
                size_t          byteCount() const override { return _s.size(); }
                uint8_t         byteAt(size_t idx) const override { return static_cast<uint8_t>(_s[idx]); }
                const char     *cstr() const override { return _s.c_str(); }
                const std::string &str() const override { return _s; }
 
                uint64_t hash() const override {
                        return fnv1aData(_s.data(), _s.size());
                }
 
                std::string &rawStr() { return _s; }
 
        private:
                std::string _s;
};
 
class StringUnicodeData : public StringData {
        PROMEKI_SHARED_DERIVED(StringData, StringUnicodeData)
        public:
                StringUnicodeData() : _strDirty(true) {}
 
                StringUnicodeData(const List<Char> &chars) : _chars(chars), _strDirty(true) {}
 
                StringUnicodeData(List<Char> &&chars) : _chars(std::move(chars)), _strDirty(true) {}
 
                static StringUnicodeData *fromUtf8(const char *data, size_t len);
 
                static StringUnicodeData *fromLatin1(const std::string &s);
 
                size_t  length() const override { return _chars.size(); }
                Char    charAt(size_t idx) const override { return _chars[idx]; }
                void    setCharAt(size_t idx, Char ch) override;
                bool    isLatin1() const override { return false; }
 
                size_t  find(Char ch, size_t from = 0) const override;
                size_t  find(const StringData &s, size_t from = 0) const override;
                size_t  rfind(Char ch, size_t from = npos) const override;
                size_t  rfind(const StringData &s, size_t from = npos) const override;
                StringData *createSubstr(size_t pos, size_t len) const override;
                void    reverseInPlace() override;
                size_t  count(const StringData &substr) const override;
 
                void    append(const StringData &other) override;
                void    append(Char ch) override;
                void    insert(size_t pos, const StringData &s) override;
                void    erase(size_t pos, size_t count) override;
                void    clear() override;
                void    resize(size_t len, Char fill = Char()) override;
 
                size_t          byteCount() const override;
                uint8_t         byteAt(size_t idx) const override;
                const char     *cstr() const override;
                const std::string &str() const override;
 
                uint64_t hash() const override;
 
        private:
                void ensureEncoded() const;
 
                List<Char>              _chars;
                mutable std::string     _strCache;
                mutable bool            _strDirty;
};
 
class StringLiteralData : public StringData {
        public:
                StringLiteralData(const char *s, size_t len, uint64_t precomputedHash = 0)
                        : _s(s), _len(len), _hash(precomputedHash) {
                        if(_hash == 0 && _len > 0) _hash = fnv1aData(_s, _len);
                        _promeki_refct.setImmortal();
                }
 
                StringData *_promeki_clone() const override {
                        return new StringLatin1Data(_s, _len);
                }
 
                // Character access
                size_t  length() const override { return _len; }
                Char    charAt(size_t idx) const override {
                        return Char(static_cast<char>(_s[idx]));
                }
                void    setCharAt(size_t, Char) override { assert(false); }
                bool    isLatin1() const override { return true; }
                bool    isLiteral() const override { return true; }
 
                // Search
                size_t  find(Char ch, size_t from = 0) const override;
                size_t  find(const StringData &s, size_t from = 0) const override;
                size_t  rfind(Char ch, size_t from = npos) const override;
                size_t  rfind(const StringData &s, size_t from = npos) const override;
                StringData *createSubstr(size_t pos, size_t len) const override;
                void    reverseInPlace() override { assert(false); }
                size_t  count(const StringData &substr) const override;
 
                // Mutation (unreachable — COW always clones first)
                void    append(const StringData &) override { assert(false); }
                void    append(Char) override { assert(false); }
                void    insert(size_t, const StringData &) override { assert(false); }
                void    erase(size_t, size_t) override { assert(false); }
                void    clear() override { assert(false); }
                void    resize(size_t, Char) override { assert(false); }
 
                // Byte-level
                size_t          byteCount() const override { return _len; }
                uint8_t         byteAt(size_t idx) const override {
                        return static_cast<uint8_t>(_s[idx]);
                }
                const char     *cstr() const override { return _s; }
                const std::string &str() const override;
 
                uint64_t hash() const override { return _hash; }
 
        private:
                const char             *_s;
                size_t                  _len;
                uint64_t                _hash;
                mutable std::once_flag  _strOnce;
                mutable std::string     _strCache;
};
 
class StringUnicodeLiteralData : public StringData {
        public:
                StringUnicodeLiteralData(const char32_t *codepoints, size_t charCount,
                                         const char *bytes, size_t byteLen,
                                         uint64_t precomputedHash = 0)
                        : _codepoints(codepoints), _charCount(charCount),
                          _bytes(bytes), _byteLen(byteLen),
                          _hash(precomputedHash) {
                        if(_hash == 0 && _charCount > 0)
                                _hash = fnv1aData(_codepoints, _charCount * sizeof(char32_t));
                        _promeki_refct.setImmortal();
                }
 
                StringData *_promeki_clone() const override;
 
                // Character access
                size_t  length() const override { return _charCount; }
                Char    charAt(size_t idx) const override {
                        return Char(_codepoints[idx]);
                }
                void    setCharAt(size_t, Char) override { assert(false); }
                bool    isLatin1() const override { return false; }
                bool    isLiteral() const override { return true; }
 
                // Search
                size_t  find(Char ch, size_t from = 0) const override;
                size_t  find(const StringData &s, size_t from = 0) const override;
                size_t  rfind(Char ch, size_t from = npos) const override;
                size_t  rfind(const StringData &s, size_t from = npos) const override;
                StringData *createSubstr(size_t pos, size_t len) const override;
                void    reverseInPlace() override { assert(false); }
                size_t  count(const StringData &substr) const override;
 
                // Mutation (unreachable — COW always clones first)
                void    append(const StringData &) override { assert(false); }
                void    append(Char) override { assert(false); }
                void    insert(size_t, const StringData &) override { assert(false); }
                void    erase(size_t, size_t) override { assert(false); }
                void    clear() override { assert(false); }
                void    resize(size_t, Char) override { assert(false); }
 
                // Byte-level — uses the original UTF-8 bytes directly
                size_t          byteCount() const override { return _byteLen; }
                uint8_t         byteAt(size_t idx) const override {
                        return static_cast<uint8_t>(_bytes[idx]);
                }
                const char     *cstr() const override { return _bytes; }
                const std::string &str() const override;
 
                uint64_t hash() const override { return _hash; }
 
        private:
                const char32_t         *_codepoints;
                size_t                  _charCount;
                const char             *_bytes;
                size_t                  _byteLen;
                uint64_t                _hash;
                mutable std::once_flag  _strOnce;
                mutable std::string     _strCache;
};
 
PROMEKI_NAMESPACE_END