basic_inplace_string.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
#ifndef TETL_STRING_BASIC_INPLACE_STRING_HPP
#define TETL_STRING_BASIC_INPLACE_STRING_HPP
 
#include <etl/_algorithm/copy.hpp>
#include <etl/_algorithm/fill.hpp>
#include <etl/_algorithm/max.hpp>
#include <etl/_algorithm/remove.hpp>
#include <etl/_algorithm/rotate.hpp>
#include <etl/_algorithm/swap_ranges.hpp>
#include <etl/_array/array.hpp>
#include <etl/_contracts/check.hpp>
#include <etl/_cstring/memset.hpp>
#include <etl/_iterator/begin.hpp>
#include <etl/_iterator/data.hpp>
#include <etl/_iterator/distance.hpp>
#include <etl/_iterator/end.hpp>
#include <etl/_iterator/next.hpp>
#include <etl/_iterator/prev.hpp>
#include <etl/_iterator/rbegin.hpp>
#include <etl/_iterator/rend.hpp>
#include <etl/_iterator/size.hpp>
#include <etl/_limits/numeric_limits.hpp>
#include <etl/_string/char_traits.hpp>
#include <etl/_string/str_replace.hpp>
#include <etl/_string_view/basic_string_view.hpp>
#include <etl/_strings/find.hpp>
#include <etl/_strings/rfind.hpp>
#include <etl/_type_traits/is_convertible.hpp>
#include <etl/_type_traits/smallest_size_t.hpp>
#include <etl/_utility/ignore_unused.hpp>
 
namespace etl {

template <typename Char, etl::size_t Capacity, typename Traits = etl::char_traits<Char>>
struct basic_inplace_string {
    template <typename T>
    static constexpr bool string_view_like =                        //
        is_convertible_v<T const&, basic_string_view<Char, Traits>> //
        and not is_convertible_v<T const&, Char const*>;
 
    using internal_size_t = etl::smallest_size_t<Capacity>;
 
public:
    using value_type             = Char;
    using size_type              = etl::size_t;
    using difference_type        = etl::ptrdiff_t;
    using traits_type            = Traits;
    using pointer                = Char*;
    using const_pointer          = Char const*;
    using reference              = Char&;
    using const_reference        = Char const&;
    using iterator               = Char*;
    using const_iterator         = Char const*;
    using reverse_iterator       = etl::reverse_iterator<iterator>;
    using const_reverse_iterator = etl::reverse_iterator<const_iterator>;

    constexpr basic_inplace_string() = default;

    constexpr basic_inplace_string(const_pointer str, size_type const len) noexcept
    {
        TETL_PRECONDITION(len <= Capacity);
        unsafe_set_size(len);
        traits_type::copy(_storage.data(), str, len);
    }

    constexpr basic_inplace_string(const_pointer str) noexcept
        : basic_inplace_string(str, traits_type::length(str))
    {
    }
 
    constexpr basic_inplace_string(nullptr_t /*null*/) = delete;

    constexpr basic_inplace_string(size_type count, Char ch) noexcept
    {
        TETL_PRECONDITION(count <= Capacity);
        fill(begin(), begin() + count, ch);
        unsafe_set_size(count);
    }

    template <typename InputIt>
        requires(detail::InputIterator<InputIt>)
    constexpr basic_inplace_string(InputIt first, InputIt last) noexcept
        : basic_inplace_string(first, static_cast<size_type>(distance(first, last)))
    {
    }

    constexpr basic_inplace_string(basic_inplace_string const& other, size_type pos, size_type count)
        : basic_inplace_string{other.substr(pos, count)}
    {
    }

    constexpr basic_inplace_string(basic_inplace_string const& other, size_type pos)
        : basic_inplace_string{other.substr(pos, other.size())}
    {
    }

    template <typename StringView>
        requires string_view_like<StringView>
    explicit constexpr basic_inplace_string(StringView const& view) noexcept
 
    {
        basic_string_view<Char, traits_type> const sv = view;
        assign(sv.begin(), sv.end());
    }

    template <typename StringView>
        requires string_view_like<StringView>
    explicit constexpr basic_inplace_string(StringView const& view, size_type pos, size_type n)
        : basic_inplace_string{basic_string_view<Char, traits_type>{view}.substr(pos, n)}
    {
    }

    constexpr basic_inplace_string(basic_inplace_string const& /*str*/) noexcept = default;

    constexpr basic_inplace_string(basic_inplace_string&& /*str*/) noexcept = default;

    constexpr auto operator=(basic_inplace_string const& /*str*/) noexcept -> basic_inplace_string& = default;

    constexpr auto operator=(basic_inplace_string&& /*str*/) noexcept -> basic_inplace_string& = default;

