string.h

Go to the documentation of this file.

 
#include <algorithm>
#include <array>
#include <cstring>
#include <iostream>
#include <limits>
#include <qb/utility/build_macros.h>
#include <string>
#include <stdexcept>
 
#ifndef QB_STRING_H_
#define QB_STRING_H_
 
namespace qb {
 
namespace internal {
template <std::size_t _Size, bool fill8 = (_Size <= std::numeric_limits<uint8_t>::max()),
          bool fill16 = (_Size <= std::numeric_limits<uint16_t>::max())>
struct best_size {
    using type = std::size_t;
};

template <std::size_t _Size>
struct best_size<_Size, true, true> {
    using type = uint8_t;
};

template <std::size_t _Size>
struct best_size<_Size, false, true> {
    using type = uint16_t;
};
} // namespace internal

template <std::size_t _Size = 30>
class string : public std::array<char, _Size + 1> {
    static_assert(_Size > 0, "String size must be greater than 0");
    
    using base_t    = std::array<char, _Size + 1>;
    using size_type = typename internal::best_size<_Size + 1>::type;
    
public:
    // Type aliases for compatibility with std::string
    using value_type             = char;
    using reference              = char&;
    using const_reference        = const char&;
    using pointer                = char*;
    using const_pointer          = const char*;
    using iterator               = typename base_t::iterator;
    using const_iterator         = typename base_t::const_iterator;
    using reverse_iterator       = typename base_t::reverse_iterator;
    using const_reverse_iterator = typename base_t::const_reverse_iterator;
    using difference_type        = typename base_t::difference_type;
    
    static constexpr std::size_t npos = std::numeric_limits<std::size_t>::max();
 
private:
    size_type _size = 0;
 
public:
    constexpr string() noexcept
        : base_t{'\0'} {}

    template <std::size_t N>
    constexpr string(const char (&str)[N]) noexcept {
        assign(str, N - 1);
    }

    template <typename T>
    string(T const &rhs) noexcept {
        assign(rhs);
    }

    string(const char* str, std::size_t size) noexcept {
        assign(str, size);
    }

    string(const char* str) noexcept {
        assign(str);
    }

    string(std::size_t count, char ch) noexcept {
        _size = static_cast<size_type>(std::min(count, static_cast<std::size_t>(_Size)));
        std::fill_n(base_t::data(), _size, ch);
        base_t::data()[_size] = '\0';
    }

    string(const string& other) noexcept = default;

    string(string&& other) noexcept = default;

    string& operator=(const string& other) noexcept = default;

    string& operator=(string&& other) noexcept = default;

    string &
    assign(char const *rhs, std::size_t size) noexcept {
        _size = static_cast<size_type>(std::min(size, static_cast<std::size_t>(_Size)));
 
        std::memcpy(base_t::data(), rhs, _size);
        base_t::data()[_size] = '\0';
 
        return *this;
    }

    template <std::size_t N>
    constexpr string &
    assign(const char (&str)[N]) noexcept {
        return assign(str, N - 1);
    }

    template <typename T>
    string &
    assign(T const &rhs) noexcept {
        return assign(rhs.data(), rhs.size());
    }

    string &
    assign(char const *rhs) noexcept {
        return assign(rhs, std::strlen(rhs));
    }

    string &
    assign(std::size_t count, char ch) noexcept {
        _size = static_cast<size_type>(std::min(count, static_cast<std::size_t>(_Size)));
        std::fill_n(base_t::data(), _size, ch);
        base_t::data()[_size] = '\0';
        return *this;
    }

    template <std::size_t N>
    constexpr string &
    operator=(const char (&str)[N]) noexcept {
        return assign(str, N - 1);
    }

    template <typename T>
    string &
    operator=(T const &rhs) noexcept {
        return assign(rhs);
    }

    string &
    operator=(char const *rhs) noexcept {
        return assign(rhs);
    }

    string &
    operator=(char ch) noexcept {
        return assign(1, ch);
    }

    operator std::string() const noexcept {
        return {base_t::data(), _size};
    }

    operator std::string_view() const noexcept {
        return {base_t::data(), _size};
    }
 
    // Element access
    reference at(std::size_t pos) {
        if (pos >= _size) {
            throw std::out_of_range("qb::string::at: index out of range");
        }
        return base_t::data()[pos];
    }

    const_reference at(std::size_t pos) const {
        if (pos >= _size) {
            throw std::out_of_range("qb::string::at: index out of range");
        }
        return base_t::data()[pos];
    }

    reference operator[](std::size_t pos) noexcept {
        return base_t::data()[pos];
    }

    const_reference operator[](std::size_t pos) const noexcept {
        return base_t::data()[pos];
    }

    reference front() noexcept {
        return base_t::data()[0];
    }

    const_reference front() const noexcept {
        return base_t::data()[0];
    }

    reference back() noexcept {
        return base_t::data()[_size - 1];
    }

    const_reference back() const noexcept {
        return base_t::data()[_size - 1];
    }

    pointer data() noexcept {
        return base_t::data();
    }

    const_pointer data() const noexcept {
        return base_t::data();
    }

