|
@@ -1,222 +0,0 @@
|
|
|
-#ifndef CORE_UTILITY_H
|
|
|
-#define CORE_UTILITY_H
|
|
|
-
|
|
|
-#include "utils/Check.h"
|
|
|
-
|
|
|
-#define CORE_SIZE(t) static_cast<int>(sizeof(t))
|
|
|
-
|
|
|
-namespace Core {
|
|
|
- enum class Error {
|
|
|
- NONE = 0,
|
|
|
- NEGATIVE_ARGUMENT,
|
|
|
- CAPACITY_REACHED,
|
|
|
- BLOCKED_STDOUT,
|
|
|
- OUT_OF_MEMORY,
|
|
|
- INVALID_CHAR,
|
|
|
- NOT_FOUND,
|
|
|
- INVALID_STATE,
|
|
|
- INVALID_INDEX,
|
|
|
- INVALID_ARGUMENT,
|
|
|
- TIME_NOT_AVAILABLE,
|
|
|
- SLEEP_INTERRUPTED,
|
|
|
- THREAD_ERROR,
|
|
|
- INVALID_ID,
|
|
|
- EXISTING_KEY,
|
|
|
- CANNOT_OPEN_FILE,
|
|
|
- END_OF_FILE
|
|
|
- };
|
|
|
- const char* getErrorName(Error e);
|
|
|
-
|
|
|
- inline bool checkError(Error& storage, Error e) {
|
|
|
- return (storage = e) != Error::NONE;
|
|
|
- }
|
|
|
-
|
|
|
-#define CORE_RETURN_ERROR(checked) \
|
|
|
- { \
|
|
|
- Core::Error error = Core::Error::NONE; \
|
|
|
- if(checkError(error, checked)) [[unlikely]] { \
|
|
|
- return error; \
|
|
|
- } \
|
|
|
- }
|
|
|
-
|
|
|
- namespace Internal {
|
|
|
- template<typename T>
|
|
|
- struct BaseRemovePointer final {
|
|
|
- using Type = T;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- struct BaseRemovePointer<T*> final {
|
|
|
- using Type = T;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- struct BaseRemoveReference final {
|
|
|
- using Type = T;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- struct BaseRemoveReference<T&> final {
|
|
|
- using Type = T;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- struct BaseRemoveReference<T&&> final {
|
|
|
- using Type = T;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename A, typename B>
|
|
|
- struct BaseIsSame final {
|
|
|
- static constexpr bool value = false;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- struct BaseIsSame<T, T> final {
|
|
|
- static constexpr bool value = true;
|
|
|
- };
|
|
|
-
|
|
|
- template<bool C, typename A, typename B>
|
|
|
- struct BaseIf final {
|
|
|
- using Type = A;
|
|
|
- };
|
|
|
-
|
|
|
- template<typename A, typename B>
|
|
|
- struct BaseIf<false, A, B> final {
|
|
|
- using Type = B;
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- using RemovePointer = Internal::BaseRemovePointer<T>::Type;
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- using RemoveReference = Internal::BaseRemoveReference<T>::Type;
|
|
|
-
|
|
|
- template<typename T, typename U>
|
|
|
- constexpr bool IsSame = Internal::BaseIsSame<T, U>::value;
|
|
|
-
|
|
|
- template<bool C, typename A, typename B>
|
|
|
- using If = Internal::BaseIf<C, A, B>::Type;
|
|
|
-
|
|
|
- namespace Internal {
|
|
|
- template<int N, typename T1, typename T2, typename T3, typename T4,
|
|
|
- typename T5>
|
|
|
- using SelectType =
|
|
|
- If<sizeof(T1) == N, T1,
|
|
|
- If<sizeof(T2) == N, T2,
|
|
|
- If<sizeof(T3) == N, T3, If<sizeof(T4) == N, T4, T5>>>>;
|
|
|
-
|
|
|
- template<int N>
|
|
|
- using SelectSigned =
|
|
|
- SelectType<N, signed char, signed short, signed int, signed long,
|
|
|
- signed long long>;
|
|
|
-
|
|
|
- template<int N>
|
|
|
- using SelectUnsigned =
|
|
|
- SelectType<N, unsigned char, unsigned short, unsigned int,
|
|
|
- unsigned long, unsigned long long>;
|
|
|
- }
|
|
|
-
|
|
|
- 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(const char* file, int line, int value);
|
|
|
- void setExitHandler(ExitHandler eh, void* data);
|
|
|
-#define CORE_EXIT(exitValue) \
|
|
|
- Core::exitWithHandler(__FILE__, __LINE__, exitValue)
|
|
|
-
|
|
|
- check_return Error toString(signed short s, char* buffer, int size);
|
|
|
- check_return Error toString(unsigned short s, char* buffer, int size);
|
|
|
- check_return Error toString(signed int i, char* buffer, int size);
|
|
|
- check_return Error toString(unsigned int i, char* buffer, int size);
|
|
|
- check_return Error toString(signed long l, char* buffer, int size);
|
|
|
- check_return Error toString(unsigned long l, char* buffer, int size);
|
|
|
- check_return Error toString(signed long long ll, char* buffer, int size);
|
|
|
- check_return Error toString(unsigned long long ll, char* buffer, int size);
|
|
|
- check_return Error toString(float f, char* buffer, int size);
|
|
|
- check_return Error toString(double d, char* buffer, int size);
|
|
|
- check_return Error toString(long double ld, char* buffer, int size);
|
|
|
-
|
|
|
- check_return Error putChar(int c);
|
|
|
-
|
|
|
- void memorySet(void* p, int c, int n);
|
|
|
- void memoryCopy(void* dest, const void* src, int n);
|
|
|
- bool memoryCompare(const void* a, const void* b, int n);
|
|
|
- check_return Error reallocate(char*& p, int n);
|
|
|
- void free(void* p);
|
|
|
-
|
|
|
- const char* getFileName(const char* path);
|
|
|
-
|
|
|
- template<typename T>
|
|
|
- constexpr int stringLength(const T* c) {
|
|
|
- int i = 0;
|
|
|
- while(*c != '\0') {
|
|
|
- c++;
|
|
|
- i++;
|
|
|
- }
|
|
|
- return i;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-using i64 = Core::Internal::SelectSigned<8>;
|
|
|
-using i32 = Core::Internal::SelectSigned<4>;
|
|
|
-using i16 = Core::Internal::SelectSigned<2>;
|
|
|
-using i8 = Core::Internal::SelectSigned<1>;
|
|
|
-using u64 = Core::Internal::SelectUnsigned<8>;
|
|
|
-using u32 = Core::Internal::SelectUnsigned<4>;
|
|
|
-using u16 = Core::Internal::SelectUnsigned<2>;
|
|
|
-using u8 = Core::Internal::SelectUnsigned<1>;
|
|
|
-using c32 = char32_t;
|
|
|
-
|
|
|
-static_assert(sizeof(i64) == 8, "invalid size");
|
|
|
-static_assert(sizeof(i32) == 4, "invalid size");
|
|
|
-static_assert(sizeof(i16) == 2, "invalid size");
|
|
|
-static_assert(sizeof(i8) == 1, "invalid size");
|
|
|
-static_assert(sizeof(u64) == 8, "invalid size");
|
|
|
-static_assert(sizeof(u32) == 4, "invalid size");
|
|
|
-static_assert(sizeof(u16) == 2, "invalid size");
|
|
|
-static_assert(sizeof(u8) == 1, "invalid size");
|
|
|
-
|
|
|
-using size_t = u64;
|
|
|
-
|
|
|
-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
|