string_literal

// D3933 - A compile-time string library template with UDL operator templates
// N4236 - A compile-time string library template with UDL operator templates

namespace std
{

template<typename _CharT, _CharT... _Chars>
  class basic_string_literal;

inline namespace literals {
template<typename _CharT, _CharT... _Chars>
  constexpr basic_string_literal<_CharT, _Chars...> operator""S();
}

template<typename _CharT, _CharT... _Chars>
  class basic_string_literal
  {
    friend /*constexpr*/ basic_string_literal operator""S<_CharT, _Chars...>();

  private:

    static constexpr const _CharT _M_data[]{_Chars..., _CharT{}};

  public:

    constexpr basic_string_literal() = default;

    using value_type = _CharT;
    using size_type = std::size_t;
    using difference_type = std::size_t;

    using tail_type = basic_string_literal<_CharT>;

    // Size-related functions
    constexpr size_type size() const
    { return sizeof...(_Chars); }
    constexpr size_type length() const
    { return sizeof...(_Chars); }
    constexpr bool empty() const
    { return sizeof...(_Chars) == 0; }

    // Element accessor functions
    constexpr _CharT
    operator[](size_type pos) const
    { return _M_data[pos]; }

    template<size_type _Idx>
      constexpr _CharT
      at() const
      { return _M_data[_Idx]; }

    constexpr _CharT
    at(size_type pos) const
    { return _M_data[pos]; }

    constexpr _CharT
    back() const
    { return _M_data[this->size() - 1]; }

    constexpr _CharT
    front() const
    { return _M_data[0]; }

