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

sprout/weed.hpp 追加

Browse source
This commit is contained in:
bolero-MURAKAMI 2011-11-13 17:54:38 +09:00
parent 8103682fdb
commit ecfc2b297a
96 changed files with 5127 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

141
sprout/weed/attr_cnv/bitwise_or.hpp Normal file
View file

@ -0,0 +1,141 @@
#ifndef SPROUT_WEED_ATTR_CNV_BITWISE_OR_HPP
#define SPROUT_WEED_ATTR_CNV_BITWISE_OR_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/fixed_container/make_clone.hpp>
#include <sprout/operation/fixed/realign_to.hpp>
#include <sprout/tuple/algorithm/copy.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_container.hpp>
#include <sprout/weed/detail/is_same_container.hpp>
#include <sprout/weed/detail/is_container_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_container.hpp>
#include <sprout/weed/detail/is_both_tuple.hpp>
#include <sprout/weed/detail/is_same_elem.hpp>
#include <sprout/weed/detail/is_elem_and_unused.hpp>
#include <sprout/weed/detail/is_unused_and_elem.hpp>
#include <sprout/weed/detail/is_both_unused.hpp>
#include <sprout/weed/attr_cnv/result_of/bitwise_or.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
//
// bitwise_or
//
// container<V, N> | container<V, M> -> container<V, max(N, M)>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::fixed::realign_to<type>(x);
}
// container<V, N> | V -> container<V, N ? N : 1>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value
&& sprout::weed::traits::is_container<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::fixed::realign_to<type>(x);
}
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value
&& !sprout::weed::traits::is_container<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>(x);
}
// V | container<V, N> -> container<V, N ? N : 1>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value
&& sprout::weed::traits::is_container<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::fixed::realign_to<type>(x);
}
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value
&& !sprout::weed::traits::is_container<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>(x);
}
// tuple<Vs...> | tuple<Ws...> -> tuple<max(Vs..., Ws...)>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::tuples::copy(type(), x);
}
// V | V -> V
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
return x;
}
// V | unused -> container<V, 1>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value
&& !sprout::weed::traits::is_unused<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>(x);
}
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value
&& sprout::weed::traits::is_unused<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>();
}
// unused | V -> container<V, 1>
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value
&& !sprout::weed::traits::is_unused<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>(x);
}
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value
&& sprout::weed::traits::is_unused<X>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
typedef typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type type;
return sprout::make_clone<type>();
}
// unused >> unused -> unused
template<typename T, typename U, typename X>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value,
typename sprout::weed::attr_cnv::result_of::bitwise_or<T, U>::type
>::type bitwise_or(X const& x) {
return sprout::weed::unused();
}
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_BITWISE_OR_HPP

24
sprout/weed/attr_cnv/modulus.hpp Normal file
View file

@ -0,0 +1,24 @@
#ifndef SPROUT_WEED_ATTR_CNV_MODULUS_HPP
#define SPROUT_WEED_ATTR_CNV_MODULUS_HPP
#include <cstddef>
#include <sprout/config.hpp>
#include <sprout/weed/attr_cnv/result_of/modulus.hpp>
#include <sprout/weed/attr_cnv/times.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
//
// modulus
//
template<std::size_t Limit, typename T, typename... Args>
SPROUT_CONSTEXPR inline typename sprout::weed::attr_cnv::result_of::modulus<Limit, T>::type
modulus(Args const&... args) {
return sprout::weed::attr_cnv::times<Limit, T>(args...);
}
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_MODULUS_HPP

10
sprout/weed/attr_cnv/result_of.hpp Normal file
View file

@ -0,0 +1,10 @@
#ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_HPP
#define SPROUT_WEED_ATTR_CNV_RESULT_OF_HPP
#include <sprout/config.hpp>
#include <sprout/weed/attr_cnv/result_of/times.hpp>
#include <sprout/weed/attr_cnv/result_of/shift_left.hpp>
#include <sprout/weed/attr_cnv/result_of/modulus.hpp>
#include <sprout/weed/attr_cnv/result_of/bitwise_or.hpp>
#endif // #ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_HPP

