diff --git a/module/Sqrat/sqratUtil.h b/module/Sqrat/sqratUtil.h index f965af89..03ff04f7 100644 --- a/module/Sqrat/sqratUtil.h +++ b/module/Sqrat/sqratUtil.h @@ -35,6 +35,7 @@ #include #include #include +#include #include #include @@ -1580,12 +1581,31 @@ public: } }; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/// Helper structure for one element from the top of stack. Uses default global VM instead. +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +struct SqPopTopGuardLite +{ + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Base constructor. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + SqPopTopGuardLite() noexcept = default; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Destructor. Pops the specified elements from the stack. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ~SqPopTopGuardLite() + { + sq_poptop(SqVM()); + } +}; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Helper structure for one element from the top of stack. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// struct SqPopTopGuard { HSQUIRRELVM mVM; // The VM from which the elements must be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Base constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1603,13 +1623,70 @@ struct SqPopTopGuard } }; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/// Helper structure for popping elements from the stack. Uses default global VM instead. +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +struct SqPopGuardLite +{ + SQInteger mNum{0}; // The number of elements to be popped. + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Base constructor. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + explicit SqPopGuardLite(SQInteger num) noexcept + : mNum(num) + { + //... + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Destructor. Pops the specified elements from the stack. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ~SqPopGuardLite() + { + sq_pop(SqVM(), mNum); + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Increment the number of elements to be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + SqPopGuardLite & operator ++ () + { + ++mNum; + return *this; + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Decrement the number of elements to be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + SqPopGuardLite & operator -- () + { + --mNum; + return *this; + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Increase the number of elements to be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + SqPopGuardLite & operator += (SQInteger n) + { + mNum += n; + return *this; + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Decrease the number of elements to be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + SqPopGuardLite & operator -= (SQInteger n) + { + mNum -= n; + return *this; + } +}; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Helper structure for popping elements from the stack. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// struct SqPopGuard { - HSQUIRRELVM mVM; // The VM from which the elements must be popped. - SQInteger mNum; // The number of elements to be popped. + HSQUIRRELVM mVM{nullptr}; // The VM from which the elements must be popped. + SQInteger mNum{0}; // The number of elements to be popped. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Base constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1659,17 +1736,79 @@ struct SqPopGuard } }; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/// Implements RAII to restore the VM stack to it's initial size on function exit. Uses default global VM instead. +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +struct StackGuardLite +{ + SQInteger mTop{0}; ///< The top of the stack when this instance was created. + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Default constructor. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + StackGuardLite() noexcept + : mTop(sq_gettop(SqVM())) + { + /* ... */ + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Copy constructor. (disabled) + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + StackGuardLite(const StackGuardLite &) = delete; + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Move constructor. (disabled) + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + StackGuardLite(StackGuardLite &&) = delete; + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Destructor. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ~StackGuardLite() + { + Restore(); + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Copy assignment operator. (disabled) + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + StackGuardLite & operator = (const StackGuardLite &) = delete; + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Move assignment operator. (disabled) + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + StackGuardLite & operator = (StackGuardLite &&) = delete; + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Restore the stack to what was known to be. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + void Restore() const + { + auto vm = SqVM(); + // Retrieve the new stack top + const SQInteger top = sq_gettop(vm); + // Did the stack size change? + if (top > mTop) + { + sq_pop(vm, top - mTop); // Trim the stack + } + } +}; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Implements RAII to restore the VM stack to it's initial size on function exit. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// struct StackGuard { + HSQUIRRELVM mVM{nullptr}; ///< The VM where the stack should be restored. + SQInteger mTop{0}; ///< The top of the stack when this instance was created. + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Default constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// StackGuard() - : m_VM(SqVM()), m_Top(sq_gettop(m_VM)) + : mVM(SqVM()), mTop(sq_gettop(mVM)) { /* ... */ } @@ -1677,8 +1816,8 @@ struct StackGuard ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Base constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - StackGuard(HSQUIRRELVM vm) - : m_VM(vm), m_Top(sq_gettop(vm)) + explicit StackGuard(HSQUIRRELVM vm) + : mVM(vm), mTop(sq_gettop(vm)) { /* ... */ } @@ -1717,18 +1856,13 @@ struct StackGuard void Restore() const { // Retrieve the new stack top - const SQInteger top = sq_gettop(m_VM); + const SQInteger top = sq_gettop(mVM); // Did the stack size change? - if (top > m_Top) + if (top > mTop) { - sq_pop(m_VM, top - m_Top); // Trim the stack + sq_pop(mVM, top - mTop); // Trim the stack } } - -private: - - HSQUIRRELVM m_VM; ///< The VM where the stack should be restored. - SQInteger m_Top; ///< The top of the stack when this instance was created. }; @@ -2131,18 +2265,13 @@ inline void ErrorToException(HSQUIRRELVM vm, bool keep = false) { ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template < typename T > struct DeleteGuard { -private: - - // -------------------------------------------------------------------------------------------- - T * m_Ptr; // Pointer to the instance to manage. - -public: + T * mPtr; // Pointer to the instance to manage. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Default constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// explicit DeleteGuard(T * ptr) - : m_Ptr(ptr) + : mPtr(ptr) { /* ... */ } @@ -2152,7 +2281,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template explicit DeleteGuard(SqInPlace SQ_UNUSED_ARG(t), A&&... a) - : m_Ptr(new T(std::forward< A >(a)...)) + : mPtr(new T(std::forward< A >(a)...)) { /* ... */ } @@ -2166,9 +2295,9 @@ public: /// Move constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// DeleteGuard(DeleteGuard && o) noexcept - : m_Ptr(o.m_Ptr) + : mPtr(o.mPtr) { - o.m_Ptr = nullptr; + o.mPtr = nullptr; } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2176,9 +2305,9 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ~DeleteGuard() { - if (m_Ptr) + if (mPtr) { - delete m_Ptr; + delete mPtr; } } @@ -2197,7 +2326,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// operator T * () const { - return m_Ptr; + return mPtr; } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2205,7 +2334,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// T * Get() const { - return m_Ptr; + return mPtr; } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2213,7 +2342,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void Release() { - m_Ptr = nullptr; + mPtr = nullptr; } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2221,8 +2350,8 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// T * Grab() { - T * ptr = m_Ptr; - m_Ptr = nullptr; + T * ptr = mPtr; + mPtr = nullptr; return ptr; } }; @@ -2320,18 +2449,13 @@ template < typename T > T * SqChainedInstances< T >::sHead = nullptr; /// @cond DEV /// Used internally to get and manipulate the underlying type of variables - retrieved from cppreference.com ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -template struct remove_const {typedef T type;}; -template struct remove_const {typedef T type;}; -template struct remove_volatile {typedef T type;}; -template struct remove_volatile {typedef T type;}; -template struct remove_cv {typedef typename remove_volatile::type>::type type;}; -template struct is_pointer_helper {static constexpr bool value = false;}; -template struct is_pointer_helper {static constexpr bool value = true;}; -template struct is_pointer_helper > {static constexpr bool value = true;}; -template struct is_pointer_helper > {static constexpr bool value = true;}; -template struct is_pointer : is_pointer_helper::type> {}; -template struct is_reference {static constexpr bool value = false;}; -template struct is_reference {static constexpr bool value = true;}; +template using remove_const = std::remove_const< T >; +template using remove_volatile = std::remove_volatile< T >; +template using remove_cv = std::remove_cv< T >; +template struct is_pointer : public std::is_pointer< T > { }; +template struct is_pointer > : public std::true_type { }; +template struct is_pointer > : public std::true_type { }; +template using is_reference = std::is_lvalue_reference< T >; /// @endcond