From 49aa85102cd6942aca3aacd3929dc9cc679460fb Mon Sep 17 00:00:00 2001 From: Sandu Liviu Catalin Date: Mon, 13 Apr 2020 13:45:24 +0300 Subject: [PATCH] Minor changes to move semantics in sqrat library. --- sqrat/sqrat/sqratArray.h | 16 ++--- sqrat/sqrat/sqratFunction.h | 4 +- sqrat/sqrat/sqratObject.h | 123 ++++++++++++++++++++++++++++++++++-- sqrat/sqrat/sqratTable.h | 40 ++++++++---- sqrat/sqrat/sqratUtil.h | 24 +++---- 5 files changed, 168 insertions(+), 39 deletions(-) diff --git a/sqrat/sqrat/sqratArray.h b/sqrat/sqrat/sqratArray.h index 5fbd214f..fa8e4c40 100644 --- a/sqrat/sqrat/sqratArray.h +++ b/sqrat/sqrat/sqratArray.h @@ -72,7 +72,7 @@ public: /// \param obj An Object that should already represent a Squirrel array /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - ArrayBase(Object&& obj) : Object(std::move(obj)) { + ArrayBase(Object&& obj) noexcept : Object(std::forward< Object >(obj)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -90,7 +90,7 @@ public: /// \param sa ArrayBase to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - ArrayBase(ArrayBase&& sa) : Object(std::move(sa)) { + ArrayBase(ArrayBase&& sa) noexcept : Object(std::forward< ArrayBase >(sa)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -124,8 +124,8 @@ public: /// \return The ArrayBase itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - ArrayBase& operator=(ArrayBase&& sa) { - Object::operator = (std::move(sa)); + ArrayBase& operator=(ArrayBase&& sa) noexcept { + Object::operator = (std::forward< ArrayBase >(sa)); return *this; } @@ -595,7 +595,7 @@ public: /// \param obj An Object that should already represent a Squirrel array /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Array(Object&& obj) : ArrayBase(std::move(obj)) { + Array(Object&& obj) noexcept : ArrayBase(std::forward< Object >(obj)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -623,7 +623,7 @@ public: /// \param sa Array to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Array(Array&& sa) : ArrayBase(std::move(sa)) { + Array(Array&& sa) noexcept : ArrayBase(std::forward< Array >(sa)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -647,8 +647,8 @@ public: /// \return The Array itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Array& operator=(Array&& sa) { - ArrayBase::operator = (std::move(sa)); + Array& operator=(Array&& sa) noexcept { + ArrayBase::operator = (std::forward< Array >(sa)); return *this; } diff --git a/sqrat/sqrat/sqratFunction.h b/sqrat/sqrat/sqratFunction.h index b874443d..ea325077 100644 --- a/sqrat/sqrat/sqratFunction.h +++ b/sqrat/sqrat/sqratFunction.h @@ -60,7 +60,7 @@ struct Function { sq_addref(DefaultVM::Get_(), &mObj); } // Move constructor - Function(Function&& sf) : mEnv(sf.mEnv), mObj(sf.mObj) { + Function(Function&& sf) noexcept : mEnv(sf.mEnv), mObj(sf.mObj) { sq_resetobject(&sf.GetEnv()); sq_resetobject(&sf.GetFunc()); } @@ -121,7 +121,7 @@ struct Function { return *this; } // Move Assignment operator - Function& operator=(Function&& sf) { + Function& operator=(Function&& sf) noexcept { Release(); mEnv = sf.mEnv; mObj = sf.mObj; diff --git a/sqrat/sqrat/sqratObject.h b/sqrat/sqrat/sqratObject.h index 8cbe7d86..6e23275b 100644 --- a/sqrat/sqrat/sqratObject.h +++ b/sqrat/sqrat/sqratObject.h @@ -1,3 +1,6 @@ +#ifndef HEADER_1593521F164F3DCC +#define HEADER_1593521F164F3DCC + // // SqratObject: Referenced Squirrel Object Wrapper // @@ -43,6 +46,8 @@ namespace Sqrat { +struct LightObj; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// The base class for classes that represent Squirrel objects /// @@ -89,11 +94,27 @@ public: /// \param so Object to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Object(Object&& so) : vm(so.vm), obj(so.obj), release(so.release) { - sq_resetobject(&so.GetObject()); + Object(Object&& so) noexcept : vm(so.vm), obj(so.obj), release(so.release) { + so.ResetObj(); so.release = false; } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Light object copy constructor + /// + /// \param so Object to copy + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Object(const LightObj& so); + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Light object copy constructor + /// + /// \param so Object to move + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Object(LightObj&& so) noexcept; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Constructs an Object from a Squirrel object /// @@ -101,7 +122,7 @@ public: /// \param v VM that the object will exist in /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Object(HSQOBJECT o, HSQUIRRELVM v = DefaultVM::Get()) : vm(v), obj(o), release(true) { + Object(HSQOBJECT o, HSQUIRRELVM v = DefaultVM::Get()) : vm(v), obj(o), release(!sq_isnull(o)) { sq_addref(vm, &obj); } @@ -115,6 +136,7 @@ public: Object(SQInteger i, HSQUIRRELVM v = DefaultVM::Get()) : vm(v), release(true) { if (SQ_FAILED(sq_getstackobj(vm, i, &obj))) { sq_resetobject(&obj); + release = false; } else { sq_addref(vm, &obj); } @@ -213,18 +235,55 @@ public: /// \return The Object itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Object& operator=(Object&& so) { + Object& operator=(Object&& so) noexcept { if(release) { Release(); } vm = so.vm; obj = so.obj; release = so.release; - sq_resetobject(&so.GetObject()); - so.release = false; + so.Reset(); return *this; } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Assignment operator + /// + /// \param so LightObj to copy + /// + /// \return The Object itself + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Object& operator=(const LightObj& so); + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Assignment operator + /// + /// \param so LightObj to move + /// + /// \return The Object itself + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + Object& operator=(LightObj&& so) noexcept; + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Discards obj member value without releasing the reference. + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + void ResetObj() { + sq_resetobject(&GetObject()); + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Discards any member values without releasing any references. + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + void Reset() { + vm = nullptr; + sq_resetobject(&GetObject()); + release = false; + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Gets the Squirrel VM for this Object (reference) /// @@ -954,6 +1013,22 @@ struct LightObj { return *this; } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Discards obj member value without releasing the reference. Only present for compatibility with Object type. + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + void ResetObj() { + sq_resetobject(&mObj); + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Discards any member values without releasing any references. Only present for compatibility with Object type. + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + void Reset() { + sq_resetobject(&mObj); + } + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Gets the type of the LightObj as defined by the Squirrel API /// @@ -1081,6 +1156,40 @@ struct LightObj { } }; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +inline Object::Object(const LightObj& so) : vm(SqVM()), obj(so.mObj), release(!so.IsNull()) { + sq_addref(vm, &obj); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +inline Object::Object(LightObj&& so) noexcept : vm(SqVM()), obj(so.mObj), release(!so.IsNull()) { + so.Reset(); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +inline Object& Object::operator=(const LightObj& so) { + if(release) { + Release(); + } + vm = SqVM(); + obj = so.mObj; + release = !so.IsNull(); + sq_addref(vm, &GetObject()); + return *this; +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +inline Object& Object::operator=(LightObj&& so) noexcept { + if(release) { + Release(); + } + vm = SqVM(); + obj = so.mObj; + release = !so.IsNull(); + so.Reset(); + return *this; +} + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Used to get and push LightObj instances to and from the stack as references (LightObj is always a reference) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1207,3 +1316,5 @@ struct Var : Var {Var(HSQUIRRELVM vm, SQInteger idx } #endif +#endif // header guard + diff --git a/sqrat/sqrat/sqratTable.h b/sqrat/sqrat/sqratTable.h index 8eca9e95..7b311172 100644 --- a/sqrat/sqrat/sqratTable.h +++ b/sqrat/sqrat/sqratTable.h @@ -72,7 +72,25 @@ public: /// \param obj An Object that should already represent a Squirrel table /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TableBase(Object&& obj) : Object(std::move(obj)) { + TableBase(Object&& obj) noexcept : Object(std::forward< Object >(obj)) { + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Construct the TableBase from an Object that already exists + /// + /// \param obj An Object that should already represent a Squirrel table + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TableBase(const LightObj& obj) : Object(obj) { + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// Construct the TableBase from an Object that already exists + /// + /// \param obj An Object that should already represent a Squirrel table + /// + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TableBase(LightObj&& obj) : Object(std::forward< LightObj >(obj)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -100,7 +118,7 @@ public: /// \param st TableBase to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TableBase(TableBase&& st) : Object(std::move(st)) { + TableBase(TableBase&& st) noexcept : Object(std::forward< TableBase >(st)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -124,8 +142,8 @@ public: /// \return The TableBase itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TableBase& operator=(TableBase&& st) { - Object::operator = (std::move(st)); + TableBase& operator=(TableBase&& st) noexcept { + Object::operator = (std::forward< TableBase >(st)); return *this; } @@ -509,7 +527,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class Table : public TableBase { public: - + using TableBase::TableBase; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Default constructor (null) /// @@ -548,7 +566,7 @@ public: /// \param obj An Object that should already represent a Squirrel table /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Table(Object&& obj) : TableBase(std::move(obj)) { + Table(Object&& obj) noexcept : TableBase(std::forward< Table >(obj)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -590,7 +608,7 @@ public: /// \param st Table to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Table(Table&& st) : TableBase(std::move(st)) { + Table(Table&& st) noexcept : TableBase(std::forward< Table >(st)) { } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -614,8 +632,8 @@ public: /// \return The Table itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - Table& operator=(Table&& st) { - TableBase::operator = (std::move(st)); + Table& operator=(Table&& st) noexcept { + TableBase::operator = (std::forward< Table >(st)); return *this; } @@ -627,7 +645,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class RootTable : public TableBase { public: - + using TableBase::TableBase; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Constructs a RootTable object to represent the given VM's root table /// @@ -648,7 +666,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class RegistryTable : public TableBase { public: - + using TableBase::TableBase; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Constructs a RegistryTable object to represent the given VM's registry table /// diff --git a/sqrat/sqrat/sqratUtil.h b/sqrat/sqrat/sqratUtil.h index 00c17ea5..23cd1c7c 100644 --- a/sqrat/sqrat/sqratUtil.h +++ b/sqrat/sqrat/sqratUtil.h @@ -423,7 +423,7 @@ public: /// \param msg A nice error message /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - explicit Exception(string && msg) : message(msg) {} + explicit Exception(string && msg) noexcept : message(std::forward< string >(msg)) {} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Constructs an exception @@ -698,7 +698,7 @@ public: /// \param other SharedPtr to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - SharedPtr(SharedPtr&& other) + SharedPtr(SharedPtr&& other) noexcept : m_Ptr(other.m_Ptr) , m_Ref(other.m_Ref) { @@ -715,7 +715,7 @@ public: /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template - SharedPtr(SharedPtr&& other) + SharedPtr(SharedPtr&& other) noexcept : m_Ptr(static_cast(other.m_Ptr)) , m_Ref(other.m_Ref) { @@ -800,7 +800,7 @@ public: /// \return The SharedPtr itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - SharedPtr& operator=(SharedPtr&& other) + SharedPtr& operator=(SharedPtr&& other) noexcept { if (m_Ptr != other.m_Ptr) { @@ -827,7 +827,7 @@ public: /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template - SharedPtr& operator=(SharedPtr&& other) + SharedPtr& operator=(SharedPtr&& other) noexcept { if (m_Ptr != static_cast(other.m_Ptr)) { @@ -1193,7 +1193,7 @@ public: /// \param other WeakPtr to move /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - WeakPtr(WeakPtr&& other) + WeakPtr(WeakPtr&& other) noexcept : m_Ptr(other.m_Ptr) , m_Ref(other.m_Ref) { @@ -1210,7 +1210,7 @@ public: /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template - WeakPtr(WeakPtr&& other) + WeakPtr(WeakPtr&& other) noexcept : m_Ptr(static_cast(other.m_Ptr)) , m_Ref(other.m_Ref) { @@ -1293,7 +1293,7 @@ public: /// \return The WeakPtr itself /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - WeakPtr& operator=(WeakPtr&& other) + WeakPtr& operator=(WeakPtr&& other) noexcept { if (m_Ptr != other.m_Ptr) { @@ -1320,7 +1320,7 @@ public: /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// template - WeakPtr& operator=(WeakPtr&& other) + WeakPtr& operator=(WeakPtr&& other) noexcept { if (m_Ptr != static_cast(other.m_Ptr)) { @@ -1683,7 +1683,7 @@ struct StackStrF ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Move constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - StackStrF(StackStrF && o) + StackStrF(StackStrF && o) noexcept : mPtr(o.mPtr) , mLen(o.mLen) , mRes(o.mRes) @@ -1718,7 +1718,7 @@ struct StackStrF ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Move assignment operator. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - StackStrF & operator = (StackStrF && o) + StackStrF & operator = (StackStrF && o) noexcept { if (this != &o) { @@ -1966,7 +1966,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Move constructor. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - DeleteGuard(DeleteGuard && o) + DeleteGuard(DeleteGuard && o) noexcept : m_Ptr(o.m_Ptr) { o.m_Ptr = nullptr;