CMakeLists.txt

@@ -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()

engine/NBCore/ANSITerm.hpp

@@ -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 

engine/NBCore/CMakeLists.txt

@@ -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()

engine/NBCore/Errors.hpp

@@ -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(
+    ErrorBase(const ErrorBase&) = default;
-        const unsigned int code,
+    ErrorBase& operator=(const ErrorBase&) = delete;
-        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
-    ) {}
 
-    static std::string lookup(unsigned int);
+    virtual const char* what() const noexcept override final {
-    unsigned int code() const noexcept {
+        std::string ret = this->msg;
-        return static_cast<const ErrorType*>(this)->_code;
+        const std::string replace = nb::NEWLINE + "\t";
-    };
+        if (trace) {
-    virtual const char* what() const noexcept override final { return _msg.c_str(); };
+            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,
+        const unsigned int code_,
-        std::string msg,
+        std::string msg_,
-        unsigned int line=0,
+        const TraceType* trace_=nullptr,
-        std::string filename=""
+        unsigned int line_=0,
-    ) noexcept : _code{code}, _msg{""} {
+        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_enum_v<typename ErrorType::Codes>, "enum Codes must be a class member.");
-        static_assert(std::is_same<std::underlying_type_t<typename ErrorType::ErrorCodes>, unsigned int>::value,
+        static_assert(std::is_same<std::underlying_type_t<typename ErrorType::Codes>, unsigned int>::value,
-            "enum ErrorCodes must be of underlying type unsigned int."
+            "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."
         );
+        static_assert(std::is_base_of<std::exception, TraceType>::value,
+            "`trace_` must be a pointer to a child object of std::exception."
+        );
+    }
 
-        _msg += std::string(ErrorType::type);
+    template <
-        _msg += "[" + std::to_string(_code) + "]";
+        typename TraceType,
-        if (line && filename.size()) {
+        std::enable_if_t<std::is_base_of_v<std::exception, TraceType>, bool> = true
-            _msg += " in \'" + filename + "\':" + std::to_string(line);
+    >
-        }
-        _msg += "\n    " + msg;
-    } 
     ErrorBase(
-        const unsigned int code,
+        const unsigned int& code_,
-        std::string msg,
+        const TraceType& trace_,
-        const std::exception& trace,
+        unsigned int line_=0,
-        unsigned int line=0,
+        std::string filename_=""
-        std::string filename=""
+    ) noexcept : ErrorBase(
-    ) noexcept : ErrorBase(code, msg, line, filename) {
+        code_, 
-        std::string what_msg(trace.what());
+        ErrorType::ErrorMessages.at(code_),
-        std::string::size_type newline_pos=-1;
+        &trace_,
-        while((newline_pos=what_msg.find("\n", newline_pos+1))!= std::string::npos) {
+        line_,
-            what_msg.replace(newline_pos, 1, "\n  ");
+        filename_
-        }
+    ) {}
-        _msg += "\n    Trace - " + what_msg;
-    }
 
-    unsigned int _code;
+    template <
-    std::string _msg;
+        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

engine/NBCore/Types.hpp

@@ -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

engine/NBCore/Utils.hpp

@@ -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

engine/NBCore/src/Errors.cpp

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

engine/NBCore/src/Processes.cpp

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

engine/NBCore/src/Utils.cpp

@@ -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;
+}

engine/NBCore/tests/CMakeLists.txt

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

engine/NBCore/tests/testErrors.cpp

@@ -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::Codes::A, "Hey!"},
-    {TestError::ErrorCodes::B, "How"},
+    {TestError::Codes::B, "How"},
-    {TestError::ErrorCodes::C, "You"},
+    {TestError::Codes::C, "You"},
-    {TestError::ErrorCodes::D, "Doin"}
+    {TestError::Codes::D, "Doin"}
 };
 
 
 TEST(ErrorTest, Test) {
-    EXPECT_EQ(1, 1);
+    std::cout << TestError(0, TestError(1, TestError(2))).what();
-
-    std::stringstream sstream;
-
-    ASSERT_TRUE(nb::logger.isRunning());
-    nb::logger.log("Hey!");
 }

engine/NBCore/tests/testProcesses.cpp

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

engine/NBCore/tests/testUtils.cpp

@@ -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