    // Search functions
    template<_CharT... _OtherChars>
    constexpr size_type find(const basic_string_literal<_CharT, _OtherChars...>& str, size_type pos = 0) const;
    constexpr size_type find(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type find(const _CharT* s, size_type pos = 0) const;
    constexpr size_type find(_CharT ch, size_type pos = 0) const;

    template<_CharT... _OtherChars>
    constexpr size_type rfind(const basic_string_literal<_CharT, _OtherChars...>& str, std::size_t pos = sizeof...(_Chars)) const;
    constexpr size_type rfind(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type rfind(const _CharT* s, size_type pos = sizeof...(_Chars)) const;
    constexpr size_type rfind(_CharT ch, size_t pos = sizeof...(_Chars)) const;

    template<_CharT... _OtherChars>
    constexpr size_type find_first_of(const basic_string_literal<_CharT, _OtherChars...>& str, size_type pos = 0) const;
    constexpr size_type find_first_of(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type find_first_of(const _CharT* s, size_type pos = 0) const;
    constexpr size_type find_first_of(_CharT ch, size_type pos = 0) const;

    template<_CharT... _OtherChars>
    constexpr size_type find_first_not_of(const basic_string_literal<_CharT, _OtherChars...>& str, size_type pos = 0) const;
    constexpr size_type find_first_not_of(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type find_first_not_of(const _CharT* s, size_type pos = 0) const;
    constexpr size_type find_first_not_of(_CharT ch, size_type pos = 0) const;

    template<_CharT... _OtherChars>
    constexpr size_type find_last_of(const basic_string_literal<_CharT, _OtherChars...>& str, size_type pos = sizeof...(_Chars)) const;
    constexpr size_type find_last_of(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type find_last_of(const _CharT* s, size_type pos = sizeof...(_Chars)) const;
    constexpr size_type find_last_of(_CharT ch, size_t pos = sizeof...(_Chars)) const;

    template<_CharT... _OtherChars>
    constexpr size_type find_last_not_of(const basic_string_literal<_CharT, _OtherChars...>& str, size_type pos = sizeof...(_Chars)) const;
    constexpr size_type find_last_not_of(const _CharT* s, size_type pos, size_type count) const;
    constexpr size_type find_last_not_of(const _CharT* s, size_type pos = sizeof...(_Chars)) const;
    constexpr size_type find_last_not_of(_CharT ch, size_t pos = sizeof...(_Chars)) const;

    // Comparison functions
    template<_CharT... _OtherChars>
    constexpr int compare(const basic_string_literal<_CharT, _OtherChars...> & other) const;

    template<typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT>>
      constexpr int compare(const basic_string<_CharT, _Traits, _Alloc>& str) const;
    template<typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT>>
      constexpr int compare(size_type pos1, size_type count1,
			    const basic_string<_CharT, _Traits, _Alloc>& str) const;
    template<typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT>>
      constexpr int compare(size_type pos1, size_type count1,
			    const basic_string<_CharT, _Traits, _Alloc>& str,
                            size_type pos2, size_type count2) const;
    constexpr int compare(const _CharT* s) const;
    constexpr int compare(size_type pos1, size_type count1, const _CharT* s) const;
    constexpr int compare(size_type pos1, size_type count1,
                          const _CharT* s, size_type count2) const;

    // Conversion functions
    constexpr const char *
    c_str() const
    { return _M_data; }

    constexpr const char *
    data() const
    { return _M_data; }

    std::string
    to_string() const;

    constexpr operator const char*() const;

    constexpr long long
    to_number() const;
  };

template<typename _CharT>
  class basic_string_literal<_CharT>
  {

    friend /*constexpr*/ basic_string_literal operator""S<_CharT>();

  private:

    static constexpr const _CharT _M_data[]{_CharT{}};

  public:

    constexpr basic_string_literal() = default;

    using value_type = _CharT;
    using size_type = std::size_t;
    using difference_type = std::size_t;

    using tail_type = basic_string_literal<_CharT>;

    constexpr size_type
    size() const
    { return 1; }

    constexpr size_type
    length() const
    { return 1; }

    constexpr bool
    empty() const
    { return false; }

    template<_CharT... _OtherChars>
      constexpr int compare(const basic_string_literal<_CharT, _OtherChars...>& other) const;
    constexpr int compare(const basic_string<_CharT>& str) const;
    constexpr int compare(std::size_t pos1, std::size_t count1, const basic_string<_CharT>& str) const;
    constexpr int compare(std::size_t pos1, std::size_t count1, const basic_string<_CharT>& str, std::size_t pos2, std::size_t count2) const;
    constexpr int compare(const _CharT* s) const;
    constexpr int compare(std::size_t pos1, std::size_t count1, const _CharT* s) const;
    constexpr int compare(std::size_t pos1, std::size_t count1, const _CharT* s, std::size_t count2) const;

    constexpr const char * c_str() const;
    constexpr const char * data() const;
    std::string to_string() const;
    constexpr size_type to_number() const;
    constexpr operator const char*() const;
    operator std::string() const;
  };

inline namespace literals
{
template<typename _CharT, _CharT... _Chars>
  constexpr basic_string_literal<_CharT, _Chars...>
  operator""S()
  { return basic_string_literal<_CharT, _Chars...>(); }
}

// Concatenation

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  inline constexpr auto
  operator+(const basic_string_literal<_CharT, _LeftChars...>& lhs,
            const basic_string_literal<_CharT, _RightChars...>& rhs)
  -> basic_string_literal<_CharT, _LeftChars..., _RightChars...>;

// Relational operators

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator==(const basic_string_literal<_CharT, _LeftChars...>& lhs,
             const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator!=(const basic_string_literal<_CharT, _LeftChars...>& lhs,
             const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator<(const basic_string_literal<_CharT, _LeftChars...>& lhs,
            const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator<=(const basic_string_literal<_CharT, _LeftChars...>& lhs,
             const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator>(const basic_string_literal<_CharT, _LeftChars...>& lhs,
            const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _LeftChars, _CharT... _RightChars>
  constexpr bool
  operator>=(const basic_string_literal<_CharT, _LeftChars...>& lhs,
             const basic_string_literal<_CharT, _RightChars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator==(const _CharT* lhs,
	     const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator==(const basic_string_literal<_CharT, _Chars...>& lhs,
	     const _CharT* rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator!=(const _CharT* lhs,
	     const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator!=(const basic_string_literal<_CharT, _Chars...>& lhs,
	     const _CharT* rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator<(const _CharT* lhs,
	    const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator<(const basic_string_literal<_CharT, _Chars...>& lhs,
	    const _CharT* rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator<=(const _CharT* lhs,
	     const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator<=(const basic_string_literal<_CharT, _Chars...>& lhs,
	     const _CharT* rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator>(const _CharT* lhs,
	    const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator>(const basic_string_literal<_CharT, _Chars...>& lhs,
	    const _CharT* rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator>=(const _CharT* lhs,
	     const basic_string_literal<_CharT, _Chars...>& rhs);

template<typename _CharT, _CharT... _Chars>
  constexpr bool
  operator>=(const basic_string_literal<_CharT, _Chars...>& lhs,
	     const _CharT* rhs);

// Stream inseration operator

template<typename _CharT, _CharT... _Chars>
  inline std::ostream&
  operator<<(std::ostream& os,
             const basic_string_literal<_CharT, _Chars...>& str);

// Literal operator

template <typename _CharT, _CharT... _Chars>
  inline constexpr basic_string_literal<_CharT, _Chars...>
  operator""S();

template<char... _Chars>
  using string_literal = basic_string_literal<char, _Chars...>;
template<char16_t... _Chars>
  using u16string_literal = basic_string_literal<char16_t, _Chars...>;
template<char32_t... _Chars>
  using u32string_literal = basic_string_literal<char32_t, _Chars...>;
template<wchar_t... _Chars>
  using wstring_literal = basic_string_literal<wchar_t, _Chars...>;

} // namespace std