utility.h

#ifndef NCTL_UTILITY
#define NCTL_UTILITY
 
#include <cstring> // for `memcpy()`
#include "type_traits.h"
 
namespace nctl {
 
template <class T>
inline typename removeReference<T>::type &&move(T &&arg)
{
    return static_cast<typename removeReference<T>::type &&>(arg);
}
 
namespace detail {
 
    template <bool value>
    struct constructHelpers
    {
        template <class T>
        inline static void constructObject(T *ptr)
        {
            new (ptr) T();
        }
 
        template <class T>
        inline static void constructArray(T *ptr, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                new (ptr + i) T();
        }
 
        template <class T>
        inline static void copyConstructObject(T *dest, const T *src)
        {
            new (dest) T(*src);
        }
 
        template <class T>
        inline static void copyConstructArray(T *dest, const T *src, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                new (dest + i) T(src[i]);
        }
 
        template <class T>
        inline static void moveConstructObject(T *dest, T *src)
        {
            new (dest) T(nctl::move(*src));
        }
 
        template <class T>
        inline static void moveConstructArray(T *dest, T *src, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                new (dest + i) T(nctl::move(src[i]));
        }
    };
 
    template <>
    struct constructHelpers<true>
    {
        template <class T>
        inline static void constructObject(T *ptr)
        {
        }
 
        template <class T>
        inline static void constructArray(T *ptr, unsigned int numElements)
        {
        }
 
        template <class T>
        inline static void copyConstructObject(T *dest, const T *src)
        {
            memcpy(dest, src, sizeof(T));
        }
 
        template <class T>
        inline static void copyConstructArray(T *dest, const T *src, unsigned int numElements)
        {
            memcpy(dest, src, numElements * sizeof(T));
        }
 
        template <class T>
        inline static void moveConstructObject(T *dest, T *src)
        {
            memcpy(dest, src, sizeof(T));
        }
 
        template <class T>
        inline static void moveConstructArray(T *dest, T *src, unsigned int numElements)
        {
            memcpy(dest, src, numElements * sizeof(T));
        }
    };
 
    template <bool value>
    struct destructHelpers
    {
        template <class T>
        inline static void destructObject(T *ptr)
        {
            ptr->~T();
        }
 
        template <class T>
        inline static void destructArray(T *ptr, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                ptr[numElements - i - 1].~T();
        }
    };
 
    template <>
    struct destructHelpers<true>
    {
        template <class T>
        inline static void destructObject(T *ptr)
        {
        }
 
        template <class T>
        inline static void destructArray(T *ptr, unsigned int numElements)
        {
        }
    };
 
    template <bool value>
    struct copyHelpers
    {
        template <class T>
        inline static void copyAssignObject(T *dest, const T *src)
        {
            *dest = *src;
        }
 
        template <class T>
        inline static void copyAssignArray(T *dest, const T *src, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                dest[i] = src[i];
        }
 
        template <class T>
        inline static void moveAssignObject(T *dest, T *src)
        {
            *dest = nctl::move(*src);
        }
 
        template <class T>
        inline static void moveAssignArray(T *dest, T *src, unsigned int numElements)
        {
            for (unsigned int i = 0; i < numElements; i++)
                dest[i] = nctl::move(src[i]);
        }
    };
 
    template <>
    struct copyHelpers<true>
    {
        template <class T>
        inline static void copyAssignObject(T *dest, const T *src)
        {
            memcpy(dest, src, sizeof(T));
        }
 
        template <class T>
        inline static void copyAssignArray(T *dest, const T *src, unsigned int numElements)
        {
            memcpy(dest, src, numElements * sizeof(T));
        }
 
        template <class T>
        inline static void moveAssignObject(T *dest, T *src)
        {
            memcpy(dest, src, sizeof(T));
        }
 
        template <class T>
        inline static void moveAssignArray(T *dest, T *src, unsigned int numElements)
        {
            memcpy(dest, src, numElements * sizeof(T));
        }
    };
 
}
 
template <typename T>
inline constexpr T &&forward(typename removeReference<T>::type &arg)
{
    return static_cast<T &&>(arg);
}
 
template <typename T>
inline constexpr T &&forward(typename removeReference<T>::type &&arg)
{
    static_assert(!isLValueReference<T>::value, "Invalid lvalue to rvalue conversion");
    return static_cast<T &&>(arg);
}
 
template <class T>
inline void swap(T &a, T &b)
{
    T temp = nctl::move(a);
    a = nctl::move(b);
    b = nctl::move(temp);
}
 
template <class T>
inline bool equalTo(const T &a, const T &b)
{
    return (a == b);
}
 
template <class T>
inline bool equalTo(const T *a, const T *b)
{
    return (a == b);
}
 
template <>
inline bool equalTo<char>(const char *a, const char *b)
{
    // `strcmp()` reimplementation to avoid additional dependencies
    while (*a && (*a == *b))
    {
        a++;
        b++;
    }
    const unsigned char result = *reinterpret_cast<const unsigned char *>(a) -
                                 *reinterpret_cast<const unsigned char *>(b);
 
    return (result == 0);
}
 
template <class T>
void constructObject(T *ptr)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::constructObject(ptr);
}
 
template <class T>
void constructArray(T *ptr, unsigned int numElements)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::constructArray(ptr, numElements);
}
 
template <class T>
void copyConstructObject(T *dest, const T *src)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::copyConstructObject(dest, src);
}
 
template <class T>
void copyConstructArray(T *dest, const T *src, unsigned int numElements)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::copyConstructArray(dest, src, numElements);
}
 
template <class T>
void moveConstructObject(T *dest, T *src)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::moveConstructObject(dest, src);
}
 
template <class T>
void moveConstructArray(T *dest, T *src, unsigned int numElements)
{
    detail::constructHelpers<isTriviallyConstructible<T>::value>::moveConstructArray(dest, src, numElements);
}
 
template <class T>
void destructObject(T *ptr)
{
    detail::destructHelpers<isTriviallyDestructible<T>::value>::destructObject(ptr);
}
 
template <class T>
void destructArray(T *ptr, unsigned int numElements)
{
    detail::destructHelpers<isTriviallyDestructible<T>::value>::destructArray(ptr, numElements);
}
 
template <class T>
void copyAssignObject(T *dest, const T *src)
{
    detail::copyHelpers<isTriviallyCopyable<T>::value>::copyAssignObject(dest, src);
}
 
template <class T>
void copyAssignArray(T *dest, const T *src, unsigned int numElements)
{
    detail::copyHelpers<isTriviallyCopyable<T>::value>::copyAssignArray(dest, src, numElements);
}
 
template <class T>
void moveAssignObject(T *dest, T *src)
{
    detail::copyHelpers<isTriviallyCopyable<T>::value>::moveAssignObject(dest, src);
}
 
template <class T>
void moveAssignArray(T *dest, T *src, unsigned int numElements)
{
    detail::copyHelpers<isTriviallyCopyable<T>::value>::moveAssignArray(dest, src, numElements);
}
 
}
 
#endif