diff --git a/includes/misc.hpp b/includes/misc.hpp index 14e6eaa..d8cdbb1 100644 --- a/includes/misc.hpp +++ b/includes/misc.hpp @@ -1,16 +1,85 @@ #ifndef MISC_HPP #define MISC_HPP +//MISC.HPP is a header with useful functions and classes. + #include #include +#include +#include +#include namespace misc { - //Realiza um std::make_shared e converte para classe base com reinterpret_pointer_cast + //Performs a std::make_shared and converts to base class with reinterpret_pointer_cast template std::shared_ptr reinterpret_make_shared(_Types&&... _Args) { auto derived = std::make_shared(std::forward<_Types>(_Args)...); return reinterpret_pointer_cast(derived); } + + // + // Smart Pointer Comparator + // + + template struct is_shared_ptr : std::false_type {}; + template struct is_shared_ptr> : std::true_type {}; + template struct is_weak_ptr : std::false_type {}; + template struct is_weak_ptr> : std::true_type {}; + template struct is_unique_ptr : std::false_type {}; + template struct is_unique_ptr> : std::true_type {}; + + //Returns true if the type is a smart pointer + template + static constexpr bool IsSmartPointer() { + return is_shared_ptr::value || is_unique_ptr::value || is_weak_ptr::value; + } + + //Convert a string to wstring + static inline std::wstring ToWString(const std::string& str) + { + std::wstring wstr; + size_t size; + wstr.resize(str.length()); + mbstowcs_s(&size, &wstr[0], wstr.size() + 1, str.c_str(), str.size()); + return wstr; + } + + //Convert a wstring to string + static inline std::string ToString(const std::wstring& wstr) + { + std::string str; + size_t size; + str.resize(wstr.length()); + wcstombs_s(&size, &str[0], str.size() + 1, wstr.c_str(), wstr.size()); + return str; + } + + //Returns a hash reporting input values + template + static constexpr void HashCombine(std::size_t& seed, const T& v) { + std::hash hasher; + seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + +#define SOURCE_LOCATION std::source_location const& location = std::source_location::current() + + //Returns null if the type is a smart pointer or default value if the type has a default constructor. + //Throws an exception if the object cannot be created + template + static inline auto ReturnDefaultOrNull(SOURCE_LOCATION) { + if constexpr (IsSmartPointer() || std::is_pointer::value) + return (T)nullptr; + else if constexpr (std::is_default_constructible::value) + return T(); + else { + std::string error; + error.append("Could not return null or default value."); + error.append("In "); + error.append(location.function_name); + + throw std::runtime_error(error); + } + } } #endif \ No newline at end of file