From b47997ff653fa6599bbb962da2272bd90c03fcde Mon Sep 17 00:00:00 2001 From: ThePhD Date: Sat, 13 Apr 2019 10:15:14 -0400 Subject: [PATCH] pointer_like, now, more traits being separated out... --- include/sol/pointer_like.hpp | 98 ++++++++++++++ include/sol/traits.hpp | 62 +-------- include/sol/unique_usertype_traits.hpp | 1 + single/include/sol/forward.hpp | 4 +- single/include/sol/sol.hpp | 135 +++++++++++--------- tests/compile_tests/source/pointer_like.cpp | 26 ++++ 6 files changed, 200 insertions(+), 126 deletions(-) create mode 100644 include/sol/pointer_like.hpp create mode 100644 tests/compile_tests/source/pointer_like.cpp diff --git a/include/sol/pointer_like.hpp b/include/sol/pointer_like.hpp new file mode 100644 index 00000000..35b5d43d --- /dev/null +++ b/include/sol/pointer_like.hpp @@ -0,0 +1,98 @@ +// sol3 + +// The MIT License (MIT) + +// Copyright (c) 2013-2019 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_POINTER_LIKE_HPP +#define SOL_POINTER_LIKE_HPP + +#include "base_traits.hpp" + +#include +#include + +namespace sol { + + namespace meta { + namespace meta_detail { + template + using is_dereferenceable_test = decltype(*std::declval()); + } + + template + using is_pointer_like = std::integral_constant && (std::is_pointer_v || is_detected_v)>; + + template + constexpr inline bool is_pointer_like_v = is_pointer_like::value; + } // namespace meta + + namespace detail { + + template + auto unwrap(T&& item) -> decltype(std::forward(item)) { + return std::forward(item); + } + + template + T& unwrap(std::reference_wrapper arg) { + return arg.get(); + } + + template + inline decltype(auto) deref(T&& item) { + using Tu = meta::unqualified_t; + if constexpr (meta::is_pointer_like_v) { + return *std::forward(item); + } + else { + return std::forward(item); + } + } + + template + inline decltype(auto) deref_non_pointer(T&& item) { + using Tu = meta::unqualified_t; + if constexpr (meta::is_pointer_like_v && !std::is_pointer_v) { + return *std::forward(item); + } + else { + return std::forward(item); + } + } + + template + inline T* ptr(T& val) { + return std::addressof(val); + } + + template + inline T* ptr(std::reference_wrapper val) { + return std::addressof(val.get()); + } + + template + inline T* ptr(T* val) { + return val; + } + } // namespace detail +} // namespace sol + +#endif // SOL_POINTER_LIKE_HPP diff --git a/include/sol/traits.hpp b/include/sol/traits.hpp index b87fff92..7ecb9e22 100644 --- a/include/sol/traits.hpp +++ b/include/sol/traits.hpp @@ -26,6 +26,7 @@ #include "tuple.hpp" #include "bind_traits.hpp" +#include "pointer_like.hpp" #include "base_traits.hpp" #include "string_view.hpp" @@ -669,68 +670,7 @@ namespace sol { using type = typename std::iterator_traits::iterator_category; }; - namespace meta_detail { - template - using is_dereferenceable_test = decltype(*std::declval()); - } - - template - using is_pointer_like = meta::boolean && ( std::is_pointer_v || meta::is_detected_v)>; - - template - constexpr inline bool is_pointer_like_v = is_pointer_like::value; - } // namespace meta - - namespace detail { - - template - auto unwrap(T&& item) -> decltype(std::forward(item)) { - return std::forward(item); - } - - template - T& unwrap(std::reference_wrapper arg) { - return arg.get(); - } - - template - inline decltype(auto) deref(T&& item) { - using Tu = meta::unqualified_t; - if constexpr (meta::is_pointer_like_v) { - return *std::forward(item); - } - else { - return std::forward(item); - } - } - - template - inline decltype(auto) deref_non_pointer(T&& item) { - using Tu = meta::unqualified_t; - if constexpr (meta::is_pointer_like_v && !std::is_pointer_v) { - return *std::forward(item); - } - else { - return std::forward(item); - } - } - - template - inline T* ptr(T& val) { - return std::addressof(val); - } - - template - inline T* ptr(std::reference_wrapper val) { - return std::addressof(val.get()); - } - - template - inline T* ptr(T* val) { - return val; - } - } // namespace detail } // namespace sol #endif // SOL_TRAITS_HPP diff --git a/include/sol/unique_usertype_traits.hpp b/include/sol/unique_usertype_traits.hpp index c1433a61..fbd3e179 100644 --- a/include/sol/unique_usertype_traits.hpp +++ b/include/sol/unique_usertype_traits.hpp @@ -25,6 +25,7 @@ #define SOL_UNIQUE_USERTYPE_TRAITS_HPP #include "base_traits.hpp" +#include "pointer_like.hpp" #include diff --git a/single/include/sol/forward.hpp b/single/include/sol/forward.hpp index d765ca40..9d85b9ae 100644 --- a/single/include/sol/forward.hpp +++ b/single/include/sol/forward.hpp @@ -20,8 +20,8 @@ // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // This file was generated with a script. -// Generated 2019-04-13 09:58:41.494320 UTC -// This header was generated with sol v3.0.1-beta2 (revision 3adac34) +// Generated 2019-04-13 14:14:41.718314 UTC +// This header was generated with sol v3.0.1-beta2 (revision caa71f2) // https://github.com/ThePhD/sol2 #ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP diff --git a/single/include/sol/sol.hpp b/single/include/sol/sol.hpp index e64871eb..afc265d8 100644 --- a/single/include/sol/sol.hpp +++ b/single/include/sol/sol.hpp @@ -20,8 +20,8 @@ // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // This file was generated with a script. -// Generated 2019-04-13 09:58:41.191654 UTC -// This header was generated with sol v3.0.1-beta2 (revision 3adac34) +// Generated 2019-04-13 14:14:41.437059 UTC +// This header was generated with sol v3.0.1-beta2 (revision caa71f2) // https://github.com/ThePhD/sol2 #ifndef SOL_SINGLE_INCLUDE_HPP @@ -1171,6 +1171,76 @@ namespace meta { // end of sol/bind_traits.hpp +// beginning of sol/pointer_like.hpp + +namespace sol { + + namespace meta { + namespace meta_detail { + template + using is_dereferenceable_test = decltype(*std::declval()); + } + + template + using is_pointer_like = std::integral_constant && (std::is_pointer_v || is_detected_v)>; + + template + constexpr inline bool is_pointer_like_v = is_pointer_like::value; + } // namespace meta + + namespace detail { + + template + auto unwrap(T&& item) -> decltype(std::forward(item)) { + return std::forward(item); + } + + template + T& unwrap(std::reference_wrapper arg) { + return arg.get(); + } + + template + inline decltype(auto) deref(T&& item) { + using Tu = meta::unqualified_t; + if constexpr (meta::is_pointer_like_v) { + return *std::forward(item); + } + else { + return std::forward(item); + } + } + + template + inline decltype(auto) deref_non_pointer(T&& item) { + using Tu = meta::unqualified_t; + if constexpr (meta::is_pointer_like_v && !std::is_pointer_v) { + return *std::forward(item); + } + else { + return std::forward(item); + } + } + + template + inline T* ptr(T& val) { + return std::addressof(val); + } + + template + inline T* ptr(std::reference_wrapper val) { + return std::addressof(val.get()); + } + + template + inline T* ptr(T* val) { + return val; + } + } // namespace detail +} // namespace sol + +// end of sol/pointer_like.hpp + // beginning of sol/string_view.hpp #include @@ -1959,68 +2029,7 @@ namespace sol { using type = typename std::iterator_traits::iterator_category; }; - namespace meta_detail { - template - using is_dereferenceable_test = decltype(*std::declval()); - } - - template - using is_pointer_like = meta::boolean && ( std::is_pointer_v || meta::is_detected_v)>; - - template - constexpr inline bool is_pointer_like_v = is_pointer_like::value; - } // namespace meta - - namespace detail { - - template - auto unwrap(T&& item) -> decltype(std::forward(item)) { - return std::forward(item); - } - - template - T& unwrap(std::reference_wrapper arg) { - return arg.get(); - } - - template - inline decltype(auto) deref(T&& item) { - using Tu = meta::unqualified_t; - if constexpr (meta::is_pointer_like_v) { - return *std::forward(item); - } - else { - return std::forward(item); - } - } - - template - inline decltype(auto) deref_non_pointer(T&& item) { - using Tu = meta::unqualified_t; - if constexpr (meta::is_pointer_like_v && !std::is_pointer_v) { - return *std::forward(item); - } - else { - return std::forward(item); - } - } - - template - inline T* ptr(T& val) { - return std::addressof(val); - } - - template - inline T* ptr(std::reference_wrapper val) { - return std::addressof(val.get()); - } - - template - inline T* ptr(T* val) { - return val; - } - } // namespace detail } // namespace sol // end of sol/traits.hpp diff --git a/tests/compile_tests/source/pointer_like.cpp b/tests/compile_tests/source/pointer_like.cpp new file mode 100644 index 00000000..9ae5eda3 --- /dev/null +++ b/tests/compile_tests/source/pointer_like.cpp @@ -0,0 +1,26 @@ +// sol3 + +// The MIT License (MIT) + +// Copyright (c) 2013-2019 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. + +#include "sol_defines.hpp" + +#include