    constexpr auto operator=(const_pointer s) noexcept -> basic_inplace_string&
    {
        auto const len = traits_type::length(s);
        TETL_PRECONDITION(len <= capacity());
        assign(s, len);
        return *this;
    }
 
    constexpr auto operator=(nullptr_t /*0*/) -> basic_inplace_string& = delete;

    constexpr auto operator=(Char ch) noexcept -> basic_inplace_string&
    {
        assign(&ch, 1);
        return *this;
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto operator=(StringView const& view) noexcept -> basic_inplace_string&
    {
        assign(view);
        return *this;
    }

    constexpr auto assign(size_type count, Char ch) noexcept -> basic_inplace_string&
    {
        TETL_PRECONDITION(count <= capacity());
        (*this) = basic_inplace_string{count, ch};
        return *this;
    }

    constexpr auto assign(basic_inplace_string const& str) noexcept -> basic_inplace_string&
    {
        *this = str;
        return *this;
    }

    constexpr auto assign(basic_inplace_string const& str, size_type pos, size_type count = npos) noexcept
        -> basic_inplace_string&
    {
        *this = str.substr(pos, count);
        return *this;
    }

    constexpr auto assign(const_pointer s, size_type count) noexcept -> basic_inplace_string&
    {
        TETL_PRECONDITION(count <= capacity());
        *this = basic_inplace_string{s, count};
        return *this;
    }

    constexpr auto assign(const_pointer s) noexcept -> basic_inplace_string&
    {
        *this = basic_inplace_string{s, traits_type::length(s)};
        return *this;
    }

    template <typename InputIt>
        requires(detail::InputIterator<InputIt>)
    constexpr auto assign(InputIt first, InputIt last) noexcept -> basic_inplace_string&
    {
        *this = basic_inplace_string{first, last};
        return *this;
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto assign(StringView const& view) noexcept -> basic_inplace_string&
    {
        auto tmp = basic_inplace_string{view};
        *this    = tmp;
        return *this;
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto assign(StringView const& view, size_type pos, size_type count = npos) noexcept
        -> basic_inplace_string&
    {
        auto tmp = basic_inplace_string{view, pos, count};
        *this    = tmp;
        return *this;
    }

    constexpr auto operator[](size_type index) noexcept -> reference { return unsafe_at(index); }

    constexpr auto operator[](size_type index) const noexcept -> const_reference { return unsafe_at(index); }

    constexpr auto begin() noexcept -> iterator { return data(); }

    [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator { return data(); }

    [[nodiscard]] constexpr auto cbegin() const noexcept -> const_iterator { return begin(); }

    constexpr auto end() noexcept -> iterator { return etl::next(begin(), static_cast<ptrdiff_t>(size())); }

    [[nodiscard]] constexpr auto end() const noexcept -> const_iterator
    {
        return etl::next(begin(), static_cast<ptrdiff_t>(size()));
    }

    [[nodiscard]] constexpr auto cend() const noexcept -> const_iterator { return end(); }

    [[nodiscard]] constexpr auto rbegin() noexcept -> reverse_iterator { return reverse_iterator(end()); }

    [[nodiscard]] constexpr auto rbegin() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr auto crbegin() const noexcept -> const_reverse_iterator { return rbegin(); }

    [[nodiscard]] constexpr auto rend() noexcept -> reverse_iterator { return reverse_iterator(begin()); }

    [[nodiscard]] constexpr auto rend() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr auto crend() const noexcept -> const_reverse_iterator { return rend(); }

    [[nodiscard]] constexpr auto front() noexcept -> reference
    {
        TETL_PRECONDITION(not empty());
        return *begin();
    }

    [[nodiscard]] constexpr auto front() const noexcept -> const_reference
    {
        TETL_PRECONDITION(not empty());
        return *begin();
    }

    [[nodiscard]] constexpr auto back() noexcept -> reference
    {
        TETL_PRECONDITION(not empty());
        return *etl::prev(end());
    }

    [[nodiscard]] constexpr auto back() const noexcept -> const_reference
    {
        TETL_PRECONDITION(not empty());
        return *etl::prev(end());
    }

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

    [[nodiscard]] constexpr auto full() const noexcept -> bool { return size() == capacity(); }

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

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

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

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

    static constexpr auto reserve(size_type /*newCap*/) -> void { }

    static constexpr auto shrink_to_fit() -> void { }

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

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

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

    [[nodiscard]] constexpr operator basic_string_view<Char, traits_type>() const noexcept
    {
        return basic_string_view<Char, traits_type>(data(), size());
    }

    constexpr auto clear() noexcept -> void
    {
        *begin() = Char(0);
        unsafe_set_size(0);
    }

    constexpr auto erase(size_type index = 0, size_type count = npos) noexcept -> basic_inplace_string&
    {
        auto safeCount = etl::min(count, size() - index);
        erase(begin() + index, begin() + index + safeCount);
        return *this;
    }

    constexpr auto erase(const_iterator position) noexcept -> iterator { return erase(position, position + 1); }

    constexpr auto erase(const_iterator first, const_iterator last) noexcept -> iterator
    {
        auto const start    = static_cast<size_type>(etl::distance(cbegin(), first));
        auto const distance = static_cast<size_type>(etl::distance(first, last));
        TETL_PRECONDITION(size() > distance);
        etl::rotate(begin() + start, begin() + start + distance, end());
        unsafe_set_size(size() - distance);
        return begin() + start;
    }

    constexpr auto push_back(Char ch) noexcept -> void
    {
        TETL_PRECONDITION(size() < capacity());
        append(1, ch);
    }

    constexpr auto pop_back() noexcept -> void
    {
        TETL_PRECONDITION(not empty());
        unsafe_set_size(size() - 1);
    }

    constexpr auto append(size_type const count, Char const s) noexcept -> basic_inplace_string&
    {
        auto const safeCount = etl::min(count, capacity() - size());
        auto const newSize   = size() + safeCount;
        etl::fill(end(), etl::next(begin(), static_cast<ptrdiff_t>(newSize)), s);
        unsafe_set_size(newSize);
        return *this;
    }

    constexpr auto append(const_pointer s) noexcept -> basic_inplace_string&
    {
        auto const len = traits_type::length(s);
        return append(s, len);
    }

    constexpr auto append(const_pointer str, size_type count) noexcept -> basic_inplace_string&
    {
        auto const safeCount = etl::min(count, capacity() - size());
        etl::copy(str, etl::next(str, static_cast<ptrdiff_t>(safeCount)), end());
        unsafe_set_size(size() + safeCount);
        return *this;
    }

    template <typename InputIt>
        requires(detail::InputIterator<InputIt>)
    constexpr auto append(InputIt first, InputIt last) noexcept -> basic_inplace_string&
    {
        for (; first != last; ++first) {
            push_back(*first);
        }
        return *this;
    }

    constexpr auto append(basic_inplace_string const& str) noexcept -> basic_inplace_string&
    {
        return append(str.begin(), str.end());
    }

    constexpr auto append(basic_inplace_string const& str, size_type pos, size_type count = npos) noexcept
        -> basic_inplace_string&
    {
        return append(str.substr(pos, count));
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto append(StringView const& view) -> basic_inplace_string&
    {
        etl::basic_string_view<Char, traits_type> sv = view;
        return append(sv.data(), sv.size());
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto append(StringView const& view, size_type pos, size_type count = npos) -> basic_inplace_string&
    {
        etl::basic_string_view<Char, traits_type> sv = view;
        return append(sv.substr(pos, count));
    }

    constexpr auto operator+=(basic_inplace_string const& str) noexcept -> basic_inplace_string& { return append(str); }

    constexpr auto operator+=(Char ch) noexcept -> basic_inplace_string& { return append(1, ch); }

    constexpr auto operator+=(const_pointer s) noexcept -> basic_inplace_string& { return append(s); }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto operator+=(StringView const& view) noexcept -> basic_inplace_string&
    {
        return append(view);
    }

    constexpr auto insert(size_type const index, size_type const count, Char const ch) noexcept -> basic_inplace_string&
    {
        for (size_type i = 0; i < count; ++i) {
            insert_impl(begin() + index, &ch, 1);
        }
        return *this;
    }

    constexpr auto insert(size_type const index, const_pointer s) noexcept -> basic_inplace_string&
    {
        insert_impl(begin() + index, s, traits_type::length(s));
        return *this;
    }

    constexpr auto insert(size_type const index, const_pointer s, size_type const count) noexcept
        -> basic_inplace_string&
    {
        insert_impl(begin() + index, s, count);
        return *this;
    }

    constexpr auto insert(size_type const index, basic_inplace_string const& str) noexcept -> basic_inplace_string&
    {
        insert_impl(begin() + index, str.data(), str.size());
        return *this;
    }

    constexpr auto insert(
        size_type const index,
        basic_inplace_string const& str,
        size_type const indexStr,
        size_type const count = npos
    ) noexcept -> basic_inplace_string&
    {
        using view_type = basic_string_view<Char, traits_type>;
        auto sv         = view_type(str).substr(indexStr, count);
        insert_impl(begin() + index, sv.data(), sv.size());
        return *this;
    }
 
    //
    //  * \brief Inserts character ch before the character pointed by pos.
    // constexpr auto insert(const_iterator pos, Char const ch) noexcept
    // -> iterator
    // {
    // }
 
    //
    //  * \brief Inserts count copies of character ch before the element (if
    //  any) pointed by
    //  * pos.
    // constexpr auto insert(const_iterator pos, size_type count,
    //                       Char const ch) noexcept -> iterator
    // {
    // }
 
    //
    //  * \brief Inserts characters from the range [first, last) before the
    //  element (if any)
    //  * pointed by pos.
    // template <typename InputIter>
    // requires(detail::InputIterator<T>)
    // constexpr auto insert(const_iterator pos, InputIter first, InputIter
    // last) noexcept
    //     -> iterator
    // {
    // }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto insert(size_type const pos, StringView const& view) noexcept -> basic_inplace_string&
    {
        basic_string_view<Char, traits_type> sv = view;
        insert_impl(begin() + pos, sv.data(), sv.size());
        return *this;
    }

    template <typename StringView>
        requires string_view_like<StringView>
    constexpr auto
    insert(size_type const index, StringView const& view, size_type const indexStr, size_type const count = npos)
        noexcept -> basic_inplace_string&
    {
        basic_string_view<Char, traits_type> sv = view;
 
        auto sub = sv.substr(indexStr, count);
        insert_impl(begin() + index, sub.data(), sub.size());
        return *this;
    }

    [[nodiscard]] constexpr auto compare(basic_inplace_string const& str) const noexcept -> int
    {
        return basic_string_view<Char, Traits>{*this}.compare({str.data(), str.size()});
    }

    template <size_type OtherCapacity>
    [[nodiscard]] constexpr auto compare(basic_inplace_string<Char, OtherCapacity, traits_type> const& str
    ) const noexcept -> int
    {
        return basic_string_view<Char, Traits>{*this}.compare({str.data(), str.size()});
    }

    [[nodiscard]] constexpr auto
    compare(size_type const pos, size_type const count, basic_inplace_string const& str) const -> int
    {
        auto const sz  = count > size() - pos ? size() : count;
        auto const sub = basic_string_view<Char, Traits>(*this).substr(pos, sz);
        return sub.compare(str);
    }

    [[nodiscard]] constexpr auto compare(
        size_type const pos1,
        size_type const count1,
        basic_inplace_string const& str,
        size_type const pos2,
        size_type const count2 = npos
    ) const -> int
    {
        auto const sz1  = count1 > size() - pos1 ? size() : count1;
        auto const sub1 = basic_string_view<Char, Traits>(*this).substr(pos1, sz1);
 
        auto const sz2  = count2 > str.size() - pos2 ? size() : count2;
        auto const sub2 = basic_string_view<Char, Traits>(str).substr(pos2, sz2);
 
        return sub1.compare(sub2);
    }

    [[nodiscard]] constexpr auto compare(const_pointer s) const -> int
    {
        return basic_string_view<Char, Traits>{*this}.compare({s, traits_type::length(s)});
    }

    [[nodiscard]] constexpr auto compare(size_type const pos, size_type const count, const_pointer s) const -> int
    {
        auto const sz  = count > size() - pos ? size() : count;
        auto const sub = basic_string_view<Char, Traits>(*this).substr(pos, sz);
        return sub.compare({s, traits_type::length(s)});
    }

    [[nodiscard]] constexpr auto
    compare(size_type const pos1, size_type const count1, const_pointer s, size_type const count2) const -> int
    {
        auto const sz  = count1 > size() - pos1 ? size() : count1;
        auto const sub = basic_string_view<Char, Traits>(*this).substr(pos1, sz);
        return sub.compare({s, count2});
    }

    template <typename StringView>
        requires string_view_like<StringView>
    [[nodiscard]] constexpr auto compare(StringView const& view) const noexcept -> int
    {
        using view_type    = basic_string_view<Char, Traits>;
        view_type const sv = view;
        return view_type(*this).compare(sv);
    }

    template <typename StringView>
        requires string_view_like<StringView>
    [[nodiscard]] constexpr auto compare(size_type pos1, size_type count1, StringView const& view) const noexcept -> int
    {
        using view_type    = basic_string_view<Char, Traits>;
        view_type const sv = view;
        return view_type(*this).substr(pos1, count1).compare(sv);
    }

    template <typename StringView>
        requires string_view_like<StringView>
    [[nodiscard]] constexpr auto
    compare(size_type pos1, size_type count1, StringView const& view, size_type pos2, size_type count2 = npos)
        const noexcept -> int
    {
        using view_type    = basic_string_view<Char, Traits>;
        view_type const sv = view;
        return view_type(*this).substr(pos1, count1).compare(sv.substr(pos2, count2));
    }

    [[nodiscard]] constexpr auto starts_with(basic_string_view<Char, Traits> sv) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).starts_with(sv);
    }

    [[nodiscard]] constexpr auto starts_with(Char c) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).starts_with(c);
    }

    [[nodiscard]] constexpr auto starts_with(const_pointer s) const -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).starts_with(s);
    }