154
sprout/weed/attr_cnv/result_of/bitwise_or.hpp Normal file
View file

@ -0,0 +1,154 @@
#ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_BITWISE_OR_HPP
#define SPROUT_WEED_ATTR_CNV_RESULT_OF_BITWISE_OR_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/string.hpp>
#include <sprout/array.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/detail/is_same_container.hpp>
#include <sprout/weed/detail/is_container_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_container.hpp>
#include <sprout/weed/detail/is_both_tuple.hpp>
#include <sprout/weed/detail/is_same_elem.hpp>
#include <sprout/weed/detail/is_elem_and_unused.hpp>
#include <sprout/weed/detail/is_unused_and_elem.hpp>
#include <sprout/weed/detail/is_both_unused.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
namespace result_of {
//
// bitwise_or
//
template<typename T, typename U, typename = void>
struct bitwise_or;
// container<V, N> | container<V, M> -> container<V, max(N, M)>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
!(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value),
T,
U
>::type type;
};
// container<V, N> | V -> container<V, N ? N : 1>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::fixed_container_traits<T>::fixed_size != 0,
T,
typename sprout::rebind_fixed_size<T>::template apply<1>::type
>::type type;
};
// V | container<V, N> -> container<V, N ? N : 1>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::fixed_container_traits<T>::fixed_size != 0,
U,
typename sprout::rebind_fixed_size<U>::template apply<1>::type
>::type type;
};
// tuple<Vs...> | tuple<Ws...> -> tuple<max(Vs..., Ws...)>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
!(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value),
T,
U
>::type type;
};
// V | V -> V
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value
>::type
> {
public:
typedef T type;
};
// V | unused -> container<V, 1>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, 1>,
sprout::array<T, 1>
>::type type;
};
// unused | V -> container<V, 1>
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::weed::traits::is_char_type<U>::value,
sprout::basic_string<U, 1>,
sprout::array<U, 1>
>::type type;
};
// unused | unused -> unused
template<typename T, typename U>
struct bitwise_or<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value
>::type
> {
public:
typedef sprout::weed::unused type;
};
} // namespace result_of
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_BITWISE_OR_HPP

24
sprout/weed/attr_cnv/result_of/modulus.hpp Normal file
View file

@ -0,0 +1,24 @@
#ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_MODULUS_HPP
#define SPROUT_WEED_ATTR_CNV_RESULT_OF_MODULUS_HPP
#include <cstddef>
#include <sprout/config.hpp>
#include <sprout/weed/attr_cnv/result_of/times.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
namespace result_of {
//
// modulus
//
template<std::size_t Limit, typename T, typename = void>
struct modulus
: public sprout::weed::attr_cnv::result_of::times<Limit, T>
{};
} // namespace result_of
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_MODULUS_HPP

178
sprout/weed/attr_cnv/result_of/shift_left.hpp Normal file
View file

