From 72a445ff6a5bd6d2bcf537dd2897edf58c4129ed Mon Sep 17 00:00:00 2001 From: ThePhD Date: Thu, 29 Sep 2016 03:29:48 -0400 Subject: [PATCH] Some minor fixes and updates --- sol/object.hpp | 285 +++++++++++++++++++++++---------------------- sol/stack_get.hpp | 8 +- sol/tie.hpp | 2 +- sol/types.hpp | 8 +- test_usertypes.cpp | 3 +- 5 files changed, 158 insertions(+), 148 deletions(-) diff --git a/sol/object.hpp b/sol/object.hpp index 2a6e628d..b44571ac 100644 --- a/sol/object.hpp +++ b/sol/object.hpp @@ -1,141 +1,150 @@ -// The MIT License (MIT) - -// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors - -// Permission is hereby granted, free of charge, to any person obtaining a copy of -// this software and associated documentation files (the "Software"), to deal in -// the Software without restriction, including without limitation the rights to -// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software is furnished to do so, -// subject to the following conditions: - -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -#ifndef SOL_OBJECT_HPP -#define SOL_OBJECT_HPP - -#include "optional.hpp" -#include "reference.hpp" -#include "stack.hpp" -#include "userdata.hpp" -#include "variadic_args.hpp" - -namespace sol { - - template ::value, typename T> - R make_reference(lua_State* L, T&& value) { - int backpedal = stack::push(L, std::forward(value)); - R r = stack::get(L, -backpedal); - if (should_pop) { - lua_pop(L, backpedal); - } - return r; - } - - template ::value, typename... Args> - R make_reference(lua_State* L, Args&&... args) { - int backpedal = stack::push(L, std::forward(args)...); - R r = stack::get(L, -backpedal); - if (should_pop) { - lua_pop(L, backpedal); - } - return r; - } - - template - class basic_object : public base_t { - private: - template - decltype(auto) as_stack(std::true_type) const { - return stack::get(base_t::lua_state(), base_t::stack_index()); - } - - template - decltype(auto) as_stack(std::false_type) const { - base_t::push(); - return stack::pop(base_t::lua_state()); - } - - template - bool is_stack(std::true_type) const { - return stack::check(base_t::lua_state(), base_t::stack_index(), no_panic); - } - - template - bool is_stack(std::false_type) const { - auto pp = stack::push_pop(*this); - return stack::check(base_t::lua_state(), -1, no_panic); - } - template - basic_object(std::integral_constant, lua_State* L, int index = -1) noexcept : base_t(L, index) { +// The MIT License (MIT) + +// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors + +// Permission is hereby granted, free of charge, to any person obtaining a copy of +// this software and associated documentation files (the "Software"), to deal in +// the Software without restriction, including without limitation the rights to +// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software is furnished to do so, +// subject to the following conditions: + +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +#ifndef SOL_OBJECT_HPP +#define SOL_OBJECT_HPP + +#include "optional.hpp" +#include "reference.hpp" +#include "stack.hpp" +#include "userdata.hpp" +#include "variadic_args.hpp" + +namespace sol { + + template ::value, typename T> + R make_reference(lua_State* L, T&& value) { + int backpedal = stack::push(L, std::forward(value)); + R r = stack::get(L, -backpedal); + if (should_pop) { + lua_pop(L, backpedal); + } + return r; + } + + template ::value, typename... Args> + R make_reference(lua_State* L, Args&&... args) { + int backpedal = stack::push(L, std::forward(args)...); + R r = stack::get(L, -backpedal); + if (should_pop) { + lua_pop(L, backpedal); + } + return r; + } + + template + class basic_object : public base_t { + private: + template + decltype(auto) as_stack(std::true_type) const { + return stack::get(base_t::lua_state(), base_t::stack_index()); + } + + template + decltype(auto) as_stack(std::false_type) const { + base_t::push(); + return stack::pop(base_t::lua_state()); + } + + template + bool is_stack(std::true_type) const { + return stack::check(base_t::lua_state(), base_t::stack_index(), no_panic); + } + + template + bool is_stack(std::false_type) const { + auto pp = stack::push_pop(*this); + return stack::check(base_t::lua_state(), -1, no_panic); + } + + template + basic_object(std::integral_constant, lua_State* L, int index = -1) noexcept : base_t(L, index) { if (invert_and_pop) { lua_pop(L, -index); } - } - - public: - basic_object() noexcept = default; - template , basic_object>>, std::is_base_of>> = meta::enabler> - basic_object(T&& r) : base_t(std::forward(r)) {} - basic_object(nil_t r) : base_t(r) {} - basic_object(const basic_object&) = default; - basic_object(basic_object&&) = default; - basic_object& operator=(const basic_object&) = default; - basic_object& operator=(basic_object&&) = default; - basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {} - basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {} - basic_object(lua_State* L, int index = -1) noexcept : base_t(L, index) {} - template - basic_object(lua_State* L, in_place_type_t, Args&&... args) noexcept : basic_object(std::integral_constant::value>(), L, -stack::push(L, std::forward(args)...)) {} - template - basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place, std::forward(arg), std::forward(args)...) {} - - template - decltype(auto) as() const { - return as_stack(std::is_same()); - } - - template - bool is() const { - if (!base_t::valid()) - return false; - return is_stack(std::is_same()); - } - }; - - template - object make_object(lua_State* L, T&& value) { - return make_reference(L, std::forward(value)); - } - - template - object make_object(lua_State* L, Args&&... args) { - return make_reference(L, std::forward(args)...); - } - - inline bool operator==(const object& lhs, const nil_t&) { - return !lhs.valid(); - } - - inline bool operator==(const nil_t&, const object& rhs) { - return !rhs.valid(); - } - - inline bool operator!=(const object& lhs, const nil_t&) { - return lhs.valid(); - } - - inline bool operator!=(const nil_t&, const object& rhs) { - return rhs.valid(); - } -} // sol - -#endif // SOL_OBJECT_HPP + } + + public: + basic_object() noexcept = default; + template , basic_object>>, std::is_base_of>> = meta::enabler> + basic_object(T&& r) : base_t(std::forward(r)) {} + basic_object(nil_t r) : base_t(r) {} + basic_object(const basic_object&) = default; + basic_object(basic_object&&) = default; + basic_object& operator=(const basic_object&) = default; + basic_object& operator=(basic_object&&) = default; + basic_object& operator=(const base_t& b) { + base_t::operator=(b); + return *this; + } + basic_object& operator=(base_t&& b) { + base_t::operator=(std::move(b)); + return *this; + } + basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {} + basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {} + basic_object(lua_State* L, int index = -1) noexcept : base_t(L, index) {} + template + basic_object(lua_State* L, in_place_type_t, Args&&... args) noexcept : basic_object(std::integral_constant::value>(), L, -stack::push(L, std::forward(args)...)) {} + template + basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place, std::forward(arg), std::forward(args)...) {} + + template + decltype(auto) as() const { + return as_stack(std::is_same()); + } + + template + bool is() const { + if (!base_t::valid()) + return false; + return is_stack(std::is_same()); + } + }; + + template + object make_object(lua_State* L, T&& value) { + return make_reference(L, std::forward(value)); + } + + template + object make_object(lua_State* L, Args&&... args) { + return make_reference(L, std::forward(args)...); + } + + inline bool operator==(const object& lhs, const nil_t&) { + return !lhs.valid(); + } + + inline bool operator==(const nil_t&, const object& rhs) { + return !rhs.valid(); + } + + inline bool operator!=(const object& lhs, const nil_t&) { + return lhs.valid(); + } + + inline bool operator!=(const nil_t&, const object& rhs) { + return rhs.valid(); + } +} // sol + +#endif // SOL_OBJECT_HPP diff --git a/sol/stack_get.hpp b/sol/stack_get.hpp index 38769ac9..52c52efa 100644 --- a/sol/stack_get.hpp +++ b/sol/stack_get.hpp @@ -334,15 +334,15 @@ namespace sol { struct getter { static wchar_t get(lua_State* L, int index, record& tracking) { auto str = getter{}.get(L, index, tracking); - return str.size() > 0 ? str[0] : '\0'; + return str.size() > 0 ? str[0] : wchar_t(0); } }; template<> struct getter { - static char get(lua_State* L, int index, record& tracking) { + static char16_t get(lua_State* L, int index, record& tracking) { auto str = getter{}.get(L, index, tracking); - return str.size() > 0 ? str[0] : '\0'; + return str.size() > 0 ? str[0] : char16_t(0); } }; @@ -350,7 +350,7 @@ namespace sol { struct getter { static char32_t get(lua_State* L, int index, record& tracking) { auto str = getter{}.get(L, index, tracking); - return str.size() > 0 ? str[0] : '\0'; + return str.size() > 0 ? str[0] : char32_t(0); } }; #endif // codecvt header support diff --git a/sol/tie.hpp b/sol/tie.hpp index 9f131324..fc3ec155 100644 --- a/sol/tie.hpp +++ b/sol/tie.hpp @@ -85,7 +85,7 @@ namespace sol { }; template - struct tie_size<::sol::tie_t> : ::std::tuple_size<::std::tuple> { }; + struct tie_size< tie_t > : std::tuple_size< std::tuple > { }; namespace adl_barrier_detail { template diff --git a/sol/types.hpp b/sol/types.hpp index c487cef2..1c65fb13 100644 --- a/sol/types.hpp +++ b/sol/types.hpp @@ -138,8 +138,8 @@ namespace sol { typedef std::shared_ptr actual_type; static const bool value = true; - static bool is_null(const actual_type& value) { - return value == nullptr; + static bool is_null(const actual_type& p) { + return p == nullptr; } static type* get(const actual_type& p) { @@ -153,8 +153,8 @@ namespace sol { typedef std::unique_ptr actual_type; static const bool value = true; - static bool is_null(const actual_type& value) { - return value == nullptr; + static bool is_null(const actual_type& p) { + return p == nullptr; } static type* get(const actual_type& p) { diff --git a/test_usertypes.cpp b/test_usertypes.cpp index 39ce8b27..8d5d6c01 100644 --- a/test_usertypes.cpp +++ b/test_usertypes.cpp @@ -349,7 +349,6 @@ TEST_CASE("usertype/usertype-utility-derived", "usertype classes must play nice lua.set_usertype(derivedusertype); lua.script("derived = Derived.new(7)"); - Derived& derived = lua["derived"]; lua.script("dgn = derived:get_num()\n" "print(dgn)"); lua.script("dgn10 = derived:get_num_10()\n" @@ -608,6 +607,8 @@ TEST_CASE("usertype/destructor-tests", "Show that proper copies / destruction ha REQUIRE(created == 4); REQUIRE(destroyed == 0); REQUIRE(std::addressof(x1) == std::addressof(x1ref)); + REQUIRE(std::addressof(x1copyref) != std::addressof(x1)); + REQUIRE(std::addressof(x2copyref) != std::addressof(x2)); } REQUIRE(created == 4); REQUIRE(destroyed == 4);