native.static_string.ccm

Go to the documentation of this file.

module;
#include <native/attributes.h>
#include <concepts>
#include <cstddef>
#include <functional>
#include <iterator>
#include <ostream>
#include <ranges>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>

 
export module native.static_string;
 
export namespace native {
 
namespace detail {
  template<class T>
  concept static_character = std::same_as<T, char> || std::same_as<T, wchar_t> ||
    std::same_as<T, char8_t> || std::same_as<T, char16_t> || std::same_as<T, char32_t>;
 
  template<class CharT, std::size_t N>
  struct static_string_literal {
    using char_type = CharT;
    static constexpr std::size_t size = N;
    CharT value[N];
    consteval static_string_literal(CharT const (&text)[N]) noexcept {
      for (std::size_t i = 0; i != N; ++i) value[i] = text[i];
    }
  };
}
 

template <typename T, T...xs>
struct reify {
  static constexpr const T value[sizeof...(xs)+1] = {xs..., T() };
};
 
// forward declaration
class static_c_string;

template <
  typename CharT,
  typename Traits = std::char_traits<CharT>
>
class basic_static_string {
  std::basic_string_view<CharT,Traits> view{reify<CharT>::value, 0};
 
public:
  native_inline constexpr
  basic_static_string(std::basic_string_view<CharT,Traits> value) noexcept
  : view(value) {}

  friend class static_c_string;
  using traits_type = Traits;
  using value_type = CharT;
  using pointer = CharT *;
  using const_pointer = CharT const *;
  using reference = CharT &;
  using const_reference = CharT const &;
  using const_iterator = CharT const *;
  using iterator = const_iterator;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  using reverse_iterator = const_reverse_iterator;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;


  template <CharT...xs>
  consteval explicit basic_static_string(std::integer_sequence<CharT,xs...>) noexcept
  : view(reify<CharT,xs...>::value,sizeof...(xs)) {}

  native_inline constexpr
  basic_static_string() noexcept = default;

  native_inline constexpr
  basic_static_string(basic_static_string const &) noexcept = default;

  native_inline constexpr
  basic_static_string(basic_static_string &&) noexcept = default;


  native_reinitializes native_inline constexpr
  basic_static_string & operator = (basic_static_string const & that) noexcept = default;

  native_reinitializes native_inline constexpr
  basic_static_string & operator = (basic_static_string && that) noexcept = default;
 


  native_nodiscard native_inline native_pure constexpr
  operator CharT const * () const noexcept {
    return view.data(); // an extra invariant that its null terminated is maintained
  }

  native_nodiscard native_inline native_pure constexpr
  operator std::basic_string_view<CharT,Traits>() const noexcept {
    return view;
  }

  native_nodiscard native_inline constexpr
  operator std::basic_string<CharT,Traits>() const {
    return std::basic_string<CharT,Traits>(view);
  }


  native_nodiscard native_inline native_pure constexpr
  CharT const & operator [](size_type i) const noexcept { return view[i]; }

  native_nodiscard native_inline constexpr
  CharT const & at(size_type i) const { return view.at(i); }

  native_nodiscard native_inline native_pure constexpr
  const_reference front() const noexcept { return view.front(); }

  native_nodiscard native_inline native_pure constexpr
  const_reference back() const noexcept { return view.back(); }

  native_nodiscard native_inline native_pure constexpr
  const_pointer data() const noexcept { return view.data(); }


  native_nodiscard native_inline native_pure constexpr
  size_type size() const noexcept { return view.size(); }

  native_nodiscard native_inline native_pure constexpr
  size_type length() const noexcept { return view.length(); }

  native_nodiscard native_inline native_pure constexpr
  size_type max_size() const noexcept { return view.max_size(); }

  native_nodiscard native_inline native_pure constexpr
  bool empty() const noexcept { return view.empty(); }

  native_nodiscard native_inline native_pure
  explicit constexpr operator bool () const noexcept { return !view.empty(); }


  native_nodiscard native_inline native_artificial friend constexpr
  bool operator == (basic_static_string self, basic_static_string that) noexcept {
    if constexpr (std::is_same_v<Traits,std::char_traits<CharT>> && detail::static_character<CharT>) {
      return self.view.data() == that.view.data();
    } else {
      return (self.view.data() == that.view.data()) || (self.view == that.view); // fallback required
    }
  }

  native_nodiscard native_inline native_artificial friend constexpr
  bool operator != (basic_static_string self, basic_static_string that) noexcept {
    if constexpr (std::is_same_v<Traits,std::char_traits<CharT>> && detail::static_character<CharT>) {
      return self.view.data() != that.view.data();
    } else {
      return (self.view.data() != that.view.data()) && (self.view != that.view);
    }
  }


  friend constexpr
  std::basic_ostream<CharT, Traits> & operator<<(std::basic_ostream<CharT, Traits>& os, basic_static_string<CharT, Traits> v) {
    return os << v.view;
  }
 


  native_nodiscard native_inline native_pure native_artificial constexpr
  auto begin() const noexcept { return view.data(); }

  native_nodiscard native_inline native_pure constexpr
  auto end() const noexcept { return view.data() + view.size(); }

  native_nodiscard native_inline native_pure native_artificial constexpr
  auto cbegin() const noexcept { return begin(); }

  native_nodiscard native_inline native_pure constexpr
  auto cend() const noexcept { return end(); }

  native_nodiscard native_inline native_pure constexpr
  auto rbegin() const noexcept { return const_reverse_iterator(end()); }

