hybstr.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <string>
#include <cassert>
#include <cstddef>
#include <utility>
#include <optional>
#include <algorithm>
#include <stdexcept>
#include <string_view>
#include <type_traits>
 
#ifndef HYBSTR_DYNAMIC_EXPAND_CAPACITY
#define HYBSTR_DYNAMIC_EXPAND_CAPACITY 1000
#endif
 
#if defined(_MSC_VER)
#  define HYBSTR_CPP_STD _MSVC_LANG
#else
#  define HYBSTR_CPP_STD __cplusplus
#endif
 
#if HYBSTR_CPP_STD >= 202002L
    #define HYBSTR_CPP_20_OR_ABOVE true
#else
    #define HYBSTR_CPP_20_OR_ABOVE false
#endif
 
#if !HYBSTR_CPP_20_OR_ABOVE
    #ifndef consteval
        #define consteval constexpr
    #endif
#endif
 
#if HYBSTR_CPP_20_OR_ABOVE
    #include <type_traits>
    #define HYBSTR_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
#elif defined(__clang__) || defined(__GNUC__)
    #define HYBSTR_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
    #elif defined(_MSC_VER) && _MSC_VER >= 1928
    #define HYBSTR_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
#elif defined(__INTEL_LLVM_COMPILER)
    #define HYBSTR_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
#else
    #define HYBSTR_IS_CONSTANT_EVALUATED false
#endif

namespace hybstr
{
    template<std::size_t DynamicExpandCapacity = HYBSTR_DYNAMIC_EXPAND_CAPACITY>
    [[nodiscard]] constexpr auto string();
    template<std::size_t DynamicExpandCapacity = HYBSTR_DYNAMIC_EXPAND_CAPACITY, 
        std::size_t N>
    [[nodiscard]] constexpr auto string(const char(&str)[N]);
    template<std::size_t ViewSize = HYBSTR_DYNAMIC_EXPAND_CAPACITY, 
        std::size_t DynamicExpandCapacity = HYBSTR_DYNAMIC_EXPAND_CAPACITY>
    [[nodiscard]] constexpr auto string(std::string_view sv) noexcept;
    template<std::size_t RangeSize = HYBSTR_DYNAMIC_EXPAND_CAPACITY, 
        std::size_t DynamicExpandCapacity = HYBSTR_DYNAMIC_EXPAND_CAPACITY, 
        typename _Iter>
    [[nodiscard]] constexpr auto string(_Iter start, _Iter end) noexcept;

    template <std::size_t BufferCapacity = 0, std::size_t DynamicExpandCapacity = HYBSTR_DYNAMIC_EXPAND_CAPACITY>
    class string_impl
    {
        template <std::size_t, std::size_t>
        friend class string_impl;
    public:
        using value_type = char;
        using reference = value_type&;
        using const_reference = const value_type&;
        using size_type = std::size_t;
        using view_type = std::string_view;
        using pointer = char*;
        using const_pointer = const char*;
        using iterator = typename std::array<char, BufferCapacity + 1>::iterator;
        using const_iterator = typename std::array<char, BufferCapacity + 1>::const_iterator;
        using reverse_iterator = typename std::array<char, BufferCapacity + 1>::reverse_iterator;
        using const_reverse_iterator = typename std::array<char, BufferCapacity + 1>::const_reverse_iterator;

        constexpr string_impl() noexcept
            : _size(0)
        {
            _data[0] = '\0';
        }

        template <std::size_t N>
        constexpr string_impl(const char(&str)[N]) noexcept
        {
            static_assert(N > 0 && N - 1 <= BufferCapacity, "string literal too long");
            for (std::size_t i = 0; i < N - 1; ++i)
            {
                _data[i] = str[i];
            }
            _data[N - 1] = '\0';
            _size = N - 1;
        }

        constexpr string_impl(const std::size_t& n, char c) noexcept
        {
            const std::size_t len = std::min(n, BufferCapacity);
            for (std::size_t i = 0; i < len; ++i)
            {
                _data[i] = c;
            }
            _data[len] = '\0';
            _size = len;
        }

