SString.h

Go to the documentation of this file.

// Copyright 2024 libsese
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
 
#pragma once
 
#include <sese/Config.h>
 
#include <vector>
 
namespace sstr {
 
struct SChar final {
    uint32_t code = 0;
 
    explicit SChar(uint32_t code) noexcept;
 
    bool operator==(const SChar &ch) const;
    bool operator<(const SChar &ch) const;
 
    bool operator<=(const SChar &ch) const;
    bool operator>(const SChar &ch) const;
    bool operator>=(const SChar &ch) const;
    bool operator!=(const SChar &ch) const;
 
    SChar operator+(const SChar &ch) const;
    SChar operator-(const SChar &ch) const;
 
    explicit operator uint32_t() const;
};
 
 SChar getUnicodeFromUTF8Char(const char *u8char);
 
 size_t getStringLengthFromUTF8String(const char *str);
 
 size_t getByteLengthFromUTF8String(const char *str);
 
 char getSizeFromUTF8Char(char ch);
 
 char getUTF8SizeFromUnicodeChar(SChar ch);
 
 SChar getUnicodeCharFromUTF8Char(char size, const char *ch);
 
class SString;
 
class  SStringView {
public:
    SStringView() noexcept = default;
    explicit SStringView(const char *u8str) noexcept;
    virtual ~SStringView() = default;
 
public:
    class Iterator {
    public:
        using difference_type = SChar;
        using value_type = SChar;
        using pointer = const SChar *;
        using reference = const SChar &;
        using iterator_category = std::forward_iterator_tag;
 
        Iterator(const char *ref, size_t size, size_t pos = 0);
 
        Iterator operator++();
        // Iterator operator++(int c);
 
        bool operator==(const Iterator &other) const;
        bool operator!=(const Iterator &other) const;
        SChar operator*();
 
    private:
        Iterator() = default;
 
        const char *_ref = nullptr;
        size_t _pos = 0;
        size_t _size = 0;
        SChar _ch = SChar(0);
    };
 
public:
    Iterator begin();
    Iterator end();
 
    [[nodiscard]] bool null() const;
 
    [[nodiscard]] bool empty() const;
 
    [[nodiscard]] size_t len() const;
 
    [[nodiscard]] virtual size_t size() const;
 
    [[nodiscard]] const char *data() const;
 
    [[nodiscard]] int32_t find(const SStringView &str) const;
 
    int32_t find(const char *u8str) const;
 
    int32_t findByBytes(const char *bytes) const;
 
    [[nodiscard]] SString trim() const;
 
    [[nodiscard]] SString reverse() const;
 
    [[nodiscard]] SString append(const SStringView &str) const;
 
    SString append(const char *u8str) const;
 
    [[nodiscard]] std::vector<SString> split(const SStringView &str) const;
 
    std::vector<SString> split(const char *str) const;
 
    [[nodiscard]] SString substring(size_t begin) const;
    [[nodiscard]] SString substring(size_t begin, size_t len) const;
 
    [[nodiscard]] bool endsWith(const SStringView &suffix) const;
 
    [[nodiscard]] bool endsWith(const std::string_view &suffix) const;
 
    [[nodiscard]] bool startsWith(const SStringView &prefix) const;
 
    [[nodiscard]] bool startsWith(const std::string_view &prefix) const;
 
    [[nodiscard]] bool isLower() const;
    [[nodiscard]] bool isUpper() const;
 
    [[nodiscard]] SString toLower() const;
    [[nodiscard]] SString toUpper() const;
 
    [[nodiscard]] SChar at(size_t index) const;
    [[nodiscard]] std::vector<SChar> toChars() const;
    [[nodiscard]] std::string toString() const;
    [[nodiscard]] std::wstring toWString() const;
    [[nodiscard]] std::unique_ptr<wchar_t[]> toCWString() const;
 
public:
    SChar operator[](size_t index) const;
    bool operator!=(const SStringView &str) const;
    bool operator!=(const char *u8str) const;
    bool operator==(const SStringView &str) const;
    bool operator==(const char *u8str) const;
    SString operator+(const SStringView &str) const;
    SString operator+(const char *u8str) const;
 
protected:
    char *_data = nullptr;
    size_t _size = 0;
};
 
class SString final : public SStringView {
public:
    friend class SStringView;
 
    explicit SString() noexcept;
    SString(const char *str, size_t size);
    SString(const SString &s_string) noexcept;
    SString(SString &&s_string) noexcept;
    ~SString() noexcept override;
 
    static SString fromSChars(SChar ch[], size_t size);
    static SString fromSChars(std::vector<SChar> &chars);
    static SString fromUTF8(const char *str);
    static SString fromUCS2LE(const wchar_t *str);
 
public:
    [[nodiscard]] size_t cap() const;
    [[nodiscard]] size_t size() const override;
 
    void toLower();
    void toUpper();
 
    char *data();
 
public:
    void operator+=(const SStringView &str);
    void operator+=(const char *u8str);
 
protected:
    size_t _capacity = 0;
};
} // namespace sstr