sol2/sol/tuple.hpp

// The MIT License (MIT)

// Copyright (c) 2013 Danny Y., Rapptz

// 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 {
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>()));
};

template<size_t... Ns>
struct indices { typedef indices type; };

template<size_t N, size_t... Ns>
struct build_indices : build_indices<N - 1, N - 1, Ns...> {};

template<size_t... Ns>
struct build_indices<0, Ns...> : indices<Ns...> {};

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...> {};

template<typename... Args>
struct types : build_indices<sizeof...(Args)> {};

template<typename... Args>
struct tuple_types : types<Args...>, std::false_type {};

template<typename... Args>
struct tuple_types<std::tuple<Args...>> : types<Args...>, std::true_type {};
} // sol

#endif // SOL_TUPLE_HPP
Add call function to transform a tuple into function arguments 2013-11-28 19:50:26 +08:00			`// The MIT License (MIT)`

			`// Copyright (c) 2013 Danny Y., Rapptz`

			`// 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>`
Stylistic changes to match the rest of the code 2013-12-03 12:33:23 +08:00			`struct types : build_indices<sizeof...(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>`
Stylistic changes to match the rest of the code 2013-12-03 12:33:23 +08:00			`struct tuple_types : types<Args...>, std::false_type {};`
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>`
Stylistic changes to match the rest of the code 2013-12-03 12:33:23 +08:00			`struct tuple_types<std::tuple<Args...>> : types<Args...>, std::true_type {};`
Add call function to transform a tuple into function arguments 2013-11-28 19:50:26 +08:00			`} // sol`

			`#endif // SOL_TUPLE_HPP`