mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2024-11-08 00:37:15 +01:00
Update sqratUtil.h
This commit is contained in:
Sandu Liviu Catalin
parent
52cfa235be
commit
1f25b3ea60
@ -35,6 +35,7 @@
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <exception>
|
||||
#include <type_traits>
|
||||
#include <unordered_map>
|
||||
|
||||
#include <Poco/Exception.h>
|
||||
@ -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<class... A>
|
||||
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<class T> struct remove_const {typedef T type;};
|
||||
template<class T> struct remove_const<const T> {typedef T type;};
|
||||
template<class T> struct remove_volatile {typedef T type;};
|
||||
template<class T> struct remove_volatile<volatile T> {typedef T type;};
|
||||
template<class T> struct remove_cv {typedef typename remove_volatile<typename remove_const<T>::type>::type type;};
|
||||
template<class T> struct is_pointer_helper {static constexpr bool value = false;};
|
||||
template<class T> struct is_pointer_helper<T*> {static constexpr bool value = true;};
|
||||
template<class T,class D> struct is_pointer_helper<SharedPtr<T,D> > {static constexpr bool value = true;};
|
||||
template<class T,class D> struct is_pointer_helper<WeakPtr<T,D> > {static constexpr bool value = true;};
|
||||
template<class T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
|
||||
template<class T> struct is_reference {static constexpr bool value = false;};
|
||||
template<class T> struct is_reference<T&> {static constexpr bool value = true;};
|
||||
template<class T> using remove_const = std::remove_const< T >;
|
||||
template<class T> using remove_volatile = std::remove_volatile< T >;
|
||||
template<class T> using remove_cv = std::remove_cv< T >;
|
||||
template<class T> struct is_pointer : public std::is_pointer< T > { };
|
||||
template<class T,class D> struct is_pointer<SharedPtr<T,D> > : public std::true_type { };
|
||||
template<class T,class D> struct is_pointer<WeakPtr<T,D> > : public std::true_type { };
|
||||
template<class T> using is_reference = std::is_lvalue_reference< T >;
|
||||
/// @endcond
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user