    [[nodiscard]] const_pointer c_str() const noexcept {
        return base_t::data();
    }
 
    // Iterators
    iterator end() noexcept {
        return base_t::begin() + _size;
    }

    const_iterator end() const noexcept {
        return base_t::begin() + _size;
    }

    const_iterator cend() const noexcept {
        return base_t::cbegin() + _size;
    }

    reverse_iterator rbegin() noexcept {
        return std::reverse_iterator(end());
    }

    const_reverse_iterator rbegin() const noexcept {
        return std::reverse_iterator(end());
    }

    const_reverse_iterator crbegin() const noexcept {
        return std::reverse_iterator(cend());
    }
 
    // Capacity
    [[nodiscard]] constexpr bool empty() const noexcept {
        return _size == 0;
    }

    [[nodiscard]] constexpr std::size_t size() const noexcept {
        return _size;
    }

    [[nodiscard]] constexpr std::size_t length() const noexcept {
        return _size;
    }

    [[nodiscard]] constexpr std::size_t max_size() const noexcept {
        return _Size;
    }

    [[nodiscard]] constexpr std::size_t capacity() const noexcept {
        return _Size;
    }
 
    // Operations
    void clear() noexcept {
        *base_t::begin() = '\0';
        _size = 0;
    }

    void resize(std::size_t count, char ch = '\0') noexcept {
        count = std::min(count, static_cast<std::size_t>(_Size));
        
        if (count > _size) {
            std::fill(base_t::data() + _size, base_t::data() + count, ch);
        }
        
        _size = static_cast<size_type>(count);
        base_t::data()[_size] = '\0';
    }

    void swap(string& other) noexcept {
        base_t temp_data = *this;
        size_type temp_size = _size;
        
        *this = other;
        _size = other._size;
        
        other = temp_data;
        other._size = temp_size;
    }
 
    // String operations
    string substr(std::size_t pos = 0, std::size_t len = npos) const {
        if (pos > _size) {
            throw std::out_of_range("qb::string::substr: position out of range");
        }
        
        std::size_t actual_len = std::min(len, _size - pos);
        string result;
        result.assign(base_t::data() + pos, actual_len);
        return result;
    }

    int compare(const string& str) const noexcept {
        return std::strcmp(base_t::data(), str.c_str());
    }

    int compare(const char* str) const noexcept {
        return std::strcmp(base_t::data(), str);
    }

    int compare(std::size_t pos, std::size_t len, const string& str) const {
        return substr(pos, len).compare(str);
    }
 
    // Search operations
    std::size_t find(const string& str, std::size_t pos = 0) const noexcept {
        return find(str.c_str(), pos);
    }

    std::size_t find(const char* str, std::size_t pos = 0) const noexcept {
        if (pos >= _size) return npos;
        
        const char* result = std::strstr(base_t::data() + pos, str);
        return result ? static_cast<std::size_t>(result - base_t::data()) : npos;
    }

    std::size_t find(char ch, std::size_t pos = 0) const noexcept {
        if (pos >= _size) return npos;
        
        const char* result = std::strchr(base_t::data() + pos, ch);
        return (result && result < base_t::data() + _size) ? 
               static_cast<std::size_t>(result - base_t::data()) : npos;
    }

    std::size_t rfind(const char* str, std::size_t pos = npos) const noexcept {
        std::size_t str_len = std::strlen(str);
        if (str_len > _size) return npos;
        
        std::size_t start = std::min(pos, _size - str_len);
        
        for (std::size_t i = start + 1; i > 0; --i) {
            if (std::strncmp(base_t::data() + i - 1, str, str_len) == 0) {
                return i - 1;
            }
        }
        return npos;
    }

    std::size_t rfind(char ch, std::size_t pos = npos) const noexcept {
        if (_size == 0) return npos;
        
        std::size_t start = std::min(pos, static_cast<std::size_t>(_size - 1));
        
        for (std::size_t i = start + 1; i > 0; --i) {
            if (base_t::data()[i - 1] == ch) {
                return i - 1;
            }
        }
        return npos;
    }
 
    // Modifiers
    string& append(const string& str) noexcept {
        return append(str.c_str(), str.size());
    }

    string& append(const char* str) noexcept {
        return append(str, std::strlen(str));
    }

    string& append(const char* str, std::size_t len) noexcept {
        std::size_t new_size = std::min(_size + len, static_cast<std::size_t>(_Size));
        std::size_t actual_len = new_size - _size;
        
        std::memcpy(base_t::data() + _size, str, actual_len);
        _size = static_cast<size_type>(new_size);
        base_t::data()[_size] = '\0';
        
        return *this;
    }

    string& append(char ch) noexcept {
        return append(1, ch);
    }

    string& append(std::size_t count, char ch) noexcept {
        std::size_t new_size = std::min(_size + count, static_cast<std::size_t>(_Size));
        std::size_t actual_count = new_size - _size;
        
        std::fill_n(base_t::data() + _size, actual_count, ch);
        _size = static_cast<size_type>(new_size);
        base_t::data()[_size] = '\0';
        
        return *this;
    }