        constexpr string_impl(std::string_view sv) noexcept
        {
            const std::size_t len = std::min(sv.size(), BufferCapacity);
            for (std::size_t i = 0; i < len; ++i)
            {
                _data[i] = sv[i];
            }
            _data[len] = '\0';
            _size = len;
        }

        template<typename _Iter>
        constexpr string_impl(_Iter start, _Iter end) noexcept
        {
            std::size_t i = 0;
 
            while (i < BufferCapacity && start != end)
            {
                _data[i++] = *(start++);
            }
 
            _data[i] = '\0';
            _size = i;
        }
 
        constexpr string_impl(const string_impl&) noexcept = default;
        constexpr string_impl(string_impl&&) noexcept = default;
        constexpr string_impl& operator=(const string_impl&) noexcept = default;
        constexpr string_impl& operator=(string_impl&&) noexcept = default;

        [[nodiscard]] constexpr auto size() const noexcept -> size_type
        {
            return _size;
        }

        [[nodiscard]] constexpr auto capacity() const noexcept -> size_type
        {
            return BufferCapacity;
        }

        [[nodiscard]] constexpr auto empty() const noexcept -> bool
        {
            return _size == 0;
        }

        [[nodiscard]] constexpr auto data() noexcept -> pointer
        {
            return _data.data();
        }

        [[nodiscard]] constexpr auto data() const noexcept -> const_pointer
        {
            return _data.data();
        }

        [[nodiscard]] constexpr auto c_str() const noexcept -> const_pointer
        {
            return _data.data();
        }

        [[nodiscard]] constexpr auto view() const noexcept -> view_type
        {
            return std::string_view(_data.data(), _size);
        }

        [[nodiscard]] auto str() const -> std::string
        {
            return std::string(begin(), end());
        }
 

        [[nodiscard]] constexpr auto operator[](size_type i) noexcept -> reference
        {
            return _data[i];
        }

        [[nodiscard]] constexpr auto operator[](size_type i) const noexcept -> const_reference
        {
            return _data[i];
        }
 