    [[nodiscard]] constexpr auto ends_with(basic_string_view<Char, Traits> sv) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).ends_with(sv);
    }

    [[nodiscard]] constexpr auto ends_with(Char c) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).ends_with(c);
    }

    [[nodiscard]] constexpr auto ends_with(const_pointer str) const -> bool
    {
        return basic_string_view<Char, Traits>(data(), size()).ends_with(str);
    }

    constexpr auto replace(size_type pos, size_type count, basic_inplace_string const& str) -> basic_inplace_string&
    {
        TETL_PRECONDITION(pos < size());
        TETL_PRECONDITION(pos + count < size());
 
        auto* f = data() + pos;
        auto* l = data() + pos + count;
        detail::str_replace(f, l, str.begin(), str.end());
        return *this;
    }

    constexpr auto replace(const_iterator first, const_iterator last, basic_inplace_string const& str)
        -> basic_inplace_string&
    {
        auto* f = to_mutable_iterator(first);
        auto* l = to_mutable_iterator(last);
        detail::str_replace(f, l, str.begin(), str.end());
        return *this;
    }
 
    constexpr auto
    replace(size_type pos, size_type count, basic_inplace_string const& str, size_type pos2, size_type count2 = npos)
        -> basic_inplace_string&
    {
        TETL_PRECONDITION(pos < size());
        TETL_PRECONDITION(pos2 < str.size());
 
        auto* f        = data() + etl::min(pos, size());
        auto* l        = data() + etl::min(pos + count, size());
        auto const* sf = etl::next(str.begin(), static_cast<etl::ptrdiff_t>(etl::min(pos2, str.size())));
        auto const* sl = etl::next(str.begin(), static_cast<etl::ptrdiff_t>(etl::min(pos2 + count2, str.size())));
        detail::str_replace(f, l, sf, sl);
        return *this;
    }
 
    constexpr auto replace(size_type pos, size_type count, Char const* str, size_type count2) -> basic_inplace_string&
    {
        TETL_PRECONDITION(pos < size());
        TETL_PRECONDITION(pos + count < size());
 
        auto* f = next(data(), min(pos, size()));
        auto* l = next(data(), min(pos + count, size()));
        detail::str_replace(f, l, str, next(str, count2));
        return *this;
    }
 
    constexpr auto replace(const_iterator first, const_iterator last, Char const* str, size_type count2)
        -> basic_inplace_string&
    {
        auto* f = to_mutable_iterator(first);
        auto* l = to_mutable_iterator(last);
        detail::str_replace(f, l, str, next(str, count2));
        return *this;
    }
 
    constexpr auto replace(size_type pos, size_type count, Char const* str) -> basic_inplace_string&
    {
        TETL_PRECONDITION(pos < size());
        TETL_PRECONDITION(pos + count < size());
 
        auto* f = next(data(), min(pos, size()));
        auto* l = next(data(), min(pos + count, size()));
        detail::str_replace(f, l, str, next(str, strlen(str)));
        return *this;
    }
 
    constexpr auto replace(const_iterator first, const_iterator last, Char const* str) -> basic_inplace_string&
    {
        auto* f = to_mutable_iterator(first);
        auto* l = to_mutable_iterator(last);
        detail::str_replace(f, l, str, next(str, strlen(str)));
        return *this;
    }
 
    // constexpr auto replace(size_type pos, size_type count, size_type count2,
    //    Char ch) -> basic_inplace_string&
    //{
    //    TETL_ASSERT(pos < size());
    //    TETL_ASSERT(pos + count < size());
    //
    //    auto* f = next(data(), min(pos, size()));
    //    auto* l = next(data(), min(pos + count, size()));
    //    detail::str_replace(f, l, ch);
    //    return *this;
    //}
 
    constexpr auto replace(const_iterator first, const_iterator last, size_type count2, Char ch)
        -> basic_inplace_string&
    {
        auto* f = to_mutable_iterator(first);
        auto* l = etl::min(to_mutable_iterator(last), f + count2);
        detail::str_replace(f, l, ch);
        return *this;
    }

    [[nodiscard]] constexpr auto substr(size_type pos = 0, size_type count = npos) const -> basic_inplace_string
    {
        if (pos > size()) {
            return {};
        }
        return basic_inplace_string(data() + pos, etl::min(count, size() - pos));
    }

    constexpr auto copy(pointer destination, size_type count, size_type pos = 0) const -> size_type
    {
        if (pos > size()) {
            return 0;
        }
        auto const* first = data() + pos;
        auto const* last  = first + etl::min(count, size() - pos);
        auto const* dest  = destination;
        auto const* res   = etl::copy(first, last, destination);
        return static_cast<size_type>(res - dest);
    }

    constexpr auto resize(size_type count, Char ch) noexcept -> void
    {
        if (size() > count) {
            unsafe_set_size(count);
        }
        if (size() < count) {
            append(count, ch);
        }
    }

    constexpr auto resize(size_type count) noexcept -> void { resize(count, Char()); }

    constexpr auto swap(basic_inplace_string& other) noexcept -> void
    {
        auto const thisSize = size();
        auto const maxSize  = static_cast<etl::ptrdiff_t>(etl::max(thisSize, other.size()));
 
        etl::swap_ranges(begin(), etl::next(begin(), maxSize + 1), other.begin()); // includes null-terminator
        unsafe_set_size(other.size());
        other.unsafe_set_size(thisSize);
    }

    [[nodiscard]] constexpr auto find(basic_inplace_string const& str, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::find<Char, Traits>(*this, str, pos);
    }

    [[nodiscard]] constexpr auto find(const_pointer s, size_type pos, size_type count) const noexcept -> size_type
    {
        return etl::strings::find<Char, Traits>(*this, basic_string_view<Char, Traits>{s, count}, pos);
    }

    [[nodiscard]] constexpr auto find(const_pointer s, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::find<Char, Traits>(*this, s, pos);
    }

    [[nodiscard]] constexpr auto find(Char ch, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::find<Char, Traits>(*this, basic_string_view<Char, Traits>{&ch, 1}, pos);
    }

    [[nodiscard]] constexpr auto rfind(basic_inplace_string const& str, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::rfind<Char, Traits>(*this, str, pos);
    }

    [[nodiscard]] constexpr auto rfind(const_pointer s, size_type pos, size_type count) const noexcept -> size_type
    {
        return etl::strings::rfind<Char, Traits>(*this, s, count, pos);
    }

    [[nodiscard]] constexpr auto rfind(const_pointer s, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::rfind<Char, Traits>(*this, s, pos);
    }

    [[nodiscard]] constexpr auto rfind(Char ch, size_type pos = 0) const noexcept -> size_type
    {
        return etl::strings::rfind<Char, Traits>(*this, ch, pos);
    }

    [[nodiscard]] constexpr auto find_first_of(basic_inplace_string const& str, size_type pos = 0) const noexcept
        -> size_type
    {
        return find_first_of(str.c_str(), pos, str.size());
    }

    [[nodiscard]] constexpr auto find_first_of(const_pointer s, size_type pos, size_type count) const -> size_type
    {
        if (pos < size()) {
            return basic_string_view<Char, Traits>{*this}.find_first_of(s, pos, count);
        }
 
        return npos;
    }

    [[nodiscard]] constexpr auto find_first_of(const_pointer s, size_type pos = 0) const -> size_type
    {
        return find_first_of(s, pos, traits_type::length(s));
    }

    [[nodiscard]] constexpr auto find_first_of(Char ch, size_type pos = 0) const noexcept -> size_type
    {
        return find_first_of(&ch, pos, 1);
    }

    [[nodiscard]] constexpr auto
    find_first_of(basic_string_view<Char, traits_type> str, size_type pos = 0) const noexcept -> size_type
    {
        return find_first_of(str.data(), pos, str.size());
    }

    [[nodiscard]] constexpr auto find_first_not_of(basic_inplace_string const& str, size_type pos = 0) const noexcept
        -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_first_not_of(str, pos);
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char ch, size_type pos = 0) const noexcept -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_first_not_of(ch, pos);
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char const* s, size_type pos) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_first_not_of(s, pos);
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_first_not_of(s, pos, count);
    }

    [[nodiscard]] constexpr auto find_last_of(basic_inplace_string const& str, size_type pos = 0) const noexcept
        -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_of(str, pos);
    }

    [[nodiscard]] constexpr auto find_last_of(Char c, size_type pos = 0) const noexcept -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_of(c, pos);
    }

    [[nodiscard]] constexpr auto find_last_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_of(s, pos, count);
    }

    [[nodiscard]] constexpr auto find_last_of(Char const* s, size_type pos = 0) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_of(s, pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(basic_inplace_string const& str, size_type pos = 0) const noexcept
        -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_not_of(str, pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(Char c, size_type pos = 0) const noexcept -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_not_of(c, pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_not_of(s, pos, count);
    }

    [[nodiscard]] constexpr auto find_last_not_of(Char const* s, size_type pos = 0) const -> size_type
    {
        return basic_string_view<Char, Traits>{*this}.find_last_not_of(s, pos);
    }

    [[nodiscard]] constexpr auto contains(etl::basic_string_view<Char, Traits> sv) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>{*this}.contains(sv);
    }

    [[nodiscard]] constexpr auto contains(Char c) const noexcept -> bool
    {
        return basic_string_view<Char, Traits>{*this}.contains(c);
    }

    [[nodiscard]] constexpr auto contains(Char const* s) const -> bool
    {
        return basic_string_view<Char, Traits>{*this}.contains(s);
    }

    static constexpr size_type npos = numeric_limits<size_type>::max();
 
private:
    [[nodiscard]] constexpr auto to_mutable_iterator(const_iterator it) -> iterator
    {
        auto const dist = etl::distance(cbegin(), it);
        return etl::next(begin(), static_cast<etl::ptrdiff_t>(dist));
    }
 
    [[nodiscard]] constexpr auto unsafe_at(size_type index) noexcept -> reference
    {
        TETL_PRECONDITION(index < size() + 1);
        return *etl::next(_storage.data(), static_cast<etl::ptrdiff_t>(index));
    }
 
    [[nodiscard]] constexpr auto unsafe_at(size_type index) const noexcept -> const_reference
    {
        TETL_PRECONDITION(index < size() + 1);
        return *etl::next(_storage.data(), static_cast<etl::ptrdiff_t>(index));
    }
 
    constexpr auto unsafe_set_size(size_type const newSize) noexcept -> void
    {
        TETL_PRECONDITION(newSize <= Capacity);
        _storage.set_size(newSize);
        unsafe_at(newSize) = Char(0);
    }
 
    constexpr auto insert_impl(iterator pos, const_pointer text, size_type count) -> void
    {
        // Insert text at end.
        auto* currentEnd = end();
        append(text, count);
 
        // Rotate to correct position
        etl::rotate(pos, currentEnd, end());
    }
 
    struct tiny_layout {
        constexpr tiny_layout() noexcept { _buffer[Capacity] = Capacity; }
 
        [[nodiscard]] constexpr auto data() noexcept { return _buffer.data(); }
 
        [[nodiscard]] constexpr auto data() const noexcept { return _buffer.data(); }
 
        [[nodiscard]] constexpr auto get_size() const noexcept { return Capacity - size_type(_buffer[Capacity]); }
 
        constexpr auto set_size(size_t size) noexcept { return _buffer[Capacity] = Char(Capacity - size); }
 
    private:
        etl::array<Char, Capacity + 1> _buffer{};
    };
 
    struct normal_layout {
        constexpr normal_layout() noexcept = default;
 
        [[nodiscard]] constexpr auto data() noexcept { return _buffer.data(); }
 
        [[nodiscard]] constexpr auto data() const noexcept { return _buffer.data(); }
 
        [[nodiscard]] constexpr auto get_size() const noexcept { return size_t(_size); }
 
        constexpr auto set_size(size_t size) noexcept { return _size = internal_size_t(size); }
 
    private:
        internal_size_t _size{};
        etl::array<Char, Capacity + 1> _buffer{};
    };
 
    using layout_type = etl::conditional_t<(Capacity < 16), tiny_layout, normal_layout>;
    layout_type _storage{};
};

