BigfootDev/Bigfoot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Romain BOULLARD
2026-01-27 17:13:49 +01:00
commit a82ec43e74
76 changed files with 4584 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Bigfoot/Sources/Utils/CMakeLists.txt
+21
View File
@@ -0,0 +1,21 @@
get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
set(PublicDependencies
$<$<CONFIG:Debug,RelWithDebInfo>:quill::quill>
$<$<CONFIG:Debug,RelWithDebInfo>:cpptrace::cpptrace>)
set(PrivateDependencies)
set(BigfootPublicDependencies
System)
set(BigfootPrivateDependencies)
bigfoot_create_package_lib(
${PackageName}
"${PublicDependencies}"
"${PrivateLibraries}"
"${BigfootPublicDependencies}"
"${BigfootPrivateDependencies}"
"")
target_compile_definitions(${PackageName}
PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_NO_EXCEPTIONS>
PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_DISABLE_NON_PREFIXED_MACROS>)
Bigfoot/Sources/Utils/Include/Utils/Assert.hpp
+95
View File
@@ -0,0 +1,95 @@
/*********************************************************************
* \file Assert.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_ASSERT_HPP
#define BIGFOOT_UTILS_ASSERT_HPP
#if defined BIGFOOT_NOT_OPTIMIZED
#include <cpptrace/cpptrace.hpp>
#include <cstdint>
#include <source_location>
#include <string>
#if defined BIGFOOT_LINUX
#include <csignal>
#endif
#if defined BIGFOOT_WINDOWS
#define BREAK \
do \
{ \
__debugbreak(); \
} while (false)
#elif defined BIGFOOT_LINUX
#define BREAK \
do \
{ \
std::raise(SIGTRAP); \
} while (false)
#endif
#define ASSERT(HANDLER, p_assert, p_message, ...) \
do \
{ \
constexpr std::source_location location = std::source_location::current(); \
if (!(p_assert)) [[unlikely]] \
{ \
constexpr auto stacktrace = []() -> std::string \
{ \
const cpptrace::stacktrace stacktrace = cpptrace::generate_trace(); \
return stacktrace.to_string(); \
}; \
\
HANDLER::Handle(location, stacktrace(), p_message __VA_OPT__(, ) __VA_ARGS__); \
BREAK; \
} \
} while (false)
#define SOFT_ASSERT(HANDLER, p_assert, p_message, ...) \
do \
{ \
constexpr std::source_location location = std::source_location::current(); \
if (!(p_assert)) [[unlikely]] \
{ \
constexpr auto stacktrace = []() -> std::string \
{ \
const cpptrace::stacktrace stacktrace = cpptrace::generate_trace(); \
return stacktrace.to_string(); \
}; \
\
HANDLER::Handle(location, stacktrace(), p_message __VA_OPT__(, ) __VA_ARGS__); \
BREAK; \
} \
} while (false)
#define CRITICAL_ASSERT(HANDLER, p_assert, p_message, ...) \
do \
{ \
constexpr std::source_location location = std::source_location::current(); \
if (!(p_assert)) [[unlikely]] \
{ \
constexpr auto stacktrace = []() -> std::string \
{ \
const cpptrace::stacktrace stacktrace = cpptrace::generate_trace(); \
return stacktrace.to_string(); \
}; \
\
HANDLER::Handle(location, stacktrace(), p_message __VA_OPT__(, ) __VA_ARGS__); \
BREAK; \
std::abort(); \
} \
} while (false)
#else
#define ASSERT(HANDLER, p_assert, p_message, ...)
#define SOFT_ASSERT(HANDLER, p_assert, p_message, ...)
#define CRITICAL_ASSERT(HANDLER, p_assert, p_message, ...)
#endif
#endif
Bigfoot/Sources/Utils/Include/Utils/Caster.hpp
+60
View File
@@ -0,0 +1,60 @@
/*********************************************************************
* \file Caster.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_CASTER_HPP
#define BIGFOOT_UTILS_CASTER_HPP
#include <Utils/UtilsAssertHandler.hpp>
#include <type_traits>
namespace Bigfoot
{
template<class TO, class FROM>
constexpr TO* Cast(FROM* p_object)
{
constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
static_assert(same, "Trying to cast to an incompatible type!");
return static_cast<TO*>(p_object);
}
template<class TO, class FROM>
constexpr const TO* Cast(const FROM* p_object)
{
constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
static_assert(same, "Trying to cast to an incompatible type!");
return static_cast<const TO*>(p_object);
}
template<class TO, class FROM>
constexpr TO& Cast(FROM& p_object)
{
constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
static_assert(same, "Trying to cast to an incompatible type!");
return static_cast<TO&>(p_object);
}
template<class TO, class FROM>
constexpr const TO& Cast(const FROM& p_object)
{
constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
static_assert(same, "Trying to cast to an incompatible type!");
return static_cast<const TO&>(p_object);
}
template<typename TO, typename FROM, std::enable_if_t<std::is_integral_v<FROM> && std::is_integral_v<TO>, bool> = true>
constexpr TO NumericCast(const FROM& p_from)
{
const TO to = static_cast<TO>(p_from);
SOFT_ASSERT(UtilsAssertHandler, static_cast<FROM>(to) == p_from, "We are losing data for this cast!");
return to;
}
} // namespace Bigfoot
#define BIGFOOT_NUMERIC_CAST(p_to, p_data) Bigfoot::NumericCast<p_to>(p_data)
#define BIGFOOT_OBJECT_CAST(p_to, p_object) Bigfoot::Cast<p_to>(p_object)
#endif
Bigfoot/Sources/Utils/Include/Utils/Concat.h
+17
View File
@@ -0,0 +1,17 @@
/*********************************************************************
* \file Concat.h
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_CONCAT_H
#define BIGFOOT_UTILS_CONCAT_H
#define CONCAT_IMPL(a, b) a b
#define CONCAT(a, b) CONCAT_IMPL(a, b)
#define UNIQUE_IMPL(prefix, line) prefix##_##line
#define UNIQUE(prefix, line) UNIQUE_IMPL(prefix, line)
#define MAKE_UNIQUE_VARIABLE_NAME(prefix) UNIQUE(prefix, __LINE__)
#endif
Bigfoot/Sources/Utils/Include/Utils/Log.hpp
+187
View File
@@ -0,0 +1,187 @@
/*********************************************************************
* \file Log.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_LOG_HPP
#define BIGFOOT_UTILS_LOG_HPP
#if defined BIGFOOT_NOT_OPTIMIZED
#include <Utils/Singleton.hpp>
#include <magic_enum/magic_enum.hpp>
#ifdef BIGFOOT_WINDOWS
#pragma warning(disable: 4702)
#endif
#include <quill/Backend.h>
#include <quill/Frontend.h>
#include <quill/LogMacros.h>
#include <quill/Logger.h>
#include <quill/sinks/ConsoleSink.h>
#if defined BIGFOOT_WINDOWS
#pragma warning(default: 4702)
#endif
namespace Bigfoot
{
class Log
{
public:
enum class LogLevel
{
Debug,
Trace,
Info,
Warn,
Error,
Critical
};
struct LoggerInfo
{
std::string m_name;
LogLevel m_level;
};
Log();
Log(const Log& p_logger) = delete;
Log(Log&& p_logger) = delete;
/**
* Register a logger.
*
* \param p_loggerInfo The logger to register
*/
[[nodiscard]]
quill::Logger* RegisterLogger(const LoggerInfo& p_loggerInfo);
/**
* Register a logger.
*
* \param p_loggerInfo The logger to get
* \return The logger, nullptr if it does not exist
*/
[[nodiscard]]
quill::Logger* GetLogger(const LoggerInfo& p_loggerInfo);
/**
* Changes the loglevel of a Logger.
*
* \param p_loggerInfo The logger to change
* \param p_level The new level
*/
void ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level);
~Log();
Log& operator=(const Log& p_logger) = delete;
Log& operator=(Log&& p_logger) = delete;
private:
/**
* Set the LogLevel of a logger
*
* \param p_loggerInfo The logger to set
*/
void SetLoggerLevel(const LoggerInfo& p_loggerInfo);
enum class SinkType
{
Console
};
/*
* The sinks
*/
std::array<std::shared_ptr<quill::Sink>, magic_enum::enum_count<SinkType>()> m_sinks;
};
} // namespace Bigfoot
#define BIGFOOT_LOG_DEBUG(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_DEBUG(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_DEBUG(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#define BIGFOOT_LOG_TRACE(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_TRACE_L3(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_TRACE_L3(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#define BIGFOOT_LOG_INFO(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_INFO(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_INFO(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#define BIGFOOT_LOG_WARN(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_WARNING(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_WARNING(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#define BIGFOOT_LOG_ERROR(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_ERROR(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_ERROR(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#define BIGFOOT_LOG_FATAL(loggerName, fmt, ...) \
do \
{ \
if (quill::Logger* logger = Bigfoot::Singleton<Bigfoot::Log>::Instance().GetLogger(loggerName)) \
{ \
QUILL_LOG_CRITICAL(logger, fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
else \
{ \
QUILL_LOG_CRITICAL(Bigfoot::Singleton<Bigfoot::Log>::Instance().RegisterLogger(loggerName), \
fmt __VA_OPT__(, ) __VA_ARGS__); \
} \
} while (0)
#endif
#endif
Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp
+106
View File
@@ -0,0 +1,106 @@
/*********************************************************************
* \file Singleton.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_SINGLETON_HPP
#define BIGFOOT_UTILS_SINGLETON_HPP
#include <array>
#include <bit>
#include <type_traits>
#include <utility>
namespace Bigfoot
{
template<class TYPE>
class Singleton
{
public:
Singleton() = delete;
Singleton(const Singleton& p_singleton) = delete;
Singleton(Singleton&& p_singleton) = delete;
~Singleton() = delete;
/**
* Get the instance.
*
* \return The instance
*/
static constexpr TYPE& Instance()
{
return *std::bit_cast<TYPE*>(ms_instance.data());
}
class Lifetime
{
public:
/**
* Constructor.
*
* \param p_args Arguments for the singleton
*/
template<typename... ARGS, typename = std::enable_if_t<!(std::is_same_v<Lifetime, std::decay_t<ARGS>> || ...)>>
explicit Lifetime(ARGS&&... p_args)
{
Initialize(std::forward<ARGS>(p_args)...);
}
Lifetime(const Lifetime& p_lifetime) = delete;
Lifetime(Lifetime&& p_lifetime) = delete;
~Lifetime()
{
Finalize();
}
[[nodiscard]]
Lifetime& operator=(const Lifetime& p_lifetime) = delete;
[[nodiscard]]
Lifetime& operator=(Lifetime&& p_lifetime) = delete;
};
[[nodiscard]]
Singleton& operator=(const Singleton& p_singleton) = delete;
[[nodiscard]]
Singleton& operator=(Singleton&& p_singleton) = delete;
private:
/**
* Initialize the singleton.
*
* \param p_args Arguments for the singleton
*/
template<typename... ARGS>
static void Initialize(ARGS&&... p_args)
{
new (ms_instance.data()) TYPE(std::forward<ARGS>(p_args)...);
ms_initialized = true;
}
/**
* Finalize the singleton.
*
*/
static void Finalize()
{
std::bit_cast<TYPE*>(ms_instance.data())->~TYPE();
ms_initialized = false;
}
/**
* The singleton.
*/
alignas(alignof(TYPE)) inline static std::array<std::byte, sizeof(TYPE)> ms_instance;
/**
* Is the singleton initialized?
*/
inline static bool ms_initialized = false;
};
} // namespace Bigfoot
#endif
Bigfoot/Sources/Utils/Include/Utils/TargetLogger.generated.hpp.in
+21
View File
@@ -0,0 +1,21 @@
@AUTO_GENERATED_COMMENT@
/*********************************************************************
* \file @LOGGER_FILENAME@.generated.hpp
*
*********************************************************************/
#ifndef BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
#define BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
#include <Utils/Log.hpp>
#if defined BIGFOOT_NOT_OPTIMIZED
namespace Bigfoot
{
/*
* Logger
*/
inline Log::LoggerInfo @LOGGER_NAME@ {"@LOGGER_NAME@", Log::LogLevel::Trace};
}
#endif
#endif
Bigfoot/Sources/Utils/Include/Utils/TargetMacros.h
+21
View File
@@ -0,0 +1,21 @@
/*********************************************************************
* \file TargetMacros.h
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_TARGETMACROS_H
#define BIGFOOT_UTILS_TARGETMACROS_H
#if defined BIGFOOT_OPTIMIZED
#define BIGFOOT_OPTIMIZED_ONLY(...) __VA_ARGS__
#define BIGFOOT_NOT_OPTIMIZED_ONLY(...)
#define BIGFOOT_OPTIMIZED_OR_NOT(p_optimized, p_notOptimized) p_optimized
#endif
#if defined BIGFOOT_NOT_OPTIMIZED
#define BIGFOOT_OPTIMIZED_ONLY(...)
#define BIGFOOT_NOT_OPTIMIZED_ONLY(...) __VA_ARGS__
#define BIGFOOT_OPTIMIZED_OR_NOT(p_optimized, p_notOptimized) p_notOptimized
#endif
#endif
Bigfoot/Sources/Utils/Include/Utils/UtilsAssertHandler.hpp
+49
View File
@@ -0,0 +1,49 @@
/*********************************************************************
* \file UtilsAssertHandler.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
#define BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
#include <Utils/Assert.hpp>
#include <format>
#include <source_location>
#include <string_view>
namespace Bigfoot
{
class UtilsAssertHandler
{
public:
UtilsAssertHandler() = delete;
UtilsAssertHandler(const UtilsAssertHandler& p_handler) = delete;
UtilsAssertHandler(UtilsAssertHandler&& p_handler) = delete;
~UtilsAssertHandler() = delete;
/**
* Handle an assertion.
*
* \param p_location Location of the assertion.
* \param p_stacktrace The stack trace
* \param p_format Format string for the assertion message.
* \param p_args Arguments for the format string.
*/
template<typename... ARGS>
static void Handle([[maybe_unused]] const std::source_location& p_location,
[[maybe_unused]] const std::string_view p_stacktrace,
[[maybe_unused]] std::format_string<ARGS...> p_format,
[[maybe_unused]] ARGS&&... p_args)
{
// We dont have access to logging capabilities here
// So no log
}
UtilsAssertHandler& operator=(const UtilsAssertHandler& p_handler) = delete;
UtilsAssertHandler& operator=(UtilsAssertHandler&& p_handler) = delete;
};
} // namespace Bigfoot
#endif
Bigfoot/Sources/Utils/Include/Utils/Version.hpp
+158
View File
@@ -0,0 +1,158 @@
/*********************************************************************
* \file Version.hpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#ifndef BIGFOOT_UTILS_VERSION_HPP
#define BIGFOOT_UTILS_VERSION_HPP
#include <Utils/Caster.hpp>
#include <Utils/TargetMacros.h>
#include <cstdint>
#include <format>
#include <string>
namespace Bigfoot
{
class Version
{
public:
Version() = default;
/**
* Constructor.
*
* \param p_combined The combined version.
*/
explicit constexpr Version(const std::uint32_t p_combined):
m_combined(p_combined)
{
}
/**
* Constructor.
*
* \param p_major Major
* \param p_minor Minor
* \param p_patch Patch
*/
constexpr Version(const std::uint8_t p_major, const std::uint8_t p_minor, const std::uint8_t p_patch):
m_combined((p_major << 16) | (p_minor << 8) | p_patch)
{
}
Version(const Version& p_version) = default;
Version(Version&& p_version) = default;
~Version() = default;
/**
* Get the major part of the version.
*
* \return The major part of the version.
*/
[[nodiscard]]
constexpr std::uint8_t Major() const
{
constexpr std::uint32_t mask = 0b00000000111111110000000000000000;
return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 16);
}
/**
* Get the minor part of the version.
*
* \return The minor part of the version.
*/
[[nodiscard]]
constexpr std::uint8_t Minor() const
{
constexpr std::uint32_t mask = 0b00000000000000001111111100000000;
return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 8);
}
/**
* Get the patch part of the version.
*
* \return The patch part of the version.
*/
[[nodiscard]]
constexpr std::uint8_t Patch() const
{
constexpr std::uint32_t mask = 0b00000000000000000000000011111111;
return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask));
}
[[nodiscard]]
constexpr operator std::uint32_t() const
{
return m_combined;
}
[[nodiscard]] operator std::string() const;
constexpr Version& operator=(const Version& p_version) = default;
constexpr Version& operator=(Version&& p_version) = default;
[[nodiscard]]
constexpr bool operator>(const Version& p_version) const
{
return m_combined > p_version.m_combined;
}
[[nodiscard]]
constexpr bool operator<(const Version& p_version) const
{
return m_combined < p_version.m_combined;
}
[[nodiscard]]
constexpr bool operator>=(const Version& p_version) const
{
return m_combined >= p_version.m_combined;
}
[[nodiscard]]
constexpr bool operator<=(const Version& p_version) const
{
return m_combined <= p_version.m_combined;
}
[[nodiscard]]
constexpr bool operator==(const Version& p_version) const = default;
[[nodiscard]]
constexpr bool operator!=(const Version& p_version) const = default;
private:
/**
* The combined version.
*/
std::uint32_t m_combined = 0;
};
} // namespace Bigfoot
/****************************************************************************************/
#if defined BIGFOOT_NOT_OPTIMIZED
template<>
struct std::formatter<Bigfoot::Version>
{
template<typename ParseContext>
constexpr auto parse(ParseContext& p_context)
{
return p_context.begin();
}
template<typename FormatContext>
auto format(const Bigfoot::Version& p_version, FormatContext& p_context) const
{
return std::format_to(p_context.out(), "{}", static_cast<std::string>(p_version));
}
};
#endif
#endif
Bigfoot/Sources/Utils/Log.cpp
+90
View File
@@ -0,0 +1,90 @@
/*******************************************************************
* \file Log.cpp
*
* \author Romain BOULLARD
* \date October 2025
*********************************************************************/
#include <Utils/Log.hpp>
#if defined BIGFOOT_NOT_OPTIMIZED
namespace Bigfoot
{
Log::Log()
{
quill::Backend::start();
m_sinks[magic_enum::enum_integer(SinkType::Console)] = quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
std::string {magic_enum::enum_name(SinkType::Console)});
}
/****************************************************************************************/
quill::Logger* Log::RegisterLogger(const LoggerInfo& p_loggerInfo)
{
quill::Logger* logger = quill::Frontend::create_or_get_logger(p_loggerInfo.m_name,
m_sinks[magic_enum::enum_integer(SinkType::Console)]);
SetLoggerLevel(p_loggerInfo);
return logger;
}
/****************************************************************************************/
quill::Logger* Log::GetLogger(const LoggerInfo& p_loggerInfo)
{
return quill::Frontend::get_logger(p_loggerInfo.m_name);
}
/****************************************************************************************/
void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level)
{
p_loggerInfo.m_level = p_level;
SetLoggerLevel(p_loggerInfo);
}
/****************************************************************************************/
void Log::SetLoggerLevel(const LoggerInfo& p_loggerInfo)
{
constexpr auto logLevelToQuillLogLevel = [](const LogLevel p_level) constexpr -> quill::LogLevel
{
switch (p_level)
{
case LogLevel::Debug:
return quill::LogLevel::Debug;
case LogLevel::Trace:
return quill::LogLevel::TraceL3;
case LogLevel::Info:
return quill::LogLevel::Info;
case LogLevel::Warn:
return quill::LogLevel::Warning;
case LogLevel::Error:
return quill::LogLevel::Error;
case LogLevel::Critical:
return quill::LogLevel::Critical;
}
return quill::LogLevel::TraceL3;
};
if (quill::Logger* logger = GetLogger(p_loggerInfo))
{
logger->set_log_level(logLevelToQuillLogLevel(p_loggerInfo.m_level));
}
}
/****************************************************************************************/
Log::~Log()
{
for (quill::Logger* logger: quill::Frontend::get_all_loggers())
{
quill::Frontend::remove_logger(logger);
}
quill::Backend::stop();
}
} // namespace Bigfoot
#endif
Bigfoot/Sources/Utils/Version.cpp
+15
View File
@@ -0,0 +1,15 @@
/*********************************************************************
* \file Version.cpp
*
* \author Romain BOULLARD
* \date January 2023
*********************************************************************/
#include <Utils/Version.hpp>
namespace Bigfoot
{
Version::operator std::string() const
{
return std::format("{}.{}.{}", Major(), Minor(), Patch());
}
} // namespace Bigfoot