memory.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_MEMORY_HPP__
#define NEFORCE_CORE_MEMORY_MEMORY_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_CONSTEXPR14 void* memory_copy(void* NEFORCE_RESTRICT dest, const void* NEFORCE_RESTRICT src,
                                      size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    if (count == 0) {
        return dest;
    }
 
    void* res = dest;
    auto* dest_v = static_cast<volatile byte_t*>(dest);
    const auto* src_v = static_cast<const volatile byte_t*>(src);
    while (count-- != 0U) {
        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign)
        *dest_v = *src_v;
        dest_v++;
        src_v++;
    }
    return res;
}

template <typename T>
NEFORCE_CONSTEXPR14 void* memory_copy(T* NEFORCE_RESTRICT dest, const T* NEFORCE_RESTRICT src) noexcept {
    return _NEFORCE memory_copy(dest, src, sizeof(T));
}

NEFORCE_CONSTEXPR14 void* memory_copy_offset(void* NEFORCE_RESTRICT dest, const void* NEFORCE_RESTRICT src,
                                             size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    auto* dest_v = static_cast<volatile byte_t*>(dest);
    const auto* src_v = static_cast<const volatile byte_t*>(src);
    while (count-- != 0U) {
        *dest_v = *src_v;
        dest_v++;
        src_v++;
    }
    return (void*) dest_v;
}

NEFORCE_CONSTEXPR14 void* memory_copy_until(void* dest, const void* src, const byte_t value, size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    auto* dest_v = static_cast<volatile byte_t*>(dest);
    const auto* src_v = static_cast<const volatile byte_t*>(src);
 
    while (count-- != 0U) {
        const byte_t current = *src_v;
        *dest_v = current;
        if (current == value) {
            return (void*) (++dest_v);
        }
        dest_v++;
        src_v++;
    }
    return nullptr;
}

NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 int memory_compare(const void* lhs, const void* rhs, size_t count) noexcept {
    if (lhs == nullptr && rhs == nullptr) {
        return 0;
    }
    if (lhs == nullptr) {
        return -1;
    }
    if (rhs == nullptr) {
        return 1;
    }
 
    while (count-- != 0U) {
        if (*static_cast<const byte_t*>(lhs) != *static_cast<const byte_t*>(rhs)) {
            return *static_cast<const byte_t*>(lhs) - *static_cast<const byte_t*>(rhs);
        }
        lhs = static_cast<const byte_t*>(lhs) + 1;
        rhs = static_cast<const byte_t*>(rhs) + 1;
    }
    return 0;
}

template <typename T>
NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 int memory_compare(const T& lhs, const T& rhs) noexcept {
    return _NEFORCE memory_compare(&lhs, &rhs, sizeof(T));
}

NEFORCE_CONSTEXPR14 void* memory_move(void* dest, const void* src, size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    void* res = dest;
    auto* dest_v = static_cast<volatile byte_t*>(dest);
    const auto* src_v = static_cast<const volatile byte_t*>(src);
    if (dest_v < src_v) {
        while (count-- != 0U) {
            *dest_v = *src_v;
            dest_v = dest_v + 1;
            src_v = src_v + 1;
        }
    } else if (dest_v > src_v) {
        while (count-- != 0U) {
            *(dest_v + count) = *(src_v + count);
        }
    }
    return res;
}

NEFORCE_CONSTEXPR14 void* memory_set(void* dest, const byte_t value, size_t count) noexcept {
    if (dest == nullptr) {
        return nullptr;
    }
 
    void* ret = static_cast<byte_t*>(dest);
    auto* dest_v = static_cast<volatile byte_t*>(dest);
    while (count-- != 0U) {
        *dest_v = value;
        dest_v = dest_v + 1;
    }
    return ret;
}

NEFORCE_CONSTEXPR14 void memory_zero(void* dest, const size_t count) noexcept {
    if (dest == nullptr) {
        return;
    }
 
    auto* const dest_v = static_cast<volatile byte_t*>(dest);
    for (size_t i = 0; i < count; ++i) {
        dest_v[i] = static_cast<byte_t>(0);
    }
}

template <typename T>
NEFORCE_CONSTEXPR14 void memory_zero(T* dest) noexcept {
    _NEFORCE memory_zero(dest, sizeof(T));
}

NEFORCE_PURE_FUNCTION NEFORCE_CONSTEXPR14 const void* memory_find(const void* dest, const byte_t value,
                                                                  size_t count) noexcept {
    if (dest == nullptr) {
        return nullptr;
    }
    const auto* p = static_cast<const byte_t*>(dest);
    while (count-- != 0U) {
        if (*p == value) {
            return p;
        }
        p++;
    }
    return nullptr;
}