@ -0,0 +1,178 @@
#ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_SHIFT_LEFT_HPP
#define SPROUT_WEED_ATTR_CNV_RESULT_OF_SHIFT_LEFT_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/string.hpp>
#include <sprout/array.hpp>
#include <sprout/operation/fixed/append_back.hpp>
#include <sprout/operation/fixed/push_back.hpp>
#include <sprout/operation/fixed/push_front.hpp>
#include <sprout/tuple/operation/append_back.hpp>
#include <sprout/tuple/operation/push_back.hpp>
#include <sprout/tuple/operation/push_front.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/detail/is_same_container.hpp>
#include <sprout/weed/detail/is_container_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_container.hpp>
#include <sprout/weed/detail/is_both_tuple.hpp>
#include <sprout/weed/detail/is_tuple_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_tuple.hpp>
#include <sprout/weed/detail/is_same_elem.hpp>
#include <sprout/weed/detail/is_different_elem.hpp>
#include <sprout/weed/detail/is_elem_and_unused.hpp>
#include <sprout/weed/detail/is_unused_and_elem.hpp>
#include <sprout/weed/detail/is_both_unused.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
namespace result_of {
//
// shift_left
//
template<typename T, typename U, typename = void>
struct shift_left;
// container<V, N> >> container<V, M> -> container<V, N + M>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value
>::type
> {
public:
typedef typename sprout::fixed::result_of::append_back<T, U>::type type;
};
// container<V, N> >> V -> container<V, N + 1>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value
>::type
> {
public:
typedef typename sprout::fixed::result_of::push_back<T, U>::type type;
};
// V >> container<V, N> -> container<V, N + 1>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value
>::type
> {
public:
typedef typename sprout::fixed::result_of::push_front<T, U>::type type;
};
// tuple<Vs...> >> tuple<Ws...> -> tuple<Vs..., Ws...>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value
>::type
> {
public:
typedef typename sprout::tuples::result_of::append_back<T, U>::type type;
};
// tuple<Vs...> >> V -> tuple<Vs..., V>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_tuple_and_elem<T, U>::value
>::type
> {
public:
typedef typename sprout::tuples::result_of::push_back<T, U>::type type;
};
// V >> tuple<Vs...> -> tuple<V, Vs...>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_elem_and_tuple<T, U>::value
>::type
> {
public:
typedef typename sprout::tuples::result_of::push_front<T, U>::type type;
};
// V >> V -> container<V, 2>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, 2>,
sprout::array<T, 2>
>::type type;
};
// V >> W -> tuple<V, W>
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_different_elem<T, U>::value
>::type
> {
public:
typedef sprout::tuples::tuple<T, U> type;
};
// V >> unused -> V
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value
>::type
> {
public:
typedef T type;
};
// unused >> V -> V
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value
>::type
> {
public:
typedef U type;
};
// unused >> unused -> unused
template<typename T, typename U>
struct shift_left<
T,
U,
typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value
>::type
> {
public:
typedef sprout::weed::unused type;
};
} // namespace result_of
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_SHIFT_LEFT_HPP

74
sprout/weed/attr_cnv/result_of/times.hpp Normal file
View file

@ -0,0 +1,74 @@
#ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_TIMES_HPP
#define SPROUT_WEED_ATTR_CNV_RESULT_OF_TIMES_HPP
#include <cstddef>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/string.hpp>
#include <sprout/array.hpp>
#include <sprout/algorithm/string/join.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/traits/type/is_container.hpp>
#include <sprout/weed/traits/type/is_unused.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
namespace result_of {
//
// times
//
template<std::size_t Limit, typename T, typename = void>
struct times;
// times<N>(container<V, K>) -> container<V, N * K>
template<std::size_t Limit, typename T>
struct times<
Limit,
T,
typename std::enable_if<
Limit != std::size_t(-1)
&& sprout::weed::traits::is_container<T>::value
>::type
> {
public:
typedef typename sprout::algorithm::result_of::join<
sprout::array<T, Limit>
>::type type;
};
// times<N>(V) -> container<V, N>
template<std::size_t Limit, typename T>
struct times<
Limit,
T,
typename std::enable_if<
Limit != std::size_t(-1)
&& !sprout::weed::traits::is_container<T>::value
&& !sprout::weed::traits::is_unused<T>::value
>::type
> {
public:
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, Limit>,
sprout::array<T, Limit>
>::type type;
};
// times<N>(unused) -> unused
template<std::size_t Limit, typename T>
struct times<
Limit,
T,
typename std::enable_if<
sprout::weed::traits::is_unused<T>::value
>::type
> {
public:
typedef sprout::weed::unused type;
};
} // namespace result_of
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_RESULT_OF_TIMES_HPP

125
sprout/weed/attr_cnv/shift_left.hpp Normal file
View file

