diff options
Diffstat (limited to '3rdparty/sol2/sol/proxy.hpp')
-rw-r--r-- | 3rdparty/sol2/sol/proxy.hpp | 179 |
1 files changed, 0 insertions, 179 deletions
diff --git a/3rdparty/sol2/sol/proxy.hpp b/3rdparty/sol2/sol/proxy.hpp deleted file mode 100644 index 5cd8b5e1fc9..00000000000 --- a/3rdparty/sol2/sol/proxy.hpp +++ /dev/null @@ -1,179 +0,0 @@ -// 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_PROXY_HPP -#define SOL_PROXY_HPP - -#include "traits.hpp" -#include "object.hpp" -#include "function.hpp" -#include "protected_function.hpp" -#include "proxy_base.hpp" - -namespace sol { - template<typename Table, typename Key> - struct proxy : public proxy_base<proxy<Table, Key>> { - private: - typedef meta::condition<meta::is_specialization_of<std::tuple, Key>, Key, std::tuple<meta::condition<std::is_array<meta::unqualified_t<Key>>, Key&, meta::unqualified_t<Key>>>> key_type; - - template<typename T, std::size_t... I> - decltype(auto) tuple_get(std::index_sequence<I...>) const { - return tbl.template traverse_get<T>(std::get<I>(key)...); - } - - template<std::size_t... I, typename T> - void tuple_set(std::index_sequence<I...>, T&& value) { - tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value)); - } - - public: - Table tbl; - key_type key; - - template<typename T> - proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {} - - template<typename T> - proxy& set(T&& item) { - tuple_set(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>(), std::forward<T>(item)); - return *this; - } - - template<typename... Args> - proxy& set_function(Args&&... args) { - tbl.set_function(key, std::forward<Args>(args)...); - return *this; - } - - template<typename U, meta::enable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler> - proxy& operator=(U&& other) { - return set_function(std::forward<U>(other)); - } - - template<typename U, meta::disable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler> - proxy& operator=(U&& other) { - return set(std::forward<U>(other)); - } - - template<typename T> - decltype(auto) get() const { - return tuple_get<T>(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>()); - } - - template<typename T> - decltype(auto) get_or(T&& otherwise) const { - typedef decltype(get<T>()) U; - sol::optional<U> option = get<sol::optional<U>>(); - if (option) { - return static_cast<U>(option.value()); - } - return static_cast<U>(std::forward<T>(otherwise)); - } - - template<typename T, typename D> - decltype(auto) get_or(D&& otherwise) const { - sol::optional<T> option = get<sol::optional<T>>(); - if (option) { - return static_cast<T>(option.value()); - } - return static_cast<T>(std::forward<D>(otherwise)); - } - - template <typename K> - decltype(auto) operator[](K&& k) const { - auto keys = meta::tuplefy(key, std::forward<K>(k)); - return proxy<Table, decltype(keys)>(tbl, std::move(keys)); - } - - template<typename... Ret, typename... Args> - decltype(auto) call(Args&&... args) { - return get<function>().template call<Ret...>(std::forward<Args>(args)...); - } - - template<typename... Args> - decltype(auto) operator()(Args&&... args) { - return call<>(std::forward<Args>(args)...); - } - - bool valid() const { - auto pp = stack::push_pop(tbl); - auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(tbl.lua_state(), key, lua_gettop(tbl.lua_state())); - lua_pop(tbl.lua_state(), p.levels); - return p; - } - }; - - template<typename Table, typename Key, typename T> - inline bool operator==(T&& left, const proxy<Table, Key>& right) { - typedef decltype(stack::get<T>(nullptr, 0)) U; - return right.template get<optional<U>>() == left; - } - - template<typename Table, typename Key, typename T> - inline bool operator==(const proxy<Table, Key>& right, T&& left) { - typedef decltype(stack::get<T>(nullptr, 0)) U; - return right.template get<optional<U>>() == left; - } - - template<typename Table, typename Key, typename T> - inline bool operator!=(T&& left, const proxy<Table, Key>& right) { - typedef decltype(stack::get<T>(nullptr, 0)) U; - return right.template get<optional<U>>() == left; - } - - template<typename Table, typename Key, typename T> - inline bool operator!=(const proxy<Table, Key>& right, T&& left) { - typedef decltype(stack::get<T>(nullptr, 0)) U; - return right.template get<optional<U>>() == left; - } - - template<typename Table, typename Key> - inline bool operator==(lua_nil_t, const proxy<Table, Key>& right) { - return !right.valid(); - } - - template<typename Table, typename Key> - inline bool operator==(const proxy<Table, Key>& right, lua_nil_t) { - return !right.valid(); - } - - template<typename Table, typename Key> - inline bool operator!=(lua_nil_t, const proxy<Table, Key>& right) { - return right.valid(); - } - - template<typename Table, typename Key> - inline bool operator!=(const proxy<Table, Key>& right, lua_nil_t) { - return right.valid(); - } - - namespace stack { - template <typename Table, typename Key> - struct pusher<proxy<Table, Key>> { - static int push(lua_State* L, const proxy<Table, Key>& p) { - sol::reference r = p; - return r.push(L); - } - }; - } // stack -} // sol - -#endif // SOL_PROXY_HPP |