        [[nodiscard]] constexpr auto begin() noexcept -> iterator
        {
            return _data.begin();
        }
        [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator
        {
            return _data.begin();
        }
        [[nodiscard]] constexpr auto cbegin() const noexcept -> const_iterator
        {
            return _data.cbegin();
        }
        [[nodiscard]] constexpr auto end() noexcept -> iterator
        {
            return _data.begin() + _size;
        }
        [[nodiscard]] constexpr auto end() const noexcept -> const_iterator
        {
            return _data.begin() + _size;
        }
        [[nodiscard]] constexpr auto cend() const noexcept -> const_iterator
        {
            return _data.begin() + _size;
        }
        [[nodiscard]] constexpr auto rbegin() noexcept -> reverse_iterator
        {
            return _data.rbegin() + 1;
        }
        [[nodiscard]] constexpr auto rbegin() const noexcept -> const_reverse_iterator
        {
            return _data.rbegin() + 1;
        }
        [[nodiscard]] constexpr auto crbegin() const noexcept -> const_reverse_iterator
        {
            return _data.crbegin() + 1;
        }
        [[nodiscard]] constexpr auto rend() noexcept -> reverse_iterator
        {
            return _data.rend();
        }
        [[nodiscard]] constexpr auto rend() const noexcept -> const_reverse_iterator
        {
            return _data.rend();
        }
        [[nodiscard]] constexpr auto crend() const noexcept -> const_reverse_iterator
        {
            return _data.crend();
        }

        template <std::size_t N>
        [[nodiscard]] constexpr auto set(char c) const noexcept
        {
            static_assert(N >= 0 && N < BufferCapacity, "index out of bound");
            string_impl<BufferCapacity, DynamicExpandCapacity> result{};
            for (std::size_t i = 0; i < _size; ++i)
            {
                result._data[i] = _data[i];
            }
            result._size = _size;
            result._data[N] = c;
            result._data[result._size] = '\0';
 
            return result;
        }

        template <std::size_t N>
        [[nodiscard]] constexpr auto append(const char(&str)[N]) const noexcept
        {
            string_impl<BufferCapacity + N - 1, DynamicExpandCapacity> result{};
 
            for (std::size_t i = 0; i < _size; ++i)
            {
                result._data[i] = _data[i];
            }
            for (std::size_t i = 0; i < N - 1; ++i)
            {
                result._data[_size + i] = str[i];
            }
 
            result._size = _size + (N - 1);
            result._data[result._size] = '\0';
 
            return result;
        }

        template<std::size_t TargetSize = DynamicExpandCapacity, std::size_t N, std::size_t ExpandCapacity>
        [[nodiscard]] constexpr auto append(const string_impl<N, ExpandCapacity>& other) const noexcept
        {
            string_impl<
                BufferCapacity + TargetSize, 
                std::max(DynamicExpandCapacity, ExpandCapacity)
            > result{};
 
            for (std::size_t i = 0; i < _size; ++i)
            {
                result._data[i] = _data[i];
            }
            for (std::size_t i = 0; i < other.size(); ++i)
            {
                result._data[_size + i] = other._data[i];
            }
 
            result._size = _size + other.size();
            result._data[result._size] = '\0';
            return result;
        }

        template<std::size_t TargetSize = DynamicExpandCapacity>
        [[nodiscard]] constexpr auto append(std::string_view sv) const noexcept
        {
            if (HYBSTR_IS_CONSTANT_EVALUATED)
            {
                string_impl<BufferCapacity + TargetSize, DynamicExpandCapacity> result{};
                for (std::size_t i = 0; i < _size; ++i)
                {
                    result._data[i] = _data[i];
                }
                for (std::size_t i = 0; i < sv.size(); ++i)
                {
                    result._data[_size + i] = sv[i];
                }
                result._size = _size + sv.size();
                result._data[result._size] = '\0';
                return result;
            }
            else
            {
                // "string_impl overflow; increase the dynamic buffer size"
                assert(sv.size() < TargetSize);
 
                string_impl<BufferCapacity + TargetSize, DynamicExpandCapacity> result{};
 
                std::copy_n(_data.data(), _size, result._data.data());
                std::copy_n(sv.data(), sv.size(), result._data.data() + _size);
                result._size = _size + sv.size();
                result._data[result._size] = '\0';
                return result;
            }
        }

        template<std::size_t N = 1>
        [[nodiscard]] constexpr auto append(char c) const noexcept
        {
            string_impl<BufferCapacity + N, DynamicExpandCapacity> result{};
            for (std::size_t i = 0; i < _size; ++i)
            {
                result._data[i] = _data[i];
            }
            for (std::size_t i = 0; i < N; ++i)
            {
                result._data[_size + i] = c;
            }
            result._size = _size + N;
            result._data[result._size] = '\0';
            return result;
        }

        [[nodiscard]] constexpr auto push_back(char c) const noexcept
        {
            return append<1>(c);
        }

        template<std::size_t N>
        [[nodiscard]] constexpr auto resize(char c = ' ') const noexcept
        {
            string_impl<N, DynamicExpandCapacity> result{};
 
            const std::size_t len = std::min(_size, N);
 
            for (std::size_t i = 0; i < len; ++i)
            {
                result._data[i] = _data[i];
            }
            for (std::size_t i = len; i < N; ++i)
            {
                result._data[i] = c;
            }
 
            result._size = N;
            result._data[result._size] = '\0';
 
            return result;
        }

        template<std::size_t N>
        [[nodiscard]] constexpr auto reserve() const noexcept
        {
            if constexpr (BufferCapacity < N)
            {
                string_impl<N, DynamicExpandCapacity> result{};
                result._size = std::min(_size, N);
 
                for (std::size_t i = 0; i < result._size; ++i)
                {
                    result._data[i] = _data[i];
                }
 
                result._data[result._size] = '\0';
                return result;
            }
            else
            {
                return string_impl<N, DynamicExpandCapacity> { *this };
            }
        }
 
        std::array<char, BufferCapacity + 1> _data{}; 
        size_type _size{}; 
    };
 