template <etl::size_t Capacity>
using inplace_string = basic_inplace_string<char, Capacity>;

template <etl::size_t Capacity>
using inplace_wstring = basic_inplace_string<wchar_t, Capacity>;

template <etl::size_t Capacity>
using inplace_u8string = basic_inplace_string<char8_t, Capacity>;

template <etl::size_t Capacity>
using inplace_u16string = basic_inplace_string<char16_t, Capacity>;

template <etl::size_t Capacity>
using inplace_u32string = basic_inplace_string<char32_t, Capacity>;

template <typename Char, typename Traits, size_t Capacity1, size_t Capacity2>
[[nodiscard]] constexpr auto operator+(
    basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept -> basic_inplace_string<Char, Capacity1, Traits>
{
    auto str = basic_inplace_string<Char, Capacity1, Traits>{lhs};
    str.append(rhs);
    return str;
}

template <typename Char, typename Traits, size_t Capacity>
[[nodiscard]] constexpr auto
operator+(basic_inplace_string<Char, Capacity, Traits> const& lhs, Char const* rhs) noexcept
    -> basic_inplace_string<Char, Capacity, Traits>
{
    auto str = basic_inplace_string<Char, Capacity, Traits>{lhs};
    str.append(rhs);
    return str;
}

template <typename Char, typename Traits, size_t Capacity>
[[nodiscard]] constexpr auto operator+(basic_inplace_string<Char, Capacity, Traits> const& lhs, Char rhs) noexcept
    -> basic_inplace_string<Char, Capacity, Traits>
{
    auto str = basic_inplace_string<Char, Capacity, Traits>{lhs};
    str.append(1, rhs);
    return str;
}

template <typename Char, typename Traits, size_t Capacity>
[[nodiscard]] constexpr auto
operator+(Char const* lhs, basic_inplace_string<Char, Capacity, Traits> const& rhs) noexcept
    -> basic_inplace_string<Char, Capacity, Traits>
{
    auto str = basic_inplace_string<Char, Capacity, Traits>{lhs};
    str.append(rhs);
    return str;
}

template <typename Char, typename Traits, size_t Capacity>
[[nodiscard]] constexpr auto operator+(Char lhs, basic_inplace_string<Char, Capacity, Traits> const& rhs) noexcept
    -> basic_inplace_string<Char, Capacity, Traits>
{
    auto str = basic_inplace_string<Char, Capacity, Traits>{1, lhs};
    str.append(rhs);
    return str;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator==(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept -> bool
{
    return lhs.compare(rhs) == 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
[[nodiscard]] constexpr auto
operator==(etl::basic_inplace_string<Char, Capacity, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) == 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
[[nodiscard]] constexpr auto
operator==(Char const* lhs, etl::basic_inplace_string<Char, Capacity, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) == 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator!=(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept -> bool
{
    return lhs.compare(rhs) != 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator!=(etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) != 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
[[nodiscard]] constexpr auto
operator!=(Char const* lhs, etl::basic_inplace_string<Char, Capacity, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) != 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator<(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept
{
    return lhs.compare(rhs) < 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator<(etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) < 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator<(Char const* lhs, etl::basic_inplace_string<Char, Capacity1, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) > 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator<=(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept
{
    return lhs.compare(rhs) <= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator<=(etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) <= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator<=(Char const* lhs, etl::basic_inplace_string<Char, Capacity1, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) >= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator>(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept
{
    return lhs.compare(rhs) > 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator>(etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) > 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1>
[[nodiscard]] constexpr auto
operator>(Char const* lhs, etl::basic_inplace_string<Char, Capacity1, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) < 0;
}

template <typename Char, typename Traits, etl::size_t Capacity1, etl::size_t Capacity2>
[[nodiscard]] constexpr auto operator>=(
    etl::basic_inplace_string<Char, Capacity1, Traits> const& lhs,
    etl::basic_inplace_string<Char, Capacity2, Traits> const& rhs
) noexcept
{
    return lhs.compare(rhs) >= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
[[nodiscard]] constexpr auto
operator>=(etl::basic_inplace_string<Char, Capacity, Traits> const& lhs, Char const* rhs) noexcept -> bool
{
    return lhs.compare(rhs) >= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
[[nodiscard]] constexpr auto
operator>=(Char const* lhs, etl::basic_inplace_string<Char, Capacity, Traits> const& rhs) noexcept -> bool
{
    return rhs.compare(lhs) <= 0;
}

template <typename Char, typename Traits, etl::size_t Capacity>
constexpr auto
swap(etl::basic_inplace_string<Char, Capacity, Traits>& lhs, etl::basic_inplace_string<Char, Capacity, Traits>& rhs)
    noexcept(noexcept(lhs.swap(rhs))) -> void
{
    lhs.swap(rhs);
}

template <typename Char, typename Traits, etl::size_t Capacity, typename U>
constexpr auto erase(basic_inplace_string<Char, Capacity, Traits>& c, U const& value) noexcept ->
    typename basic_inplace_string<Char, Capacity, Traits>::size_type
{
    using return_type = typename basic_inplace_string<Char, Capacity, Traits>::size_type;
 
    auto it = etl::remove(begin(c), end(c), value);
    auto r  = etl::distance(it, end(c));
    c.erase(it, end(c));
    return static_cast<return_type>(r);
}

template <typename Char, typename Traits, etl::size_t Capacity, typename Predicate>
constexpr auto erase_if(basic_inplace_string<Char, Capacity, Traits>& c, Predicate pred) noexcept ->
    typename basic_inplace_string<Char, Capacity, Traits>::size_type
{
    using return_type = typename basic_inplace_string<Char, Capacity, Traits>::size_type;
 
    auto it = etl::remove_if(begin(c), end(c), pred);
    auto r  = etl::distance(it, end(c));
    c.erase(it, end(c));
    return static_cast<return_type>(r);
}
 
} // namespace etl
 
#endif // TETL_STRING_BASIC_INPLACE_STRING_HPP