diff options
Diffstat (limited to 'lib/sol2/include/sol/raii.hpp')
| -rw-r--r-- | lib/sol2/include/sol/raii.hpp | 166 |
1 files changed, 166 insertions, 0 deletions
diff --git a/lib/sol2/include/sol/raii.hpp b/lib/sol2/include/sol/raii.hpp new file mode 100644 index 0000000..c927bd6 --- /dev/null +++ b/lib/sol2/include/sol/raii.hpp @@ -0,0 +1,166 @@ +// 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_RAII_HPP +#define SOL_RAII_HPP + +#include "traits.hpp" +#include "compatibility.hpp" + +#include <memory> + +namespace sol { + namespace detail { + struct default_construct { + template <typename T, typename... Args> + static void construct(T&& obj, Args&&... args) { + typedef meta::unqualified_t<T> Tu; + std::allocator<Tu> alloc{}; + std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...); + } + + template <typename T, typename... Args> + void operator()(T&& obj, Args&&... args) const { + construct(std::forward<T>(obj), std::forward<Args>(args)...); + } + }; + + struct default_destruct { + template <typename T> + static void destroy(T&& obj) { + std::allocator<meta::unqualified_t<T>> alloc{}; + alloc.destroy(obj); + } + + template <typename T> + void operator()(T&& obj) const { + destroy(std::forward<T>(obj)); + } + }; + + struct deleter { + template <typename T> + void operator()(T* p) const { + delete p; + } + }; + + struct state_deleter { + void operator()(lua_State* L) const { + lua_close(L); + } + }; + + template <typename T, typename Dx, typename... Args> + inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) { + return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...)); + } + + template <typename Tag, typename T> + struct tagged { + private: + T value_; + + public: + template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler> + tagged(Arg&& arg, Args&&... args) + : value_(std::forward<Arg>(arg), std::forward<Args>(args)...) { + } + + T& value() & { + return value_; + } + + T const& value() const& { + return value_; + } + + T&& value() && { + return std::move(value_); + } + }; + } // namespace detail + + template <typename... Args> + struct constructor_list {}; + + template <typename... Args> + using constructors = constructor_list<Args...>; + + const auto default_constructor = constructors<types<>>{}; + + struct no_construction {}; + const auto no_constructor = no_construction{}; + + struct call_construction {}; + const auto call_constructor = call_construction{}; + + template <typename... Functions> + struct constructor_wrapper { + std::tuple<Functions...> functions; + template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler> + constructor_wrapper(Arg&& arg, Args&&... args) + : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) { + } + }; + + template <typename... Functions> + inline auto initializers(Functions&&... functions) { + return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...); + } + + template <typename... Functions> + struct factory_wrapper { + std::tuple<Functions...> functions; + template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler> + factory_wrapper(Arg&& arg, Args&&... args) + : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) { + } + }; + + template <typename... Functions> + inline auto factories(Functions&&... functions) { + return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...); + } + + template <typename Function> + struct destructor_wrapper { + Function fx; + destructor_wrapper(Function f) + : fx(std::move(f)) { + } + }; + + template <> + struct destructor_wrapper<void> {}; + + const destructor_wrapper<void> default_destructor{}; + + template <typename Fx> + inline auto destructor(Fx&& fx) { + return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx)); + } + +} // namespace sol + +#endif // SOL_RAII_HPP |