char_traits.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_STRING_CHAR_TRAITS_HPP
#define TETL_STRING_CHAR_TRAITS_HPP
 
#include <etl/_compare/strong_ordering.hpp>
#include <etl/_cstddef/size_t.hpp>
#include <etl/_cstdint/uint_least_t.hpp>
#include <etl/_cwchar/wint_t.hpp>
#include <etl/_ios/typedefs.hpp>
#include <etl/_strings/cstr.hpp>
 
namespace etl {
 
namespace detail {
 
template <typename CharType, typename IntType, IntType Eof>
struct char_traits_base {
    using char_type           = CharType;
    using int_type            = IntType;
    using off_type            = etl::streamoff;
    using comparison_category = etl::strong_ordering;
 
    static constexpr auto assign(char_type& a, char_type const& b) noexcept -> void { a = b; }
 
    static constexpr auto eq(char_type a, char_type b) noexcept -> bool { return a == b; }
 
    static constexpr auto lt(char_type a, char_type b) noexcept -> bool { return a < b; }
 
    static constexpr auto compare(char_type const* lhs, char_type const* rhs, size_t count) -> int
    {
        if (count == 0) {
            return 0;
        }
 
        for (size_t i = 0; i < count; ++i) {
            if (lhs[i] < rhs[i]) {
                return -1;
            }
            if (lhs[i] > rhs[i]) {
                return 1;
            }
        }
 
        return 0;
    }
 
    static constexpr auto length(char_type const* str) -> size_t { return etl::detail::strlen<char_type, size_t>(str); }
 
    static constexpr auto find(char_type const* str, size_t count, char_type const& token) -> char_type const*
    {
        for (size_t i = 0; i < count; ++i) {
            if (str[i] == token) {
                return &str[i];
            }
        }
 
        return nullptr;
    }
 
    static constexpr auto move(char_type* dest, char_type const* source, size_t count) -> char_type*
    {
        for (size_t i = 0; i < count; ++i) {
            dest[i] = source[i];
        }
        return dest;
    }
 
    static constexpr auto copy(char_type* dest, char_type const* source, size_t count) -> char_type*
    {
        for (size_t i = 0; i < count; ++i) {
            assign(dest[i], source[i]);
        }
        return dest;
    }
 
    static constexpr auto assign(char_type* str, size_t count, char_type token) -> char_type*
    {
        for (size_t i = 0; i < count; ++i) {
            assign(str[i], token);
        }
        return str;
    }
 
    static constexpr auto to_char_type(int_type c) noexcept -> char_type { return static_cast<char_type>(c); }
 
    static constexpr auto to_int_type(char_type c) noexcept -> int_type { return static_cast<int_type>(c); }
 
    static constexpr auto eq_int_type(int_type lhs, int_type rhs) noexcept -> bool
    {
        if (lhs == rhs) {
            return true;
        }
        if (lhs == eof() and rhs == eof()) {
            return true;
        }
        if (lhs == eof() or rhs == eof()) {
            return false;
        }
        return false;
    }
 
    static constexpr auto eof() noexcept -> int_type { return Eof; }
 
    static constexpr auto not_eof(int_type c) noexcept -> int_type { return !eq_int_type(c, eof()) ? c : 0; }
};
 
} // namespace detail

template <typename CharT>
struct char_traits;

template <>
struct char_traits<char> : detail::char_traits_base<char, int, -1> { };

template <>
struct char_traits<wchar_t> : detail::char_traits_base<wchar_t, wint_t, static_cast<wint_t>(WEOF)> { };

template <>
struct char_traits<char8_t> : detail::char_traits_base<char8_t, unsigned, static_cast<unsigned>(-1)> { };

template <>
struct char_traits<char16_t> : detail::char_traits_base<char16_t, uint_least16_t, uint_least16_t(0xFFFF)> { };

template <>
struct char_traits<char32_t> : detail::char_traits_base<char32_t, uint_least32_t, uint_least32_t(0xFFFFFFFF)> { };
 
} // namespace etl
 
#endif // TETL_STRING_CHAR_TRAITS_HPP