    template<std::size_t N>
    string_impl(const char(&)[N]) -> string_impl<N>;
 
    // ======================================================================
    //                           Operators
    // ======================================================================

    template<
        std::size_t B1, std::size_t DynamicExpandCapacity1,
        std::size_t B2, std::size_t DynamicExpandCapacity2
    >
    [[nodiscard]] constexpr auto operator+(
        const string_impl<B1, DynamicExpandCapacity1>& s1,
        const string_impl<B2, DynamicExpandCapacity2>& s2
        ) noexcept
    {
        string_impl<
            B1 + B2,
            std::max(DynamicExpandCapacity1, DynamicExpandCapacity2)
        > result{};
 
        for (std::size_t i = 0; i < s1.size(); ++i)
        {
            result._data[i] = s1._data[i];
        }
        for (std::size_t i = 0; i < s2.size(); ++i)
        {
            result._data[s1.size() + i] = s2._data[i];
        }
 
        result._size = s1._size + s2._size;
        result._data[result._size] = '\0';
        return result;
    }

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity,
        std::size_t N
    >
    [[nodiscard]] constexpr auto operator+(
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s,
        const char(&str)[N]
        ) noexcept
    {
        string_impl<BufferCapacity + N, DynamicExpandCapacity> result{};
 
        for (std::size_t i = 0; i < s.size(); ++i)
        {
            result._data[i] = s._data[i];
        }
        for (std::size_t i = 0; i < N - 1; ++i)
        {
            result._data[s.size() + i] = str[i];
        }
 
        result._size = s.size() + N - 1;
        result._data[result._size] = '\0';
 
        return result;
    }
 

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity,
        std::size_t N
    >
    [[nodiscard]] constexpr auto operator+(
        const char(&str)[N],
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s
        ) noexcept
    {
        string_impl<BufferCapacity + N, DynamicExpandCapacity> result{};
 
        for (std::size_t i = 0; i < N - 1; ++i)
        {
            result._data[i] = str[i];
        }
        for (std::size_t i = 0; i < s.size(); ++i)
        {
            result._data[N + i - 1] = s._data[i];
        }
 
        result._size = s.size() + N - 1;
        result._data[result._size] = '\0';
 
        return result;
    }
 

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity
    >
    [[nodiscard]] constexpr auto operator+(
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s,
        char c
        ) noexcept
    {
        string_impl<BufferCapacity + 1, DynamicExpandCapacity> result{};
 
        for (std::size_t i = 0; i < s.size(); ++i)
        {
            result._data[i] = s._data[i];
        }
        result._size = s.size() + 1;
        result._data[result._size - 1] = c;
        result._data[result._size] = '\0';
 
        return result;
    }

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity
    >
    [[nodiscard]] constexpr auto operator+(
        char c,
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s
        ) noexcept
    {
        string_impl<BufferCapacity + 1, DynamicExpandCapacity> result{};
 
        result._data[0] = c;
        for (std::size_t i = 0; i < s.size(); ++i)
        {
            result._data[i + 1] = s._data[i];
        }
        result._size = s.size() + 1;
        result._data[result._size] = '\0';
 
        return result;
    }

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity
    >
    [[nodiscard]] constexpr auto operator+(
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s,
        std::string_view sv
        ) noexcept
    {
        string_impl<BufferCapacity + DynamicExpandCapacity, DynamicExpandCapacity> result{};
 
        for (std::size_t i = 0; i < s.size(); ++i)
        {
            result._data[i] = s._data[i];
        }
        for (std::size_t i = 0; i < sv.size(); ++i)
        {
            result._data[s.size() + i] = sv[i];
        }
 
        result._size = s.size() + sv.size();
        result._data[result._size] = '\0';
 
        return result;
    }