NEFORCE_CONSTEXPR14 const void* memory_find_pattern(const void* data, const size_t data_len, const void* pattern,
                                                    const size_t pattern_len) noexcept {
    if (data == nullptr || pattern == nullptr || data_len == 0 || pattern_len == 0 || pattern_len > data_len) {
        return nullptr;
    }
 
    const auto* const data_ptr = static_cast<const byte_t*>(data);
    const auto* const pattern_ptr = static_cast<const byte_t*>(pattern);
    const size_t last_possible = data_len - pattern_len + 1;
 
    for (size_t i = 0; i < last_possible; ++i) {
        if (data_ptr[i] == pattern_ptr[0]) {
            bool match = true;
            for (size_t j = 1; j < pattern_len; ++j) {
                if (data_ptr[i + j] != pattern_ptr[j]) {
                    match = false;
                    break;
                }
            }
            if (match) {
                return data_ptr + i;
            }
        }
    }
    return nullptr;
}

template <typename To, typename From>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 To memory_cast(const From& value) noexcept {
    static_assert(sizeof(To) == sizeof(From), "types must have the same size");
    static_assert(is_trivially_copyable_v<To>, "To type must be trivially copyable");
    static_assert(is_trivially_copyable_v<From>, "From type must be trivially copyable");
 
#ifdef NEFORCE_STANDARD_20
    return __builtin_bit_cast(To, value);
#else
    static_assert(is_default_constructible_v<To>, "To type must be default constructible");
 
    To result{};
    _NEFORCE memory_copy(&result, &value, sizeof(To));
    return result;
#endif
}
 // MemoryFunctions


template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 CharT to_lowercase(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character type is necessary");
    using UT = make_unsigned_t<CharT>;
    const auto uc = static_cast<UT>(c);
    if (uc >= static_cast<UT>('A') && uc <= static_cast<UT>('Z')) {
        return static_cast<CharT>(uc | 0x20);
    }
    return c;
}

template <typename CharT>
NEFORCE_CONST_FUNCTION NEFORCE_CONSTEXPR14 CharT to_uppercase(const CharT c) noexcept {
    static_assert(is_character_v<CharT>, "character type is necessary");
    using UT = make_unsigned_t<CharT>;
    const auto uc = static_cast<UT>(c);
    if (uc >= static_cast<UT>('a') && uc <= static_cast<UT>('z')) {
        return static_cast<CharT>(uc & 0xDF);
    }
    return c;
}
 // CharCaseConversion


template <typename CharT>
constexpr CharT* string_copy(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    CharT* ret = dest;
    while (*src != static_cast<CharT>(0)) {
        *dest = *src;
        ++dest;
        ++src;
    }
    *dest = *src;
    return ret;
}

template <typename CharT>
constexpr CharT* string_copy(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src,
                             const size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    CharT* ret = dest;
    size_t i = 0;
    while (i < count && *src != static_cast<CharT>(0)) {
        *dest = *src;
        ++dest;
        ++src;
        i++;
    }
 
    while (i < count) {
        *dest = static_cast<CharT>(0);
        ++dest;
        i++;
    }
    return ret;
}

template <typename CharT>
constexpr CharT* string_copy_offset(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    while (*src != static_cast<CharT>(0)) {
        *dest = *src;
        ++dest;
        ++src;
    }
    *dest = *src;
    return dest - 1;
}

