#ifndef UTILITY_H
#define UTILITY_H

#include <stdlib.h>

namespace Core {
    namespace Internal {
        template<typename T>
        struct RemoveReferenceBase {
            typedef T t;
        };

        template<typename T>
        struct RemoveReferenceBase<T&> {
            typedef T t;
        };

        template<typename T>
        struct RemoveReferenceBase<T&&> {
            typedef T t;
        };

        template<typename A, typename B>
        struct IsSameBase {
            static constexpr bool value = false;
        };

        template<typename T>
        struct IsSameBase<T, T> {
            static constexpr bool value = true;
        };
    }

    template<typename T>
    using RemoveReference = typename Internal::RemoveReferenceBase<T>::t;

    template<typename T, typename U>
    constexpr bool IsSame = Internal::IsSameBase<T, U>::value;

    template<typename T>
    constexpr RemoveReference<T>&& move(T&& t) {
        return static_cast<RemoveReference<T>&&>(t);
    }

    template<typename T>
    constexpr T&& forward(RemoveReference<T>& t) {
        return static_cast<T&&>(t);
    }

    template<typename T>
    constexpr T&& forward(RemoveReference<T>&& t) {
        return static_cast<T&&>(t);
    }

    template<typename T>
    void swap(T& a, T& b) {
        T tmp = Core::move(a);
        a = Core::move(b);
        b = Core::move(tmp);
    }

    int popcount(int i);
}

void* operator new(size_t bytes) noexcept;
void* operator new[](size_t bytes) noexcept;
void operator delete(void* p) noexcept;
void operator delete[](void* p) noexcept;
void operator delete(void* p, size_t bytes) noexcept;
void operator delete[](void* p, size_t bytes) noexcept;
void* operator new(size_t bytes, void* p) noexcept;
void* operator new[](size_t bytes, void* p) noexcept;

#endif