King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

fix tuple construction, darkroom rgb & vector3d construction

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-03-27 02:02:16 +09:00
parent c78e1d0e6d
commit 2e8b85e90c
53 changed files with 262 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

20
sprout/tuple/tuple/flexibly_construct.hpp Normal file
View file

@ -0,0 +1,20 @@
#ifndef SPROUT_TUPLE_TUPLE_FREXIBLY_CONSTRUCT_HPP
#define SPROUT_TUPLE_TUPLE_FREXIBLY_CONSTRUCT_HPP
#include <sprout/config.hpp>
namespace sprout {
namespace tuples {
//
// flexibly_construct_t
// flexibly_construct
//
struct flexibly_construct_t {};
SPROUT_STATIC_CONSTEXPR sprout::tuples::flexibly_construct_t flexibly_construct = {};
} // namespace tuples
using sprout::tuples::flexibly_construct_t;
using sprout::tuples::flexibly_construct;
} // namespace sprout
#endif // #ifndef SPROUT_TUPLE_TUPLE_FREXIBLY_CONSTRUCT_HPP

27
sprout/tuple/tuple/get.hpp
View file

@ -40,26 +40,23 @@ namespace sprout {
: public std::tuple_element<I, T>
{};
template<std::size_t I, typename T>
struct tuple_element<I, T const> {
public:
typedef typename std::add_const<
struct tuple_element<I, T const>
: public std::add_const<
typename sprout::tuples::tuple_element<I, T>::type
>::type type;
};
>
{};
template<std::size_t I, typename T>
struct tuple_element<I, T volatile> {
public:
typedef typename std::add_volatile<
struct tuple_element<I, T volatile>
: public std::add_volatile<
typename sprout::tuples::tuple_element<I, T>::type
>::type type;
};
>
{};
template<std::size_t I, typename T>
struct tuple_element<I, T const volatile> {
public:
typedef typename std::add_cv<
struct tuple_element<I, T const volatile>
: public std::add_cv<
typename sprout::tuples::tuple_element<I, T>::type
>::type type;
};
>
{};
namespace detail {
template<std::size_t I, typename Head, typename... Tail>

9
sprout/tuple/tuple/make_tuple.hpp
View file

@ -103,12 +103,11 @@ namespace sprout {
typedef sprout::index_tuple<> type;
};
template<typename Head, typename... Tail>
struct tuple_cat_1st_indexes<Head, Tail...> {
public:
typedef typename sprout::index_range<
struct tuple_cat_1st_indexes<Head, Tail...>
: public sprout::index_range<
0, sprout::tuples::tuple_size<typename std::remove_reference<Head>::type>::value
>::type type;
};
>
{};
template<typename Result, typename IndexTuple, typename... Tuples>
struct tuple_cat_impl;

44
sprout/tuple/tuple/tuple.hpp
View file

@ -9,8 +9,10 @@
#include <sprout/utility/forward.hpp>
#include <sprout/utility/move.hpp>
#include <sprout/utility/swap.hpp>
#include <sprout/type_traits/is_convert_constructible.hpp>
#include <sprout/tpp/algorithm/all_of.hpp>
#include <sprout/tuple/tuple/tuple_fwd.hpp>
#include <sprout/tuple/tuple/type_traits.hpp>
#include <sprout/tuple/tuple/flexibly_construct.hpp>
namespace sprout {
namespace tuples {
@ -247,32 +249,46 @@ namespace sprout {
: inherited_type(elements...)
{}
template<
typename U,
typename... UTypes,
typename = typename std::enable_if<
!sprout::tuples::is_tuple<typename std::remove_reference<U>::type>::value
sizeof...(Types) == sizeof...(UTypes) && sprout::tpp::all_of<sprout::is_convert_constructible<Types, UTypes&&>...>::value
>::type
>
explicit SPROUT_CONSTEXPR tuple(U&& elem)
: inherited_type(sprout::forward<U>(elem))
explicit SPROUT_CONSTEXPR tuple(UTypes&&... elements)
: inherited_type(sprout::forward<UTypes>(elements)...)
{}
template<
typename U1,
typename U2,
typename... UTypes
>
explicit SPROUT_CONSTEXPR tuple(U1&& elem1, U2&& elem2, UTypes&&... elements)
: inherited_type(sprout::forward<U1>(elem1), sprout::forward<U2>(elem2), sprout::forward<UTypes>(elements)...)
template<typename... UTypes>
explicit SPROUT_CONSTEXPR tuple(sprout::tuples::flexibly_construct_t, UTypes&&... elements)
: inherited_type(sprout::forward<UTypes>(elements)...)
{}
SPROUT_CONSTEXPR tuple(tuple const&) = default;
SPROUT_CONSTEXPR tuple(tuple&&) = default;
template<typename... UTypes>
template<
typename... UTypes,
typename = typename std::enable_if<
sizeof...(Types) == sizeof...(UTypes) && sprout::tpp::all_of<sprout::is_convert_constructible<Types, UTypes const&>...>::value
>::type
>
SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...> const& t)
: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...> const&>(t))
{}
template<typename... UTypes>
template<
typename... UTypes,
typename = typename std::enable_if<
sizeof...(Types) == sizeof...(UTypes) && sprout::tpp::all_of<sprout::is_convert_constructible<Types, UTypes&&>...>::value
>::type
>
SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...>&& t)
: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...>&&>(t))
{}
template<typename... UTypes>
SPROUT_CONSTEXPR tuple(sprout::tuples::flexibly_construct_t, sprout::tuples::tuple<UTypes...> const& t)
: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...> const&>(t))
{}
template<typename... UTypes>
SPROUT_CONSTEXPR tuple(sprout::tuples::flexibly_construct_t, sprout::tuples::tuple<UTypes...>&& t)
: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...>&&>(t))
{}
// tuple assignment
tuple& operator=(tuple const& rhs) {
static_cast<inherited_type&>(*this) = rhs;