#ifndef CORE_UTILITY_H
#define CORE_UTILITY_H

#include <stdlib.h>

#define CORE_SIZE(t) static_cast<int>(sizeof(t))

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

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

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

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

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

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

    template<typename T, typename U>
    constexpr bool IsSame = Internal::BaseIsSame<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);
    }

    template<typename T>
    int popCount(const T& t) {
        static constexpr int map[16] = {0, 1, 1, 2, 1, 2, 2, 3,
                                        1, 2, 2, 3, 2, 3, 3, 4};
        int sum = 0;
        for(int i = 0; i < CORE_SIZE(T) * 8; i += 4) {
            sum += map[(t >> i) & 0xF];
        }
        return sum;
    }

    using ExitHandler = void (*)(int, void*);

    void exitWithHandler(int value);
    void setExitHandler(ExitHandler eh, void*);
}

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