    void push_back(char ch) noexcept {
        if (_size < _Size) {
            base_t::data()[_size] = ch;
            ++_size;
            base_t::data()[_size] = '\0';
        }
    }

    void pop_back() noexcept {
        if (_size > 0) {
            --_size;
            base_t::data()[_size] = '\0';
        }
    }

    string& operator+=(const string& str) noexcept {
        return append(str);
    }

    string& operator+=(const char* str) noexcept {
        return append(str);
    }

    string& operator+=(char ch) noexcept {
        push_back(ch);
        return *this;
    }
 
    // C++20 features
    bool starts_with(const char* prefix) const noexcept {
        std::size_t prefix_len = std::strlen(prefix);
        return _size >= prefix_len && std::strncmp(base_t::data(), prefix, prefix_len) == 0;
    }

    bool starts_with(const string& prefix) const noexcept {
        return starts_with(prefix.c_str());
    }

    bool starts_with(char ch) const noexcept {
        return _size > 0 && base_t::data()[0] == ch;
    }

    bool ends_with(const char* suffix) const noexcept {
        std::size_t suffix_len = std::strlen(suffix);
        return _size >= suffix_len && 
               std::strncmp(base_t::data() + _size - suffix_len, suffix, suffix_len) == 0;
    }

    bool ends_with(const string& suffix) const noexcept {
        return ends_with(suffix.c_str());
    }

    bool ends_with(char ch) const noexcept {
        return _size > 0 && base_t::data()[_size - 1] == ch;
    }

    bool contains(const char* str) const noexcept {
        return find(str) != npos;
    }

    bool contains(const string& str) const noexcept {
        return find(str) != npos;
    }

    bool contains(char ch) const noexcept {
        return find(ch) != npos;
    }
 
    // Comparison operators
    template <typename T>
    bool operator==(T const &rhs) const noexcept {
        return rhs == base_t::data();
    }

    bool operator==(char const *rhs) const noexcept {
        return std::strcmp(base_t::data(), rhs) == 0;
    }

    bool operator==(const string& rhs) const noexcept {
        return _size == rhs._size && std::strcmp(base_t::data(), rhs.c_str()) == 0;
    }

    bool operator!=(const string& rhs) const noexcept {
        return !(*this == rhs);
    }

    bool operator!=(const char* rhs) const noexcept {
        return !(*this == rhs);
    }

    bool operator<(const string& rhs) const noexcept {
        return compare(rhs) < 0;
    }

    bool operator<(const char* rhs) const noexcept {
        return compare(rhs) < 0;
    }

    bool operator>(const string& rhs) const noexcept {
        return compare(rhs) > 0;
    }

    bool operator>(const char* rhs) const noexcept {
        return compare(rhs) > 0;
    }

    bool operator<=(const string& rhs) const noexcept {
        return compare(rhs) <= 0;
    }

    bool operator<=(const char* rhs) const noexcept {
        return compare(rhs) <= 0;
    }

    bool operator>=(const string& rhs) const noexcept {
        return compare(rhs) >= 0;
    }

    bool operator>=(const char* rhs) const noexcept {
        return compare(rhs) >= 0;
    }
};
 
// Non-member functions

template <std::size_t _Size1, std::size_t _Size2>
string<std::max(_Size1, _Size2)> operator+(const string<_Size1>& lhs, const string<_Size2>& rhs) noexcept {
    string<std::max(_Size1, _Size2)> result(lhs);
    result.append(rhs);
    return result;
}

template <std::size_t _Size>
string<_Size> operator+(const string<_Size>& lhs, const char* rhs) noexcept {
    string<_Size> result(lhs);
    result.append(rhs);
    return result;
}

template <std::size_t _Size>
string<_Size> operator+(const char* lhs, const string<_Size>& rhs) noexcept {
    string<_Size> result(lhs);
    result.append(rhs);
    return result;
}

template <std::size_t _Size>
string<_Size> operator+(const string<_Size>& lhs, char rhs) noexcept {
    string<_Size> result(lhs);
    result.push_back(rhs);
    return result;
}

template <std::size_t _Size>
string<_Size> operator+(char lhs, const string<_Size>& rhs) noexcept {
    string<_Size> result(1, lhs);
    result.append(rhs);
    return result;
}

template <std::size_t _Size>
void swap(string<_Size>& lhs, string<_Size>& rhs) noexcept {
    lhs.swap(rhs);
}

template <std::size_t _Size>
std::ostream &
operator<<(std::ostream &os, qb::string<_Size> const &str) noexcept {
    os << str.c_str();
    return os;
}

template <std::size_t _Size>
std::istream &
operator>>(std::istream &is, qb::string<_Size> &str) noexcept {
    std::string temp;
    is >> temp;
    str = temp;
    return is;
}
 
// Equality operators for reverse comparisons
template <std::size_t _Size>
bool operator==(const char* lhs, const string<_Size>& rhs) noexcept {
    return rhs == lhs;
}
 
template <std::size_t _Size>
bool operator!=(const char* lhs, const string<_Size>& rhs) noexcept {
    return rhs != lhs;
}
 
} // namespace qb
 
#endif // QB_STRING_H_