StarMirror/sol2
1
0
Fork 0
mirror of https://github.com/ThePhD/sol2.git synced 2024-03-22 13:10:44 +08:00
Code Issues Projects Releases Wiki Activity
38d03eef6e
sol2/sol/tuple.hpp

102 lines
3.3 KiB
C++
Raw Normal View History

Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
// The MIT License (MIT)
Update copyright year.
2015-07-22 07:51:17 +08:00
// Copyright (c) 2013-2015 Rapptz and contributors
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
// 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_TUPLE_HPP
#define SOL_TUPLE_HPP
#include <tuple>
#include <cstddef>
namespace sol {
Several changes. I took away operator() for the proxy type, because it'd interfere with the `Callable` type and all. Alas, good things do die I suppose. =[ But! I left it on the `sol::function` type, because it's necessary to discard returns. The .call is still there, though, just incase you need it. <3 reverse_indices_builder is also there, to make sure we can push and pop without the lua api taking our types and breaking them for the std::tuple returns. All is at it should be~
2013-12-15 12:25:44 +08:00
template<typename... Ts>
struct reverse_tuple;
template<>
struct reverse_tuple<std::tuple<>> {
using type = std::tuple<>;
};
template<typename T, typename... Ts>
struct reverse_tuple<std::tuple<T, Ts...>> {
using head = std::tuple<T>;
using tail = typename reverse_tuple<std::tuple<Ts...>>::type;
using type = decltype(std::tuple_cat(std::declval<tail>(), std::declval<head>()));
};
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
template<size_t... Ns>
Several changes. I took away operator() for the proxy type, because it'd interfere with the `Callable` type and all. Alas, good things do die I suppose. =[ But! I left it on the `sol::function` type, because it's necessary to discard returns. The .call is still there, though, just incase you need it. <3 reverse_indices_builder is also there, to make sure we can push and pop without the lua api taking our types and breaking them for the std::tuple returns. All is at it should be~
2013-12-15 12:25:44 +08:00
struct indices { typedef indices type; };
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
template<size_t N, size_t... Ns>
Stylistic changes to match the rest of the code
2013-12-03 12:33:23 +08:00
struct build_indices : build_indices<N - 1, N - 1, Ns...> {};
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
template<size_t... Ns>
Stylistic changes to match the rest of the code
2013-12-03 12:33:23 +08:00
struct build_indices<0, Ns...> : indices<Ns...> {};
The solution technically works, but there's some stack corruption going on somewhere that I can quite track down, even when calling a void function with no parameters. I'll have to look into it...
2013-12-03 03:22:51 +08:00
Several changes. I took away operator() for the proxy type, because it'd interfere with the `Callable` type and all. Alas, good things do die I suppose. =[ But! I left it on the `sol::function` type, because it's necessary to discard returns. The .call is still there, though, just incase you need it. <3 reverse_indices_builder is also there, to make sure we can push and pop without the lua api taking our types and breaking them for the std::tuple returns. All is at it should be~
2013-12-15 12:25:44 +08:00
template<size_t N, size_t... Ns>
struct build_reverse_indices : build_reverse_indices<N - 1, Ns..., N - 1> {};
template<size_t... Ns>
struct build_reverse_indices<0, Ns...> : indices<Ns...> {};
The solution technically works, but there's some stack corruption going on somewhere that I can quite track down, even when calling a void function with no parameters. I'll have to look into it...
2013-12-03 03:22:51 +08:00
template<typename... Args>
Removed std::true_type/false_type from tuple_types and created a separate is_tuple trait, so that we can use ::type on tuple_types without it interfering with base typedefs in std::true/false_type Fixing some identation Moved are_same type traits to traits.hpp
2014-05-31 07:10:08 +08:00
struct types : build_indices<sizeof...(Args)> { typedef types type; };
Update copyright year.
2015-07-22 07:51:17 +08:00
Free functions and lambdas whos first arguments match the userdata type (unqualified) now are usable as functions for userdata. allows free functions and lambdas to provide useful operations, like operator+*-/ and other things which may not be implemented as class members.
2014-08-09 19:54:58 +08:00
namespace detail {
New test cases for the order of returns. Apparently, its screwing up between both lua and C++. Have to test thoroughly. Changes currently are half-working.
2013-12-16 05:27:20 +08:00
template<class Acc, class... Args>
struct reversed_ : Acc{};
Free functions and lambdas whos first arguments match the userdata type (unqualified) now are usable as functions for userdata. allows free functions and lambdas to provide useful operations, like operator+*-/ and other things which may not be implemented as class members.
2014-08-09 19:54:58 +08:00
New test cases for the order of returns. Apparently, its screwing up between both lua and C++. Have to test thoroughly. Changes currently are half-working.
2013-12-16 05:27:20 +08:00
template<typename... RArgs, typename Arg, typename... Args>
struct reversed_<types<RArgs...>, Arg, Args...> : reversed_<types<Arg, RArgs...>, Args...>{};
Free functions and lambdas whos first arguments match the userdata type (unqualified) now are usable as functions for userdata. allows free functions and lambdas to provide useful operations, like operator+*-/ and other things which may not be implemented as class members.
2014-08-09 19:54:58 +08:00
template<typename Arg>
struct chop_one : types<> {};
template<typename Arg0, typename Arg1, typename... Args>
struct chop_one<types<Arg0, Arg1, Args...>> : types<Arg1, Args...> {};
template<typename Arg, typename... Args>
struct chop_one<types<Arg, Args...>> : types<Args...> {};
} // detail
New test cases for the order of returns. Apparently, its screwing up between both lua and C++. Have to test thoroughly. Changes currently are half-working.
2013-12-16 05:27:20 +08:00
template<typename... Args>
Free functions and lambdas whos first arguments match the userdata type (unqualified) now are usable as functions for userdata. allows free functions and lambdas to provide useful operations, like operator+*-/ and other things which may not be implemented as class members.
2014-08-09 19:54:58 +08:00
struct reversed : detail::reversed_<types<>, Args...>{};
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
The solution technically works, but there's some stack corruption going on somewhere that I can quite track down, even when calling a void function with no parameters. I'll have to look into it...
2013-12-03 03:22:51 +08:00
template<typename... Args>
Removed std::true_type/false_type from tuple_types and created a separate is_tuple trait, so that we can use ::type on tuple_types without it interfering with base typedefs in std::true/false_type Fixing some identation Moved are_same type traits to traits.hpp
2014-05-31 07:10:08 +08:00
struct tuple_types : types<Args...> {};
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
Reformatted to look like Rapptz's style. The following code sample work without error in VS 2013: http://pastebin.com/s4Jbjnht It'll be up to @Rapptz's to make further changes to make sure GCC compiles, but the core of the functionality is there and my work is essentially done. Class bindings are up next, but really I don't want to even touch those. :c
2013-12-03 04:42:03 +08:00
template<typename... Args>
Removed std::true_type/false_type from tuple_types and created a separate is_tuple trait, so that we can use ::type on tuple_types without it interfering with base typedefs in std::true/false_type Fixing some identation Moved are_same type traits to traits.hpp
2014-05-31 07:10:08 +08:00
struct tuple_types<std::tuple<Args...>> : types<Args...> {};
Renamed many parts of `lua_function.hpp` to make more sense. Added pop() function to `reference` `stack.hpp` now has many more functions to properly handle user data `types.hpp` now has `userdata_t` and `lightuserdata_t` to faciliate `stack`'s `pop` and `push` operations Class binding functionality built into `table` and `state`, as well as placed in `userdata` class in `userdata.hpp` demangling detail now present for clang, gcc, and MSVC (somewhat for MSVC) Constructor arity still needs to be handled for `userdata<T>` tests updated and passing
2014-04-26 08:20:35 +08:00
Free functions and lambdas whos first arguments match the userdata type (unqualified) now are usable as functions for userdata. allows free functions and lambdas to provide useful operations, like operator+*-/ and other things which may not be implemented as class members.
2014-08-09 19:54:58 +08:00
template<typename Arg>
struct remove_one_type : detail::chop_one<Arg> {};
Class binding now works with multiple functions Refactoring on function_types.hpp performed to slim down some of the calls: could use more refactoring Drastically simplified userdata's binding capabilities: constructor supports both `:` and `.` syntax (but member functions DO NOT). All tests are passing
2014-04-27 06:23:56 +08:00
template<typename... Tn>
Renamed many parts of `lua_function.hpp` to make more sense. Added pop() function to `reference` `stack.hpp` now has many more functions to properly handle user data `types.hpp` now has `userdata_t` and `lightuserdata_t` to faciliate `stack`'s `pop` and `push` operations Class binding functionality built into `table` and `state`, as well as placed in `userdata` class in `userdata.hpp` demangling detail now present for clang, gcc, and MSVC (somewhat for MSVC) Constructor arity still needs to be handled for `userdata<T>` tests updated and passing
2014-04-26 08:20:35 +08:00
struct constructors {};
Class binding now works with multiple functions Refactoring on function_types.hpp performed to slim down some of the calls: could use more refactoring Drastically simplified userdata's binding capabilities: constructor supports both `:` and `.` syntax (but member functions DO NOT). All tests are passing
2014-04-27 06:23:56 +08:00
const auto default_constructor = constructors<types<>>{};
Proper std::ref semantics throughout the codebase's get/set. Also a convenience type `sol::ref`, which is just an alias to `std::reference_wrapper`, to enable easy getting with `lua.get<>` (we can't use `lua.get<some_type>` because of necessary `Unqualified<T>` use)
2014-09-18 12:23:46 +08:00
template <typename T>
using ref = std::reference_wrapper<T>;
Add call function to transform a tuple into function arguments
2013-11-28 19:50:26 +08:00
} // sol
Additional get_call argument that defaults index to 1 (first argument of stack). tuple_types had overlapping purpose: we should split it up soon
2014-05-31 06:21:19 +08:00
#endif // SOL_TUPLE_HPP
Reference in New Issue Copy Permalink