inplace_string.hpp

// Copyright (c) 2023 Martin Stump
// SPDX-License-Identifier: BSL-1.0
 
#pragma once
 
#include <algorithm>
#include <array>
#include <concepts>
#include <cstddef>
#include <format>
#include <iostream>
#include <iterator>
#include <ostream>
#include <ranges>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
 
namespace gw {
 
//
template <std::size_t N, class CharT, class Traits = std::char_traits<CharT>>
class basic_inplace_string {
 public:
  using traits_type = Traits;                                            
  using value_type = CharT;                                              
  using size_type = std::size_t;                                         
  using difference_type = std::ptrdiff_t;                                
  using reference = value_type&;                                         
  using const_reference = const value_type&;                             
  using pointer = value_type*;                                           
  using const_pointer = const value_type*;                               
  using iterator = value_type*;                                          
  using const_iterator = const value_type*;                              
  using reverse_iterator = std::reverse_iterator<iterator>;              
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;  
 
  std::array<value_type, N + 1U> m_data;
 
  // NOLINTNEXTLINE(readability-identifier-naming)
  static constexpr size_type npos = -1;  
 
  constexpr basic_inplace_string() noexcept = default;
 
  template <std::size_t N2>
  // NOLINTNEXTLINE
  consteval explicit(false) basic_inplace_string(const value_type (&str)[N2]) noexcept
    requires(N2 <= N + 1)
      : m_data{} {
    traits_type::copy(data(), str, N2 - 1);
  }
 