    template<
        std::size_t BufferCapacity,
        std::size_t DynamicExpandCapacity
    >
    [[nodiscard]] constexpr auto operator+(
        std::string_view sv,
        const string_impl<BufferCapacity, DynamicExpandCapacity>& s
        ) noexcept
    {
        return s + sv;
    }
 
 
    // ======================================================================
    //                           Comparisons
    // =====================================================================

    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator==(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        if (s1._size != s2._size)
        {
            return false;
        }
 
        for (std::size_t i = 0; i < s1._size; ++i)
        {
            if (s1._data[i] != s2._data[i])
            {
                return false;
            }
        }
        return true;
    }
 

    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator!=(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        return !(s1 == s2);
    }
 
#if HYBSTR_CPP_20_OR_ABOVE
    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr auto operator<=>(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        const std::size_t min_size = std::min(s1._size, s2._size);
 
        for (std::size_t i = 0; i < min_size; ++i)
        {
            if (auto cmp = s1._data[i] <=> s2._data[i]; cmp != 0)
            {
                return cmp;
            }
        }
        return s1._size <=> s2._size;
    }
 
#else
    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator<(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        const std::size_t min_size = std::min(s1._size, s2._size);
 
        for (std::size_t i = 0; i < min_size; ++i)
        {
            if (s1._data[i] < s2._data[i]) return true;
            else return false;
        }
        return s1._size < s2._size;
    }

    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator<=(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        return !(s2 < s1);
    }

    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator>(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
        ) noexcept
    {
        return s2 < s1;
    }

    template<
        std::size_t B1, std::size_t D1,
        std::size_t B2, std::size_t D2
    >
    [[nodiscard]] constexpr bool operator>=(
        const string_impl<B1, D1>& s1,
        const string_impl<B2, D2>& s2
    ) noexcept
    {
        return !(s1 < s2);
    }
#endif
 
    // ======================================================================
    //                           Traits and Utilities
    // ======================================================================

    template<typename T>
    struct is_string_impl : std::false_type {};
    template <std::size_t BufferCapacity, std::size_t DynamicExpandCapacity>
    struct is_string_impl<string_impl<BufferCapacity, DynamicExpandCapacity>> : std::true_type {};

    template <typename T>
    inline constexpr bool is_string_impl_v = is_string_impl<T>::value;
 
#if HYBSTR_CPP_20_OR_ABOVE
    template <auto str>
    [[nodiscard]] consteval auto fit_string() noexcept
    {
        static_assert(is_string_impl_v<std::remove_cvref_t<decltype(str)>>, "Expect a vre::string as input");
        return str.template resize<str.size()>();
    }
#endif
 
#if HYBSTR_CPP_20_OR_ABOVE
    #define HYBSTR_FIT_STRING(str)\
        hybstr::fit_string<(str)>()
#else
    #define HYBSTR_FIT_STRING(str) \
        ([&]() constexpr noexcept { return (str).template resize<(str).size()>(); })()
#endif
 
    // ======================================================================
    //                           Factory Functions
    // ======================================================================

    template<std::size_t DynamicExpandCapacity>
    [[nodiscard]] constexpr auto string()
    {
        return string_impl<0, DynamicExpandCapacity>{};
    }

    template<std::size_t DynamicExpandCapacity, std::size_t N>
    [[nodiscard]] constexpr auto string(const char(&str)[N])
    {
        return string_impl<N, DynamicExpandCapacity>{str};
    }

    template<std::size_t ViewSize, std::size_t DynamicExpandCapacity>
    [[nodiscard]] constexpr auto string(std::string_view sv) noexcept
    {
        return string_impl<ViewSize, DynamicExpandCapacity>{sv};
    }

    template<std::size_t RangeSize, std::size_t DynamicExpandCapacity, typename _Iter>
    [[nodiscard]] constexpr auto string(_Iter start, _Iter end) noexcept
    {
        return string_impl<RangeSize, DynamicExpandCapacity>{start, end};
    }
} // namespace hybstr

namespace hybstr::literals
{
#if HYBSTR_CPP_20_OR_ABOVE
    template<hybstr::string_impl str>
    [[nodiscard]] consteval auto operator""_hyb() noexcept
    {
        return str;
    }
#else
    [[nodiscard]] consteval auto operator""_hyb(const char* str, std::size_t len) noexcept
    {
        return hybstr::string(str, str + len);
    }
    #endif
}