All headers reformatted with updated clang-format settings

1 files changed, 51 insertions, 37 deletions

diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index 9bc71e1..be331a1 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif // __cplusplus
 #include "lua.h"
 #include "lualib.h"
@@ -65,17 +66,17 @@ template <typename... ARGS>
 #define DEBUGSPEW_CODE(_code) _code
 #define DEBUGSPEW_OR_NOT(a_, b_) a_
 #define DEBUGSPEW_PARAM_COMMA(param_) param_,
-#define DEBUGSPEW_COMMA_PARAM( param_) , param_
+#define DEBUGSPEW_COMMA_PARAM(param_) , param_
 #else // USE_DEBUG_SPEW()
 #define DEBUGSPEW_CODE(_code)
 #define DEBUGSPEW_OR_NOT(a_, b_) b_
 #define DEBUGSPEW_PARAM_COMMA(param_)
-#define DEBUGSPEW_COMMA_PARAM( param_)
+#define DEBUGSPEW_COMMA_PARAM(param_)
 #endif // USE_DEBUG_SPEW()
 
 #ifdef NDEBUG
 
-#define LUA_ASSERT(L,c) ; //nothing
+#define LUA_ASSERT(L, c) ; // nothing
 
 #define STACK_CHECK_START_REL(L, offset_)
 #define STACK_CHECK_START_ABS(L, offset_)
@@ -87,8 +88,7 @@ template <typename... ARGS>
 
 inline void LUA_ASSERT_IMPL(lua_State* L_, bool cond_, char const* file_, size_t const line_, char const* txt_)
 {
-    if (!cond_)
-    {
+    if (!cond_) {
         raise_luaL_error(L_, "LUA_ASSERT %s:%llu '%s'", file_, line_, txt_);
     }
 }
@@ -120,8 +120,7 @@ class StackChecker
     : m_L{ L_ }
     , m_oldtop{ lua_gettop(L_) - offset_ }
     {
-        if ((offset_ < 0) || (m_oldtop < 0))
-        {
+        if ((offset_ < 0) || (m_oldtop < 0)) {
             assert(false);
             raise_luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), offset_, file_, line_);
         }
@@ -131,8 +130,7 @@ class StackChecker
     : m_L{ L_ }
     , m_oldtop{ 0 }
     {
-        if (lua_gettop(m_L) != pos_)
-        {
+        if (lua_gettop(m_L) != pos_) {
             assert(false);
             raise_luaL_error(m_L, "STACK INIT ASSERT failed (%d not %d): %s:%llu", lua_gettop(m_L), pos_, file_, line_);
         }
@@ -148,11 +146,9 @@ class StackChecker
     // verify if the distance between the current top and the initial one is what we expect
     void check(int expected_, char const* file_, size_t const line_)
     {
-        if (expected_ != LUA_MULTRET)
-        {
+        if (expected_ != LUA_MULTRET) {
             int const actual{ lua_gettop(m_L) - m_oldtop };
-            if (actual != expected_)
-            {
+            if (actual != expected_) {
                 assert(false);
                 raise_luaL_error(m_L, "STACK ASSERT failed (%d not %d): %s:%llu", actual, expected_, file_, line_);
             }
@@ -160,10 +156,26 @@ class StackChecker
     }
 };
 
-#define STACK_CHECK_START_REL(L, offset_) StackChecker stackChecker_##L{L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_START_ABS(L, offset_) StackChecker stackChecker_##L{L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_RESET_REL(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__}
-#define STACK_CHECK_RESET_ABS(L, offset_) stackChecker_##L = StackChecker{L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__}
+#define STACK_CHECK_START_REL(L, offset_) \
+    StackChecker stackChecker_##L \
+    { \
+        L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_START_ABS(L, offset_) \
+    StackChecker stackChecker_##L \
+    { \
+        L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_RESET_REL(L, offset_) \
+    stackChecker_##L = StackChecker \
+    { \
+        L, StackChecker::Relative{ offset_ }, __FILE__, __LINE__ \
+    }
+#define STACK_CHECK_RESET_ABS(L, offset_) \
+    stackChecker_##L = StackChecker \
+    { \
+        L, StackChecker::Absolute{ offset_ }, __FILE__, __LINE__ \
+    }
 #define STACK_CHECK(L, offset_) stackChecker_##L.check(offset_, __FILE__, __LINE__)
 
 #endif // NDEBUG
@@ -172,8 +184,7 @@ class StackChecker
 
 inline void STACK_GROW(lua_State* L, int n_)
 {
-    if (!lua_checkstack(L, n_))
-    {
+    if (!lua_checkstack(L, n_)) {
         raise_luaL_error(L, "Cannot grow stack!");
     }
 }
@@ -185,23 +196,20 @@ inline void STACK_GROW(lua_State* L, int n_)
 // #################################################################################################
 
 // a small helper to extract a full userdata pointer from the stack in a safe way
-template<typename T>
+template <typename T>
 [[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
 {
     LUA_ASSERT(L, lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
     return static_cast<T*>(lua_touserdata(L, index_));
 }
 
-template<typename T>
+template <typename T>
 [[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
 {
     LUA_ASSERT(L, lua_isnil(L, index_) || lua_islightuserdata(L, index_));
-    if constexpr (std::is_pointer_v<T>)
-    {
+    if constexpr (std::is_pointer_v<T>) {
         return static_cast<T>(lua_touserdata(L, index_));
-    }
-    else
-    {
+    } else {
         return static_cast<T*>(lua_touserdata(L, index_));
     }
 }
@@ -223,23 +231,27 @@ template <typename T, auto = [] {}, typename specialization = void>
 class Unique
 {
     private:
-
     T m_val;
 
     public:
-
     Unique() = default;
     operator T() const { return m_val; }
-    explicit Unique(T b_) : m_val{ b_ } {}
+    explicit Unique(T b_)
+    : m_val{ b_ }
+    {
+    }
 };
 
 template <typename T, auto lambda>
-class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>> : public T
+class Unique<T, lambda, std::enable_if_t<!std::is_scalar_v<T>>>
+: public T
 {
     public:
-
     using T::T;
-    explicit Unique(T const& b_) : T{ b_ } {}
+    explicit Unique(T const& b_)
+    : T{ b_ }
+    {
+    }
 };
 
 // #################################################################################################
@@ -252,14 +264,16 @@ using DestState = Unique<lua_State*>;
 // A helper to issue an error if the provided optional doesn't contain a value
 // we can't use std::optional::value_or(luaL_error(...)), because the 'or' value is always evaluated
 template <typename T>
-concept IsOptional = requires(T x){ x.value_or(T{}); };
+concept IsOptional = requires(T x)
+{
+    x.value_or(T{});
+};
 
-template<typename T, typename ...Ts>
+template <typename T, typename... Ts>
 requires IsOptional<T>
 typename T::value_type const& OptionalValue(T const& x_, Ts... args_)
 {
-    if (!x_.has_value())
-    {
+    if (!x_.has_value()) {
         raise_luaL_error(std::forward<Ts>(args_)...);
     }
     return x_.value();