  native_nodiscard native_inline native_pure constexpr
  auto rend() const noexcept { return const_reverse_iterator(begin()); }

  native_nodiscard native_inline native_pure constexpr
  auto crbegin() const noexcept { return rbegin(); }

  native_nodiscard native_inline native_pure constexpr
  auto crend() const noexcept { return rend(); }


  native_inline constexpr friend
  void swap(basic_static_string & x, basic_static_string & y) noexcept {
    using std::swap;
    swap(x.view,y.view);
  }
 
  static constexpr size_type npos = std::basic_string_view<CharT,Traits>::npos;
};

template <typename CharT, CharT...xs>
basic_static_string(std::integer_sequence<CharT,xs...>) -> basic_static_string<CharT,std::char_traits<CharT>>;
 
using static_string = basic_static_string<char>;
using static_wstring = basic_static_string<wchar_t>;
using static_u8string = basic_static_string<char8_t>;
using static_u16string = basic_static_string<char16_t>;
using static_u32string = basic_static_string<char32_t>;

class static_c_string {
  char const * p = reify<char>::value;
public:
 
  using traits_type = std::char_traits<char>;
  using value_type = char;
  using pointer = char *;
  using const_pointer = char const *;
  using reference = char &;
  using const_reference = char const &;
  using const_iterator = char const *;
  using iterator = const_iterator;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  using reverse_iterator = const_reverse_iterator;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;


  native_inline constexpr
  static_c_string() noexcept = default;

  native_inline constexpr
  static_c_string(static_c_string const &) noexcept = default;

  native_inline constexpr
  static_c_string(static_c_string &&) noexcept = default;

  native_inline constexpr
  static_c_string(static_string x) noexcept : p(x.data()) {}


  native_reinitializes native_inline constexpr
  static_c_string & operator = (static_c_string const &) noexcept = default;

  native_reinitializes native_inline constexpr
  static_c_string & operator = (static_c_string &&) noexcept = default;


  native_nodiscard native_inline native_pure native_artificial constexpr
  operator const char * () const noexcept { return p; }

  native_nodiscard native_inline native_pure native_artificial constexpr
  operator static_string () const noexcept { return static_string(std::string_view(p)); }

  native_nodiscard native_inline native_pure native_artificial constexpr
  const char * data() const noexcept { return p; }


  native_nodiscard native_inline native_pure native_artificial constexpr friend
  bool operator == (static_c_string x, static_c_string y) noexcept { return x.p == y.p; }

  native_nodiscard native_inline native_pure native_artificial constexpr friend
  bool operator != (static_c_string x, static_c_string y) noexcept { return x.p != y.p; }


  native_nodiscard native_inline native_pure native_artificial constexpr
  auto begin() const noexcept { return p; }

  native_nodiscard native_inline native_pure constexpr
  auto end() const noexcept { return p + std::char_traits<char>::length(p); }

  native_nodiscard native_inline native_pure native_artificial constexpr
  auto cbegin() const noexcept { return p; }

  native_nodiscard native_inline native_pure constexpr
  auto cend() const noexcept { return p + std::char_traits<char>::length(p); }

  native_nodiscard native_inline native_pure constexpr
  auto rbegin() const noexcept { return std::reverse_iterator<const char *>(end()); }

  native_nodiscard native_inline native_pure constexpr
  auto rend() const noexcept { return std::reverse_iterator<const char *>(begin()); }

  native_nodiscard native_inline native_pure constexpr
  auto crbegin() const noexcept { return std::reverse_iterator<const char *>(end()); }

  native_nodiscard native_inline native_pure constexpr
  auto crend() const noexcept { return std::reverse_iterator<const char *>(begin()); }


  native_inline friend
  void swap(static_c_string & x, static_c_string & y) noexcept {
    using std::swap;
    swap(x.p,y.p);
  }
};

// Structural string-literal NTTPs are standard C++; no GNU pack extension.
template <detail::static_string_literal Text>
consteval auto operator""_ss() noexcept {
  using CharT = typename decltype(Text)::char_type;
  return []<std::size_t... I>(std::index_sequence<I...>) {
    return basic_static_string<CharT>(std::integer_sequence<CharT, Text.value[I]...>{});
  }(std::make_index_sequence<Text.size - 1>{});
}

template <detail::static_string_literal Text>
  requires std::same_as<typename decltype(Text)::char_type, char>
consteval static_c_string operator""_scs() noexcept {
  return static_c_string(operator""_ss<Text>());
}
 
} // namespace native
 
export namespace std {
  using ::std::hash;
  template <typename CharT, typename Traits>
  struct hash<::native::basic_static_string<CharT,Traits>> {
    size_t operator()(::native::basic_static_string<CharT,Traits> const & s) const noexcept {
      return reinterpret_cast<size_t>(s.data());
    }
  };
  template <>
  struct hash<::native::static_c_string> {
    size_t operator()(::native::static_c_string s) const noexcept {
      return reinterpret_cast<size_t>(s.data());
    }
  };
  namespace ranges {

    template< class CharT, class Traits >
    inline constexpr bool enable_borrowed_range<::native::basic_static_string<CharT, Traits>> = true;
 
    template< class CharT, class Traits >
    inline constexpr bool enable_view<::native::basic_static_string<CharT, Traits>> = true;
 
    template <>
    inline constexpr bool enable_borrowed_range<::native::static_c_string> = true;
 
    template <>
    inline constexpr bool enable_view<::native::static_c_string> = true;
  }
}  // namespace std