stringdata.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <string>
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/once.h>
#include <promeki/sharedptr.h>
#include <promeki/char.h>
#include <promeki/list.h>
#include <promeki/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 void reserve(size_t capacity) { (void)capacity; }
 
 
 
                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(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;
                void reserve(size_t capacity) override { _s.reserve(capacity); }
 
                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 {
                        // Hash each Latin1 byte as a 4-byte little-endian
                        // codepoint so the result matches StringUnicodeData
                        // for the same logical characters.
                        return fnv1aLatin1AsCodepoints(_s.data(), _s.size());
                }
 
                std::string &rawStr() { return _s; }
 
        private:
                std::string _s;
};
 
class StringUnicodeData : public StringData {
                PROMEKI_SHARED_DERIVED(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;
                void reserve(size_t capacity) override { _chars.reserve(capacity); }
 
                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) {
                        // Hash each Latin1 byte as a 4-byte little-endian
                        // codepoint so the result matches StringUnicodeData
                        // for the same logical characters.
                        if (_hash == 0 && _len > 0) _hash = fnv1aLatin1AsCodepoints(_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 OnceFlag       _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) {
                        // Endian-independent codepoint mixing so the result
                        // matches StringLatin1Data and StringUnicodeData for
                        // the same logical characters.
                        if (_hash == 0 && _charCount > 0) _hash = fnv1aCodepoints(_codepoints, _charCount);
                        _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 OnceFlag       _strOnce;
                mutable std::string    _strCache;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE