naifb/NBEngine
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

Made errors mostly work as hoped

Browse Source
This commit is contained in:
NaifBanana 2026-04-06 02:22:28 -05:00
parent a52a88a2d6
commit 126862748e
13 changed files with 284 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -48,13 +48,12 @@ if(NB_BUILD_TESTS)
include(FetchContent)
FetchContent_Declare(
gtest
URL https://github.com/google/googletest/archive/refs/tags/release-1.12.1.zip
URL https://github.com/google/googletest/archive/refs/heads/main.zip
)
if (WIN32)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(gtest)
endif()
include(GoogleTest)
set(GTEST_COLOR ON)
set(GLFW_BUILD_TESTS ON CACHE BOOL "" FORCE)
endif()

6
engine/NBCore/ANSITerm.hpp
View File

@ -2,16 +2,10 @@
#ifndef _NB_ANSI_TERM
#define _NB_ANSI_TERM
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <tuple>
#include <type_traits>
#include "TypeTraits.hpp"
/*
----------- TECH DEBT ------------
Idk wtf to do here. This was originally to allow me to print

8
engine/NBCore/CMakeLists.txt
View File

@ -1,9 +1,8 @@
include_directories(./.)
toAbsolutePath(NB_CORE_SOURCE
./src/Errors.cpp
./src/Processes.cpp
./src/Logger.cpp
./src/Processes.cpp
./src/Utils.cpp
)
toAbsolutePath(NB_CORE_INCLUDE
@ -15,6 +14,7 @@ toAbsolutePath(NB_CORE_INCLUDE
./ThreadsafeQueue.hpp
./Types.hpp
./TypeTraits.hpp
./Utils.hpp
)
set(NB_CORE_SOURCE ${NB_CORE_SOURCE} PARENT_SCOPE)
@ -22,6 +22,8 @@ set(NB_CORE_INCLUDE ${NB_CORE_INCLUDE} PARENT_SCOPE)
add_library(NBCore ${NB_CORE_SOURCE})
target_include_directories(NBCore PUBLIC ./.)
if (NB_BUILD_TESTS)
add_subdirectory(./tests)
endif()

221
engine/NBCore/Errors.hpp
View File

@ -3,10 +3,11 @@
#define _NB_ERROR
#include <exception>
#include <memory>
#include <iostream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include "Utils.hpp"
#ifndef THROW_WITH_INFO
#ifdef CODE_ERROR_LOCATIONS
@ -31,109 +32,173 @@ typedef std::unordered_map<unsigned int, const char*> ErrorCodeMap;
template<class ErrorType>
class ErrorBase : public std::exception {
public:
ErrorBase(
const unsigned int code,
unsigned int line=0,
std::string filename=""
) noexcept : ErrorBase(
code,
ErrorBase<ErrorType>::lookup(code),
line,
filename
) {}
ErrorBase(
const unsigned int code,
const std::exception& trace,
unsigned int line=0,
std::string filename=""
) noexcept : ErrorBase(
code,
ErrorBase<ErrorType>::lookup(code),
trace,
line,
filename
) {}
ErrorBase(const ErrorBase&) = default;
ErrorBase& operator=(const ErrorBase&) = delete;
static std::string lookup(unsigned int);
unsigned int code() const noexcept {
return static_cast<const ErrorType*>(this)->_code;
};
virtual const char* what() const noexcept override final { return _msg.c_str(); };
virtual const char* what() const noexcept override final {
std::string ret = this->msg;
const std::string replace = nb::NEWLINE + "\t";
if (trace) {
ret += replace + find_and_replace(
std::string(trace->what()),
nb::NEWLINE,
replace
);
}
const std::string& ret_ref = ret;
return ret_ref.c_str();
}
static const std::string type;
static const ErrorCodeMap ErrorMessages;
const unsigned int code;
const std::string msg;
const std::exception* trace;
protected:
ErrorBase() = default;
ErrorBase() = delete;
template <
typename TraceType=std::exception,
std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
>
ErrorBase(
const unsigned int code,
std::string msg,
unsigned int line=0,
std::string filename=""
) noexcept : _code{code}, _msg{""} {
const unsigned int code_,
std::string msg_,
const TraceType* trace_=nullptr,
unsigned int line_=0,
std::string filename_=""
) noexcept :
code(code_),
msg(msg_),
trace{static_cast<std::exception*>(trace_ ? new TraceType(*trace_) : nullptr) }
{
static_assert(std::is_same<const std::unordered_map<unsigned int, const char*>, decltype(ErrorType::ErrorMessages)>::value,
"const std::unordered_map<unsigned int, const char*> ErrorMessages must be "
"a class member."
);
static_assert(std::is_enum_v<typename ErrorType::ErrorCodes>, "enum ErrorCodes must be a class member.");
static_assert(std::is_same<std::underlying_type_t<typename ErrorType::ErrorCodes>, unsigned int>::value,
"enum ErrorCodes must be of underlying type unsigned int."
static_assert(std::is_enum_v<typename ErrorType::Codes>, "enum Codes must be a class member.");
static_assert(std::is_same<std::underlying_type_t<typename ErrorType::Codes>, unsigned int>::value,
"enum Codes must be of underlying type unsigned int."
);
static_assert(std::is_same<const std::string, decltype(ErrorType::type)>::value,
"const std::string type must be a class member."
);
_msg += std::string(ErrorType::type);
_msg += "[" + std::to_string(_code) + "]";
if (line && filename.size()) {
_msg += " in \'" + filename + "\':" + std::to_string(line);
}
_msg += "\n " + msg;
static_assert(std::is_base_of<std::exception, TraceType>::value,
"`trace_` must be a pointer to a child object of std::exception."
);
}
template <
typename TraceType,
std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
>
ErrorBase(
const unsigned int code,
std::string msg,
const std::exception& trace,
unsigned int line=0,
std::string filename=""
) noexcept : ErrorBase(code, msg, line, filename) {
std::string what_msg(trace.what());
std::string::size_type newline_pos=-1;
while((newline_pos=what_msg.find("\n", newline_pos+1))!= std::string::npos) {
what_msg.replace(newline_pos, 1, "\n ");
}
_msg += "\n Trace - " + what_msg;
}
const unsigned int& code_,
const TraceType& trace_,
unsigned int line_=0,
std::string filename_=""
) noexcept : ErrorBase(
code_,
ErrorType::ErrorMessages.at(code_),
&trace_,
line_,
filename_
) {}
unsigned int _code;
std::string _msg;
template <
typename TraceType,
std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
>
ErrorBase(
const std::string& msg_,
const TraceType& trace_,
unsigned int line_=0,
std::string filename_=""
) noexcept : ErrorBase(
0,
msg_,
&trace_,
line_,
filename_
) {}
ErrorBase(
const unsigned int& code_,
unsigned int line_=0,
std::string filename_=""
) noexcept : ErrorBase(
code_,
ErrorType::ErrorMessages.at(code_),
static_cast<std::exception*>(nullptr),
line_,
filename_
) {}
ErrorBase(
const std::string& msg_,
unsigned int line_=0,
std::string filename_=""
) noexcept : ErrorBase(
0,
msg_,
nullptr,
line_,
filename_
) {}
};
template <typename ErrorType>
const std::string ErrorBase<ErrorType>::type = ErrorType::type;
template <typename ErrorType>
const ErrorCodeMap ErrorBase<ErrorType>::ErrorMessages = ErrorType::ErrorMessages;
class DefaultError {DefaultError() = default;};
template <class ErrorType = DefaultError>
class Error;
template<>
class Error<DefaultError>;
template <class ErrorType>
class Error : public ErrorBase<ErrorType> {
using Base = ErrorBase<ErrorType>;
public:
template <typename... Args>
Error(Args... T) : Base(T...) {}
using Base::what;
using Base::code;
using Base::msg;
using Base::trace;
using Base::type;
using Base::ErrorMessages;
friend ErrorBase<Error>;
};
class Error : public ErrorBase<Error> {
template<>
class Error<DefaultError> : public ErrorBase<Error<DefaultError>> {
using Base = ErrorBase<Error<DefaultError>>;
public:
enum ErrorCodes : unsigned int {
using Base::Base;
Error() : Base(0) {}
enum Codes : unsigned int {
GENERAL, UNDEFINED, BADERRORCODE
};
using ErrorBase<Error>::ErrorBase;
using Base::what;
using Base::code;
using Base::msg;
using Base::trace;
friend ErrorBase<Error>;
protected:
static const std::string type;
static const ErrorCodeMap ErrorMessages;
};
template<class ErrorType>
std::string ErrorBase<ErrorType>::lookup(unsigned int code) {
for (auto kv : ErrorType::ErrorMessages) {
if (kv.first==code) {
return std::string(kv.second);
}
}
throw Error(Error::ErrorCodes::BADERRORCODE);
}
} // namespace nb
#endif // _NB_ERROR

25
engine/NBCore/Types.hpp
View File

@ -1,25 +0,0 @@
#pragma once
#ifndef _NB_CORE_TYPES
#define _NB_CORE_TYPES
#include <vector>
namespace nb {
template<typename T>
T swapEndian(const T& val) {
T ret;
const int size = sizeof(T);
auto retLoc = static_cast<void*>(&ret);
auto valLoc = static_cast<const void*>(&val);
for (int i = 0; i < size; ++i) {
memcpy(retLoc+i, valLoc+(size-i-1), 1);
}
return ret;
}
using ByteVector = std::vector<uint8_t>;
} // namespace nb
#endif // _NB_CORE_TYPES

45
engine/NBCore/Utils.hpp Normal file
View File

@ -0,0 +1,45 @@
#pragma once
#ifndef _NB_CORE_TYPES
#define _NB_CORE_TYPES
#include <array>
#include <utility>
#include <string>
namespace nb {
#ifdef _NB_TARGET_WINDOWS
const std::string NEWLINE("\r\n");
#endif // _NB_TARGET_WINDOWS
#ifdef _NB_TARGET_LINUX
const std::string NEWLINE("\n");
#endif // _NB_TARGET_LINUX
template<typename K, typename V, size_t N>
struct ConstexprMap {
template<typename Input>
constexpr ConstexprMap(Input inp) : _data{inp} {}
protected:
const std::array<std::pair<K, V>, N> _data;
};
/* template<typename T>
T swap_endian(const T& val) {
T ret;
const int size = sizeof(T);
auto retLoc = static_cast<void*>(&ret);
auto valLoc = static_cast<const void*>(&val);
for (int i = 0; i < size; ++i) {
memcpy(retLoc+i, valLoc+(size-i-1), 1);
}
return ret;
} */
std::string find_and_replace(const std::string& original, const std::string& find, const std::string& replace);
// using ByteVector = std::vector<uint8_t>;
} // namespace nb
#endif // _NB_CORE_TYPES

11
engine/NBCore/src/Errors.cpp
View File

@ -2,11 +2,12 @@
namespace nb {
const std::string Error::type = "Error";
const ErrorCodeMap Error::ErrorMessages = {
{ErrorCodes::GENERAL, "General std::exception."},
{ErrorCodes::UNDEFINED, "Undefined / general error."},
{ErrorCodes::BADERRORCODE, "Unrecognized error code."}
const std::string Error<DefaultError>::type = "nb::Error";
const ErrorCodeMap Error<DefaultError>::ErrorMessages = {
{Error::Codes::GENERAL, "General std::exception."},
{Error::Codes::UNDEFINED, "Undefined / general error."},
{Error::Codes::BADERRORCODE, "Unrecognized error code."}
};
}

1
engine/NBCore/src/Processes.cpp
View File

@ -7,7 +7,6 @@
#endif // _NB_TARGET_LINUX
#include "Processes.hpp"
#include "Types.hpp"
namespace nb {

23
engine/NBCore/src/Utils.cpp Normal file
View File

@ -0,0 +1,23 @@
#include <string>
#include "Utils.hpp"
std::string nb::find_and_replace(const std::string& original, const std::string& find, const std::string& replace) {
std::string ret = original;
std::size_t find_len = find.length();
std::size_t replace_len = replace.length();
std::size_t currpos = 0;
std::size_t lastpos = 0;
while(true) {
lastpos = currpos;
currpos = original.find(find, lastpos);
if (currpos == std::string::npos) {
break;
}
ret = ret.erase(currpos, find_len);
ret = ret.insert(currpos, replace);
currpos += replace_len;
}
return ret;
}

5
engine/NBCore/tests/CMakeLists.txt
View File

@ -4,8 +4,9 @@ if (NB_BUILD_TESTS)
enable_testing()
include(GoogleTest)
add_executable(TestCore
testErrors.cpp
testProcesses.cpp
./testErrors.cpp
#./testProcesses.cpp
./testUtils.cpp
)
target_link_libraries(TestCore
NBCore

31
engine/NBCore/tests/testErrors.cpp
View File

@ -3,36 +3,35 @@
#include "Errors.hpp"
#include <gtest/gtest.h>
#include <iostream>
#include <sstream>
#include "Logger.hpp"
using namespace nb;
class TestError : public ErrorBase<TestError> {
class TestError : public Error<TestError> {
using Base = Error<TestError>;
public:
using ErrorBase<TestError>::ErrorBase;
using Base::Base;
using Base::what;
using Base::code;
using Base::msg;
using Base::trace;
enum ErrorCodes : unsigned int {
enum Codes : unsigned int {
A, B, C, D
};
static const std::string type;
static const ErrorCodeMap ErrorMessages;
static const nb::ErrorCodeMap ErrorMessages;
};
const std::string TestError::type="TestError";
const ErrorCodeMap TestError::ErrorMessages{
{TestError::ErrorCodes::A, "Hey!"},
{TestError::ErrorCodes::B, "How"},
{TestError::ErrorCodes::C, "You"},
{TestError::ErrorCodes::D, "Doin"}
{TestError::Codes::A, "Hey!"},
{TestError::Codes::B, "How"},
{TestError::Codes::C, "You"},
{TestError::Codes::D, "Doin"}
};
TEST(ErrorTest, Test) {
EXPECT_EQ(1, 1);
std::stringstream sstream;
ASSERT_TRUE(nb::logger.isRunning());
nb::logger.log("Hey!");
std::cout << TestError(0, TestError(1, TestError(2))).what();
}

2
engine/NBCore/tests/testProcesses.cpp
View File

@ -1,8 +1,6 @@
#define CODE_ERROR_LOCATIONS
#include <gtest/gtest.h>
#include <iostream>
#include "Processes.hpp"
#include <Windows.h>

41
engine/NBCore/tests/testUtils.cpp Normal file
View File

@ -0,0 +1,41 @@
#define CODE_ERROR_LOCATIONS
#include "Utils.hpp"
#include <gtest/gtest.h>
namespace nb {
TEST(UtilsTest, Test) {
ASSERT_STREQ(
find_and_replace("Jeff", "e", "efe").c_str(),
"Jefeff"
);
auto tmp = find_and_replace("Naif", "a", "afa");
ASSERT_STREQ(
find_and_replace(tmp, "i", "ifi").c_str(),
"Nafaifif"
);
tmp = find_and_replace("aeiou", "a", "afa");
tmp = find_and_replace(tmp, "e", "efe");
tmp = find_and_replace(tmp, "i", "ifi");
tmp = find_and_replace(tmp, "o", "ofo");
tmp = find_and_replace(tmp, "u", "ufu");
ASSERT_STREQ(
tmp.c_str(),
"afaefeifiofoufu"
);
tmp = find_and_replace(tmp, "afa", "a");
tmp = find_and_replace(tmp, "efe", "e");
tmp = find_and_replace(tmp, "ifi", "i");
tmp = find_and_replace(tmp, "ofo", "o");
tmp = find_and_replace(tmp, "ufu", "u");
ASSERT_STREQ(
tmp.c_str(),
"aeiou"
);
}
} // namespace nb