  constexpr basic_inplace_string(size_type count, value_type ch) : m_data{} {
    if (count > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::basic_inplace_string: count (which is {}) > max_size (which is {})", count,
                      max_size())};
    }
    std::ranges::fill_n(begin(), count, ch);
  }
 
  constexpr explicit basic_inplace_string(const value_type* str) : m_data{} {
    const auto str_size = traits_type::length(str);
 
    if (str_size > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::basic_inplace_string: str_size (which is {}) > max_size (which is {})",
                      str_size, max_size())};
    }
 
    traits_type::copy(begin(), str, str_size);
  }
 
  constexpr explicit basic_inplace_string(const value_type* str, size_type count) : m_data{} {
    if (count > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::basic_inplace_string: count (which is {}) > max_size (which is {})", count,
                      max_size())};
    }
    traits_type::copy(begin(), str, count);
  }
 
  template <std::input_iterator InputIt>
  constexpr explicit basic_inplace_string(InputIt first, InputIt last) : m_data{} {
    const auto str_size = std::ranges::distance(first, last);
 
    if (str_size > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::basic_inplace_string: str_size (which is {}) > max_size (which is {})",
                      str_size, max_size())};
    }
 
    std::ranges::copy(first, last, begin());
  }
 
  constexpr explicit basic_inplace_string(const std::basic_string_view<value_type, traits_type>& str)
      : basic_inplace_string(str.data(), str.size()) {}
 
  template <std::ranges::range R>
    requires(!std::is_convertible_v<const R&, std::basic_string_view<value_type, traits_type>> &&
             std::convertible_to<std::ranges::range_value_t<R>, value_type>)
  constexpr explicit basic_inplace_string(const R& range)
      : basic_inplace_string(std::ranges::begin(range), std::ranges::end(range)) {}
 
  constexpr basic_inplace_string(const basic_inplace_string& other) noexcept = default;
 
  constexpr basic_inplace_string(basic_inplace_string&& other) noexcept = default;
 
  constexpr ~basic_inplace_string() noexcept = default;
 
  constexpr auto operator=(const basic_inplace_string& other) noexcept -> basic_inplace_string& = default;
 
  constexpr auto operator=(basic_inplace_string&& other) noexcept -> basic_inplace_string& = default;
 
  constexpr auto at(size_type pos) -> reference {
    return pos < size()
               ? m_data[pos]
               : throw std::out_of_range{std::format(
                     "basic_inplace_string::at: pos (which is {}) >= max_size (which is {})", pos, max_size())};
  }
 
  constexpr auto at(size_type pos) const -> const_reference {
    return pos < size()
               ? m_data[pos]
               : throw std::out_of_range{std::format(
                     "basic_inplace_string::at: pos (which is {}) >= max_size (which is {})", pos, max_size())};
  }
 
  constexpr auto operator[](size_type pos) noexcept -> reference { return m_data[pos]; }
 
  constexpr auto operator[](size_type pos) const noexcept -> const_reference { return m_data[pos]; }
 
  constexpr auto front() noexcept -> reference { return m_data[0]; }
 
  constexpr auto front() const noexcept -> const_reference { return m_data[0]; }
 
  constexpr auto back() noexcept -> reference { return m_data[size() - 1]; }
 
  constexpr auto back() const noexcept -> const_reference { return m_data[size() - 1]; }
 
  constexpr auto data() noexcept -> pointer { return m_data.data(); }
 
  constexpr auto data() const noexcept -> const_pointer { return m_data.data(); }
 
  constexpr auto c_str() const noexcept -> const_pointer { return m_data.data(); }
 
  constexpr explicit operator std::basic_string_view<value_type, traits_type>() const noexcept {
    return {data(), size()};
  }
 
  constexpr auto view() const noexcept -> std::basic_string_view<value_type, traits_type> { return {data(), size()}; }
 
  constexpr auto begin() noexcept -> iterator { return data(); }
 
  constexpr auto begin() const noexcept -> const_iterator { return data(); }
 
  constexpr auto cbegin() const noexcept -> const_iterator { return data(); }
 
  constexpr auto end() noexcept -> iterator { return std::ranges::next(data(), size()); }
 
  constexpr auto end() const noexcept -> const_iterator { return std::ranges::next(data(), size()); }
 
  constexpr auto cend() const noexcept -> const_iterator { return std::ranges::next(data(), size()); }
 
  constexpr auto rbegin() noexcept -> reverse_iterator { return reverse_iterator{end()}; }
 
  constexpr auto rbegin() const noexcept -> const_reverse_iterator { return const_reverse_iterator{end()}; }
 
  constexpr auto crbegin() const noexcept -> const_reverse_iterator { return const_reverse_iterator{cend()}; }
 
  constexpr auto rend() noexcept -> reverse_iterator { return reverse_iterator{begin()}; }
 
  constexpr auto rend() const noexcept -> const_reverse_iterator { return const_reverse_iterator{begin()}; }
 
  constexpr auto crend() const noexcept -> const_reverse_iterator { return const_reverse_iterator{cbegin()}; }
 
  [[nodiscard]] constexpr auto empty() const noexcept -> bool { return size() == 0U; }
 
  [[nodiscard]] constexpr auto size() const noexcept -> size_type { return traits_type::length(data()); }
 
  [[nodiscard]] constexpr auto length() const noexcept -> size_type { return size(); }
 
  [[nodiscard]] inline constexpr auto max_size() const noexcept -> size_type { return N; }
 
  constexpr void reserve(size_type new_cap) {
    if (new_cap > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::reserve: new_cap (which is {}) > max_size (which is {})", new_cap, max_size())};
    }
  }
 
  [[nodiscard]] constexpr auto capacity() const noexcept -> size_type { return max_size(); }
 
  constexpr void shrink_to_fit() {}
 
  constexpr void clear() noexcept { m_data[0] = value_type{}; }
 
  constexpr void insert(size_type index, size_type count, CharT ch) {
    const auto new_size = size() + count;
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::insert: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    std::ranges::copy_backward(std::ranges::next(begin(), index), end(), std::ranges::next(end(), count));
    std::ranges::fill_n(std::ranges::next(begin(), index), count, ch);
    m_data[new_size] = value_type{};  // Ensure null termination
  }
 
  auto insert(size_type index, const value_type* str) -> basic_inplace_string& {
    const auto str_size = traits_type::length(str);
    return insert(index, str, str_size);
  }
 
  auto insert(size_type index, const value_type* str, size_type count) -> basic_inplace_string& {
    const auto new_size = size() + count;
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::insert: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    std::ranges::copy_backward(std::ranges::next(begin(), index), end(), std::ranges::next(end(), count));
    traits_type::copy(std::ranges::next(begin(), index), str, count);
    m_data[new_size] = value_type{};  // Ensure null termination
    return *this;
  }
 
  template <std::size_t N2>
  auto insert(size_type index, const basic_inplace_string<N2, value_type, traits_type>& str) -> basic_inplace_string& {
    return insert(index, str.data(), str.size());
  }
 
  auto insert(const_iterator pos, value_type ch) -> iterator { return insert(pos, 1U, ch); }
 
  auto insert(const_iterator pos, size_type count, value_type ch) -> iterator {
    const auto index = std::ranges::distance(cbegin(), pos);
    insert(index, count, ch);
    return std::ranges::next(begin(), index);
  }
 
  template <std::input_iterator InputIt>
  auto insert(const_iterator pos, InputIt first, InputIt last) -> iterator
    requires std::convertible_to<std::iter_value_t<InputIt>, value_type>
  {
    const auto index = std::ranges::distance(cbegin(), pos);
    const auto count = std::ranges::distance(first, last);
    const auto new_size = size() + count;
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::insert: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    std::ranges::copy_backward(std::ranges::next(begin(), index), end(), std::ranges::next(end(), count));
    std::ranges::copy(first, last, std::ranges::next(begin(), index));
    m_data[new_size] = value_type{};  // Ensure null termination
    return std::ranges::next(begin(), index);
  }
 
  template <std::ranges::input_range R>
  constexpr auto insert_range(const_iterator pos, R&& range) -> iterator
    requires std::convertible_to<std::ranges::range_value_t<R>, value_type>
  {
    return insert(pos, std::ranges::begin(range), std::ranges::end(range));
  }
 
  constexpr void erase(size_type index = 0U, size_type count = npos) {
    if (index >= size()) {
      throw std::out_of_range{
          std::format("basic_inplace_string::erase: index (which is {}) >= size (which is {})", index, size())};
    }
    const auto no_of_chars_to_erase = std::ranges::min(count, size() - index);
    const auto new_size = size() - no_of_chars_to_erase;
    std::ranges::copy(std::ranges::next(begin(), index + count), end(), std::ranges::next(begin(), index));
    m_data[new_size] = value_type{};  // Ensure null termination
  }
 
  constexpr void push_back(value_type ch) {
    const auto new_size = size() + 1;
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::push_back: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    m_data[size()] = ch;
    m_data[new_size] = value_type{};  // Ensure null termination
  }
 
  constexpr void pop_back() noexcept { m_data[size() - 1] = value_type{}; }
 
  template <std::size_t N2>
  constexpr void append(const basic_inplace_string<N2, value_type, traits_type>& str) {
    const auto new_size = size() + str.size();
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::append: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    traits_type::copy(end(), str.data(), str.size());
    m_data[new_size] = value_type{};  // Ensure null termination
  }
 
  template <std::size_t N2>
  constexpr auto operator+=(const basic_inplace_string<N2, value_type, traits_type>& str) -> basic_inplace_string& {
    const auto new_size = size() + str.size();
    if (new_size > max_size()) {
      throw std::length_error{std::format(
          "basic_inplace_string::operator+=: new_size (which is {}) > max_size (which is {})", new_size, max_size())};
    }
    traits_type::copy(end(), str.data(), str.size());
    m_data[new_size] = value_type{};  // Ensure null termination
    return *this;
  }
 
  constexpr void resize(size_type count) {
    if (count > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::resize: count (which is {}) > max_size (which is {})", count, max_size())};
    }
    m_data[count] = value_type{};  // Ensure null termination
  }
 
  constexpr void resize(size_type count, value_type ch) {
    if (count > max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::resize: count (which is {}) > max_size (which is {})", count, max_size())};
    }
    if (count > size()) {
      std::ranges::fill_n(end(), count - size(), ch);
    }
    m_data[count] = value_type{};  // Ensure null termination
  }
 
  constexpr void swap(basic_inplace_string& other) noexcept {
    using std::swap;
    swap(m_data, other.m_data);
  }
 
  template <std::size_t N2>
  constexpr auto find(const basic_inplace_string<N2, value_type, traits_type>& str,
                      size_type pos = 0) const noexcept -> size_type {
    return find(str.view(), pos);
  }
 
  constexpr auto find(std::basic_string_view<value_type, traits_type> str,
                      size_type pos = 0) const noexcept -> size_type {
    return view().find(str, pos);
  }
 
  constexpr auto find(const value_type* str, size_type pos, size_type count) const noexcept -> size_type {
    return view().find(str, pos, count);
  }
 
  constexpr auto find(const value_type* str, size_type pos = 0) const noexcept -> size_type {
    return view().find(str, pos);
  }
 
  constexpr auto find(value_type ch, size_type pos = 0) const noexcept -> size_type { return view().find(ch, pos); }
 
  template <std::size_t N2>
  constexpr auto rfind(const basic_inplace_string<N2, value_type, traits_type>& str,
                       size_type pos = npos) const noexcept -> size_type {
    return rfind(str.view(), pos);
  }
 
  constexpr auto rfind(std::basic_string_view<value_type, traits_type> str,
                       size_type pos = npos) const noexcept -> size_type {
    return view().rfind(str, pos);
  }
 
  constexpr auto rfind(const value_type* str, size_type pos, size_type count) const noexcept -> size_type {
    return view().rfind(str, pos, count);
  }
 
  constexpr auto rfind(const value_type* str, size_type pos = npos) const noexcept -> size_type {
    return view().rfind(str, pos);
  }
 
  constexpr auto rfind(value_type ch, size_type pos = npos) const noexcept -> size_type {
    return view().rfind(ch, pos);
  }
 
  template <std::size_t N2>
  constexpr auto find_first_of(const basic_inplace_string<N2, value_type, traits_type>& str,
                               size_type pos = 0) const noexcept -> size_type {
    return find_first_of(str.view(), pos);
  }
 
  constexpr auto find_first_of(std::basic_string_view<value_type, traits_type> str,
                               size_type pos = 0) const noexcept -> size_type {
    return view().find_first_of(str, pos);
  }
 
  constexpr auto find_first_of(const value_type* str, size_type pos = 0) const noexcept -> size_type {
    return view().find_first_of(str, pos);
  }
 
  template <std::size_t N2>
  friend constexpr auto operator+(const basic_inplace_string& lhs,
                                  const basic_inplace_string<N2, value_type, traits_type>& rhs)
      -> basic_inplace_string<N + N2, value_type, traits_type> {
    const auto new_size = lhs.size() + rhs.size();
    basic_inplace_string<N + N2, value_type, traits_type> result;
    traits_type::copy(result.data(), lhs.data(), lhs.size());
    traits_type::copy(std::ranges::next(result.data(), lhs.size()), rhs.data(), rhs.size());
    result[new_size] = value_type{};  // Ensure null termination
    return result;
  }
 
  friend constexpr auto operator==(const basic_inplace_string& lhs, const basic_inplace_string& rhs) noexcept -> bool {
    return std::ranges::equal(lhs.begin(), lhs.end(), rhs.begin());
  }
 
  friend constexpr auto operator==(const basic_inplace_string& lhs,
                                   std::basic_string_view<value_type, traits_type> rhs) noexcept -> bool {
    return std::ranges::equal(lhs.begin(), lhs.end(), rhs.begin());
  }
 
  friend constexpr auto operator==(std::basic_string_view<value_type, traits_type> lhs,
                                   const basic_inplace_string& rhs) noexcept -> bool {
    return rhs == lhs;
  }
 
  friend constexpr auto operator==(const basic_inplace_string& lhs, const value_type* rhs) noexcept -> bool {
    return traits_type::compare(lhs.data(), rhs, traits_type::length(rhs)) == 0;
  }
 
  friend constexpr auto operator==(const value_type* lhs, const basic_inplace_string& rhs) noexcept -> bool {
    return rhs == lhs;
  }
 
  friend constexpr auto operator!=(const basic_inplace_string& lhs, const basic_inplace_string& rhs) noexcept -> bool {
    return !(lhs == rhs);
  }
 
  friend constexpr auto operator!=(const basic_inplace_string& lhs,
                                   std::basic_string_view<value_type, traits_type> rhs) noexcept -> bool {
    return !(lhs == rhs);
  }
 
  friend constexpr auto operator!=(std::basic_string_view<value_type, traits_type> lhs,
                                   const basic_inplace_string& rhs) noexcept -> bool {
    return !(lhs == rhs);
  }
 
  friend constexpr auto operator!=(const basic_inplace_string& lhs, const value_type* rhs) noexcept -> bool {
    return !(lhs == rhs);
  }
 
  friend constexpr auto operator!=(const value_type* lhs, const basic_inplace_string& rhs) noexcept -> bool {
    return !(lhs == rhs);
  }
 
  friend inline auto operator<<(std::basic_ostream<value_type, traits_type>& ostream,
                                const basic_inplace_string& rhs) -> std::basic_ostream<value_type, traits_type>& {
    return ostream << rhs.view();
  }
 
  friend inline auto operator>>(std::basic_istream<value_type, traits_type>& istream,
                                basic_inplace_string& rhs) -> std::basic_istream<value_type, traits_type>& {
    const auto new_size = rhs.size() + istream.rdbuf()->in_avail();
    if (new_size > rhs.max_size()) {
      throw std::length_error{
          std::format("basic_inplace_string::operator>>: new_size (which is {}) > max_size (which is {})", new_size,
                      rhs.max_size())};
    }
    const auto it = std::istreambuf_iterator<value_type, traits_type>{istream};
    const auto end = std::istreambuf_iterator<value_type, traits_type>{};
    std::ranges::copy(it, end, rhs.end());
    rhs[new_size] = value_type{};  // Ensure null termination
    return istream;
  }
};
 