@ -0,0 +1,125 @@
#ifndef SPROUT_WEED_ATTR_CNV_SHIFT_LEFT_HPP
#define SPROUT_WEED_ATTR_CNV_SHIFT_LEFT_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/operation/fixed/append_back.hpp>
#include <sprout/operation/fixed/push_back.hpp>
#include <sprout/operation/fixed/push_front.hpp>
#include <sprout/tuple/operation/append_back.hpp>
#include <sprout/tuple/operation/push_back.hpp>
#include <sprout/tuple/operation/push_front.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/detail/is_same_container.hpp>
#include <sprout/weed/detail/is_container_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_container.hpp>
#include <sprout/weed/detail/is_both_tuple.hpp>
#include <sprout/weed/detail/is_tuple_and_elem.hpp>
#include <sprout/weed/detail/is_elem_and_tuple.hpp>
#include <sprout/weed/detail/is_same_elem.hpp>
#include <sprout/weed/detail/is_different_elem.hpp>
#include <sprout/weed/detail/is_elem_and_unused.hpp>
#include <sprout/weed/detail/is_unused_and_elem.hpp>
#include <sprout/weed/detail/is_both_unused.hpp>
#include <sprout/weed/attr_cnv/result_of/shift_left.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
//
// shift_left
//
// container<V, N> >> container<V, M> -> container<V, N + M>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::fixed::append_back(t, u);
}
// container<V, N> >> V -> container<V, N + 1>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::fixed::push_back(t, u);
}
// V >> container<V, N> -> container<V, N + 1>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::fixed::push_front(t, u);
}
// tuple<Vs...> >> tuple<Ws...> -> tuple<Vs..., Ws...>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::tuples::append_back(t, u);
}
// tuple<Vs...> >> V -> tuple<Vs..., V>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_tuple_and_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::tuples::push_back(t, u);
}
// V >> tuple<Vs...> -> tuple<V, Vs...>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_tuple<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::tuples::push_front(t, u);
}
// V >> V -> container<V, 2>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
typedef typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type type;
return sprout::make_clone<type>(t, u);
}
// V >> W -> tuple<V, W>
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_different_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type(t, u);
}
// V >> unused -> V
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return t;
}
// unused >> V -> V
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return u;
}
// unused >> unused -> unused
template<typename T, typename U>
SPROUT_CONSTEXPR inline typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value,
typename sprout::weed::attr_cnv::result_of::shift_left<T, U>::type
>::type shift_left(T const& t, U const& u) {
return sprout::weed::unused();
}
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_SHIFT_LEFT_HPP

53
sprout/weed/attr_cnv/times.hpp Normal file
View file

@ -0,0 +1,53 @@
#ifndef SPROUT_WEED_ATTR_CNV_TIMES_HPP
#define SPROUT_WEED_ATTR_CNV_TIMES_HPP
#include <cstddef>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/array.hpp>
#include <sprout/fixed_container/make_clone.hpp>
#include <sprout/algorithm/string/join.hpp>
#include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_container.hpp>
#include <sprout/weed/traits/type/is_unused.hpp>
#include <sprout/weed/attr_cnv/result_of/times.hpp>
namespace sprout {
namespace weed {
namespace attr_cnv {
//
// times
//
// times<N>(container<V, K>) -> container<V, N * K>
template<std::size_t Limit, typename T, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
sprout::weed::traits::is_container<T>::value,
typename sprout::weed::attr_cnv::result_of::times<Limit, T>::type
>::type times(Args const&... args) {
return sprout::algorithm::join(
sprout::make_clone<sprout::array<T, Limit> >(args...)
);
}
// times<N>(V) -> container<V, N>
template<std::size_t Limit, typename T, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
!sprout::weed::traits::is_container<T>::value
&& !sprout::weed::traits::is_unused<T>::value,
typename sprout::weed::attr_cnv::result_of::times<Limit, T>::type
>::type times(Args const&... args) {
typedef typename sprout::weed::attr_cnv::result_of::times<Limit, T>::type type;
return sprout::make_clone<type>(args...);
}
// times<N>(unused) -> unused
template<std::size_t Limit, typename T, typename... Args>
static SPROUT_CONSTEXPR typename std::enable_if<
sprout::weed::traits::is_unused<T>::value,
typename sprout::weed::attr_cnv::result_of::times<Limit, T>::type
>::type times(Args const&... args) {
return sprout::weed::unused();
}
} // namespace attr_cnv
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_ATTR_CNV_TIMES_HPP