string.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_STRING_HPP__
#define NEFORCE_CORE_STRING_STRING_HPP__

 
#include "NeForce/core/string/basic_string.hpp"
NEFORCE_BEGIN_NAMESPACE__


using string = basic_string<char>;

using wstring = basic_string<wchar_t>;
 
#ifdef NEFORCE_STANDARD_20
using u8string = basic_string<char8_t>;
#endif

using u16string = basic_string<char16_t>;

using u32string = basic_string<char32_t>;
 // String
 
NEFORCE_BEGIN_LITERALS__


NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string operator""_s(const char* str, size_t len) { return {str, len}; }

NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 wstring operator""_s(const wchar_t* str, size_t len) { return {str, len}; }
 
#ifdef NEFORCE_STANDARD_20
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 u8string operator""_s(const char8_t* str, size_t len) { return {str, len}; }
#endif

NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 u16string operator""_s(const char16_t* str, size_t len) { return {str, len}; }

NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 u32string operator""_s(const char32_t* str, size_t len) { return {str, len}; }
 // UserLiterals
 
NEFORCE_END_LITERALS__


NEFORCE_CONSTEXPR20 string escape(const string_view str) {
    string result;
    result.reserve(str.length() + str.length() / 4);
 
    for (const char c: str) {
        switch (c) {
            case '\"': {
                result += "\\\"";
                break;
            }
            case '\'': {
                result += "\\\'";
                break;
            }
            case '\\': {
                result += "\\\\";
                break;
            }
            case '\b': {
                result += "\\b";
                break;
            }
            case '\f': {
                result += "\\f";
                break;
            }
            case '\n': {
                result += "\\n";
                break;
            }
            case '\r': {
                result += "\\r";
                break;
            }
            case '\t': {
                result += "\\t";
                break;
            }
            case '\v': {
                result += "\\v";
                break;
            }
            default: {
                if (static_cast<byte_t>(c) < 0x20) {
                    result += "\\u";
                    constexpr char hex[] = "0123456789abcdef";
                    result += "00";
                    result += hex[(c >> 4) & 0x0F];
                    result += hex[c & 0x0F];
                } else {
                    result += c;
                }
                break;
            }
        }
    }
    return result;
}

NEFORCE_CONSTEXPR20 string escape(const string& str) { return escape(str.view()); }

NEFORCE_CONSTEXPR20 string escape(const char* str) { return escape(string_view{str}); }

template <typename CharT>
NEFORCE_CONSTEXPR20 bool getline(const basic_string_view<CharT> data, size_t& pos, basic_string<CharT>& str,
                                 CharT delim = static_cast<CharT>('\n')) {
    str.clear();
    bool has_read = false;
    // NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
    while (pos < data.size()) {
        has_read = true;
        const CharT c = data[pos++];
        if (c == delim) {
            break;
        }
        str.push_back(c);
    }
    return has_read;
}

template <typename CharT>
NEFORCE_CONSTEXPR20 bool getline(const basic_string<CharT>& data, size_t& pos, basic_string<CharT>& str,
                                 CharT delim = static_cast<CharT>('\n')) {
    str.clear();
    bool has_read = false;
    // NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
    while (pos < data.size()) {
        has_read = true;
        const CharT c = data[pos++];
        if (c == delim) {
            break;
        }
        str.push_back(c);
    }
    return has_read;
}

template <typename CharT, typename Pred>
NEFORCE_CONSTEXPR20 bool getline(
        const basic_string_view<CharT> data, size_t& pos, basic_string<CharT>& str,
        Pred split = [](const CharT c) { return c == static_cast<CharT>('\n'); }) {
    str.clear();
    bool has_read = false;
    // NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
    while (pos < data.size()) {
        has_read = true;
        const CharT c = data[pos++];
        if (split(c)) {
            break;
        }
        str.push_back(c);
    }
    return has_read;
}

template <typename CharT, typename Pred>
NEFORCE_CONSTEXPR20 bool getline(
        const basic_string<CharT>& data, size_t& pos, basic_string<CharT>& str,
        Pred split = [](const CharT c) { return c == static_cast<CharT>('\n'); }) {
    str.clear();
    bool has_read = false;
    // NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
    while (pos < data.size()) {
        has_read = true;
        const CharT c = data[pos++];
        if (split(c)) {
            break;
        }
        str.push_back(c);
    }
    return has_read;
}

NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string address_string(const void* p) {
    if (p == nullptr) {
        return {"nullptr"};
    }
 
#ifdef NEFORCE_ARCH_BITS_64
    constexpr uintptr_t address_mask = 0xF000000000000000ULL;
    constexpr int address_shift = 60;
#else
    constexpr uintptr_t address_mask = 0xF0000000UL;
    constexpr int address_shift = 28;
#endif
    constexpr char hex_digits[] = "0123456789abcdef";
    constexpr size_t hex_digit_count = sizeof(void*) * 2;
 
    const auto addr_val = reinterpret_cast<uintptr_t>(p);
    uintptr_t mask = address_mask;
    int shift = address_shift;
 
    string result{"0x"};
    result.reserve(2 + hex_digit_count);
 
    for (size_t i = 0; i < hex_digit_count; ++i) {
        const auto digit = static_cast<byte_t>((addr_val & mask) >> shift);
        result += hex_digits[digit];
        mask >>= 4;
        shift -= 4;
    }
    return result;
}
 // String
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_STRING_HPP__