template <typename CharT>
constexpr CharT* string_copy_offset(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src,
                                    const size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    size_t i = 0;
    while (i < count && *src != static_cast<CharT>(0)) {
        *dest = *src;
        ++dest;
        ++src;
        i++;
    }
 
    while (i < count) {
        *dest = static_cast<CharT>(0);
        ++dest;
        i++;
    }
    return dest;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr int string_compare(const CharT* dest, const CharT* src) noexcept {
    if (dest == nullptr && src == nullptr) {
        return 0;
    }
    if (dest == nullptr) {
        return -1;
    }
    if (src == nullptr) {
        return 1;
    }
 
    while (*dest == *src) {
        if (*dest == static_cast<CharT>(0)) {
            return 0;
        }
        ++dest;
        ++src;
    }
    if (*dest > *src) {
        return 1;
    }
    return -1;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr int string_compare(const CharT* dest, const CharT* src, const size_t count) noexcept {
    if (dest == nullptr && src == nullptr) {
        return 0;
    }
    if (dest == nullptr) {
        return -1;
    }
    if (src == nullptr) {
        return 1;
    }
 
    if (count == 0) {
        return 0;
    }
 
    size_t i = 0;
    while (i < count) {
        if (dest[i] != src[i]) {
            if (dest[i] == static_cast<CharT>(0) || src[i] == static_cast<CharT>(0)) {
                return 0;
            }
            return dest[i] < src[i] ? -1 : 1;
        }
        if (dest[i] == static_cast<CharT>(0)) {
            return 0;
        }
        ++i;
    }
    return 0;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr int string_compare_ignore_case(const CharT* s1, const CharT* s2) noexcept {
    if (s1 == nullptr && s2 == nullptr) {
        return 0;
    }
    if (s1 == nullptr) {
        return -1;
    }
    if (s2 == nullptr) {
        return 1;
    }
 
    while (*s1 && *s2) {
        const CharT c1 = _NEFORCE to_lowercase(*s1);
        const CharT c2 = _NEFORCE to_lowercase(*s2);
        if (c1 < c2) {
            return -1;
        }
        if (c1 > c2) {
            return 1;
        }
        ++s1;
        ++s2;
    }
    return *s1 == *s2 ? 0 : *s1 < *s2 ? -1 : 1;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr int string_compare_ignore_case(const CharT* s1, const CharT* s2,
                                                               const size_t count) noexcept {
    if ((s1 == nullptr && s2 == nullptr) || count == 0) {
        return 0;
    }
    if (s1 == nullptr) {
        return -1;
    }
    if (s2 == nullptr) {
        return 1;
    }
 
    size_t i = 0;
    while (*s1 && *s2 && i < count - 1) {
        const CharT c1 = _NEFORCE to_lowercase(*s1);
        const CharT c2 = _NEFORCE to_lowercase(*s2);
        if (c1 < c2) {
            return -1;
        }
        if (c1 > c2) {
            return 1;
        }
        ++s1;
        ++s2;
        ++i;
    }
    if (i == count - 1) {
        return 0;
    }
 
    const CharT c1 = _NEFORCE to_lowercase(*s1);
    const CharT c2 = _NEFORCE to_lowercase(*s2);
    return c1 < c2 ? -1 : c1 > c2 ? 1 : 0;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr size_t string_length(const CharT* str) noexcept {
    static_assert(is_character_v<CharT>, "CharT must be a character");
    if (str == nullptr) {
        return 0;
    }
    const CharT* p = str;
    while (*p != static_cast<CharT>(0)) {
        ++p;
    }
    return static_cast<size_t>(p - str);
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr size_t string_length(const CharT* str, const size_t max_len) noexcept {
    const CharT* p = str;
    ptrdiff_t len = 0;
    while (*p != static_cast<CharT>(0) && len < max_len) {
        ++p;
        ++len;
    }
    return len;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr const CharT* string_find(const CharT* str, const CharT chr) noexcept {
    if (str == nullptr) {
        return nullptr;
    }
    while (*str != static_cast<CharT>(0)) {
        if (*str == chr) {
            return str;
        }
        ++str;
    }
    if (*str == chr) {
        return str;
    }
    return nullptr;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr const CharT* string_find(const CharT* str, const CharT chr,
                                                         const size_t count) noexcept {
    if (str == nullptr || count == 0) {
        return nullptr;
    }
 
    for (size_t i = 0; i < count; ++i) {
        if (str[i] == chr) {
            return str + i;
        }
        if (str[i] == static_cast<CharT>(0)) {
            break;
        }
    }
    return nullptr;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr const CharT* string_find_last(const CharT* str, const CharT chr) noexcept {
    if (str == nullptr) {
        return nullptr;
    }
    const CharT* last = nullptr;
 
    while (*str != static_cast<CharT>(0)) {
        if (*str == chr) {
            last = str;
        }
        ++str;
    }
    return last;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr CharT* string_find_any(CharT* str, const CharT* accept) noexcept {
    if (str == nullptr || *str == static_cast<CharT>(0) || accept == nullptr || *accept == static_cast<CharT>(0)) {
        return nullptr;
    }
 
    while (*str != static_cast<CharT>(0)) {
        const CharT* a = accept;
        while (*a != static_cast<CharT>(0)) {
            if (*str == *a) {
                return str;
            }
            ++a;
        }
        ++str;
    }
    return nullptr;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr const CharT* string_find_pattern(const CharT* dest, const CharT* src) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    const CharT* cur = dest;
    while (*cur) {
        const CharT* str1 = cur;
        const CharT* str2 = src;
        while (*str1 && *str2 && *str1 == *str2) {
            ++str1;
            ++str2;
        }
        if (*str2 == static_cast<CharT>(0)) {
            return cur;
        }
        ++cur;
    }
    return nullptr;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr const CharT* string_find_pattern_ignored_case(const CharT* dest,
                                                                              const CharT* src) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    if (*src == static_cast<CharT>(0)) {
        return dest;
    }
 
    const CharT* cur = dest;
    while (*cur) {
        const CharT* str1 = cur;
        const CharT* str2 = src;
        while (*str1 && *str2) {
            const CharT c1 = _NEFORCE to_lowercase(*str1);
            const CharT c2 = _NEFORCE to_lowercase(*str2);
            if (c1 != c2) {
                break;
            }
            ++str1;
            ++str2;
        }
        if (*str2 == static_cast<CharT>(0)) {
            return cur;
        }
        ++cur;
    }
    return nullptr;
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr size_t string_span_in(const CharT* str, const CharT* accept) noexcept {
    if (str == nullptr || *str == static_cast<CharT>(0) || accept == nullptr || *accept == static_cast<CharT>(0)) {
        return 0;
    }
 
    const CharT* original_str = str;
    while (*str != static_cast<CharT>(0)) {
        const CharT* a = accept;
        bool found = false;
        while (*a != static_cast<CharT>(0)) {
            if (*str == *a) {
                found = true;
                break;
            }
            ++a;
        }
        if (!found) {
            return static_cast<size_t>(str - original_str);
        }
        ++str;
    }
    return static_cast<size_t>(str - original_str);
}

template <typename CharT>
NEFORCE_PURE_FUNCTION constexpr size_t string_span_not_in(const CharT* str, const CharT* reject) noexcept {
    if (str == nullptr || *str == static_cast<CharT>(0)) {
        return 0;
    }
    if (reject == nullptr || *reject == static_cast<CharT>(0)) {
        size_t len = 0;
        while (str[len] != static_cast<CharT>(0)) {
            ++len;
        }
        return len;
    }
 
    const CharT* original_str = str;
    while (*str != static_cast<CharT>(0)) {
        const CharT* r = reject;
        while (*r != static_cast<CharT>(0)) {
            if (*str == *r) {
                return static_cast<size_t>(str - original_str);
            }
            ++r;
        }
        ++str;
    }
    return static_cast<size_t>(str - original_str);
}

template <typename CharT>
constexpr CharT* string_set(CharT* str, const CharT value) noexcept {
    if (str == nullptr) {
        return nullptr;
    }
    CharT* original = str;
    while (*str != static_cast<CharT>(0)) {
        *str = value;
        ++str;
    }
    return original;
}

template <typename CharT>
constexpr CharT* string_set(CharT* str, const CharT value, const size_t count) noexcept {
    if (str == nullptr || count == 0) {
        return str;
    }
    for (size_t i = 0; i < count; ++i) {
        str[i] = value;
    }
    return str;
}

template <typename CharT>
constexpr CharT* string_reverse(CharT* str) noexcept {
    if (str == nullptr || *str == static_cast<CharT>(0)) {
        return str;
    }
 
    CharT* end = str;
    while (*end != static_cast<CharT>(0)) {
        ++end;
    }
    --end;
    while (str < end) {
        const CharT temp = *str;
        *str = *end;
        *end = temp;
        ++str;
        --end;
    }
    return str;
}

template <typename CharT>
constexpr CharT* string_concatenate(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
    CharT* original_dest = dest;
    while (*dest != static_cast<CharT>(0)) {
        ++dest;
    }
 
    while (*src != static_cast<CharT>(0)) {
        *dest = *src;
        ++dest;
        ++src;
    }
    *dest = static_cast<CharT>(0);
    return original_dest;
}

template <typename CharT>
constexpr CharT* string_concatenate(CharT* NEFORCE_RESTRICT dest, const CharT* NEFORCE_RESTRICT src,
                                    const size_t count) noexcept {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }
 
    CharT* original_dest = dest;
    while (*dest != static_cast<CharT>(0)) {
        ++dest;
    }
 
    size_t copied = 0;
    while (*src != static_cast<CharT>(0) && copied < count) {
        *dest = *src;
        ++dest;
        ++src;
        ++copied;
    }
    *dest = static_cast<CharT>(0);
    return original_dest;
}
 // StringOperations
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_MEMORY_HPP__