template <typename CharT, std::size_t N>
// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
basic_inplace_string(const CharT (&)[N]) -> basic_inplace_string<N - 1U, CharT>;
 
template <std::size_t N>
using inplace_string = basic_inplace_string<N, char>;
 
template <std::size_t N>
using inplace_wstring = basic_inplace_string<N, wchar_t>;
 
template <std::size_t N>
using inplace_u16string = basic_inplace_string<N, char16_t>;
 
template <std::size_t N>
using inplace_u32string = basic_inplace_string<N, char32_t>;
 
}  // namespace gw
 
namespace std {
 
template <std::size_t N, class CharT, class Traits>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct hash<::gw::basic_inplace_string<N, CharT, Traits>> {
  [[nodiscard]] auto inline operator()(const ::gw::basic_inplace_string<N, CharT, Traits>& str) const noexcept
      -> size_t {
    return hash<basic_string_view<CharT, Traits>>{}(static_cast<basic_string_view<CharT, Traits>>(str));
  }
};
 
template <std::size_t N, class CharT, class Traits>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct formatter<::gw::basic_inplace_string<N, CharT, Traits>, CharT> {
  template <class ParseContext>
  constexpr auto parse(ParseContext& context) const -> ParseContext::iterator {
    return context.begin();
  }
 
  template <class FormatContext>
  constexpr auto format(const ::gw::basic_inplace_string<N, CharT, Traits>& str,
                        FormatContext& context) const -> FormatContext::iterator {
    return ranges::copy(str, context.out()).out;
  }
};
 
}  // namespace std