mem_utils.h

Go to the documentation of this file.

#pragma once
 
#include "config.h"
#include "simple_type_traits.h"
 
namespace detail
{
 
    inline void memset(void *ptr, int value, my_size_t size) noexcept
    {
#if defined(__has_builtin) && __has_builtin(__builtin_memset)
        __builtin_memset(ptr, value, size);
#else
        auto *p = static_cast<unsigned char *>(ptr);
        for (my_size_t i = 0; i < size; ++i)
            p[i] = static_cast<unsigned char>(value);
#endif
    }
 
    inline void memcpy(void *dst, const void *src, my_size_t size) noexcept
    {
#if defined(__has_builtin) && __has_builtin(__builtin_memcpy)
        __builtin_memcpy(dst, src, size);
#else
        auto *d = static_cast<unsigned char *>(dst);
        const auto *s = static_cast<const unsigned char *>(src);
        for (my_size_t i = 0; i < size; ++i)
            d[i] = s[i];
#endif
    }
 
} // namespace detail
 
template <typename T>
inline void fill_n_optimized(T *ptr, my_size_t count, const T &value)
{
    if constexpr (is_pod_v<T>)
    {
        if (value == T{})
        {
            detail::memset(ptr, 0, count * sizeof(T));
            return;
        }
    }
 
    for (my_size_t i = 0; i < count; ++i)
    {
        ptr[i] = value;
    }
}
 
template <typename T>
inline void copy_n_optimized(const T *src, T *dst, my_size_t count)
{
    if constexpr (is_pod_v<T>)
    {
        detail::memcpy(dst, src, count * sizeof(T));
        return;
    }
 
    for (my_size_t i = 0; i < count; ++i)
    {
        dst[i] = src[i];
    }
}