mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2024-12-23 21:25:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

support for VC++2015

Browse source
This commit is contained in:
bolero-MURAKAMI 2015-12-09 19:54:35 +09:00
parent f2c09dd3af
commit b9440c0e9c
33 changed files with 353 additions and 253 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
sprout/bitset/bitset.hpp
View file

@ -13,6 +13,7 @@
#include <stdexcept>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/assert.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/detail/sizeof.hpp>
#include <sprout/detail/char_literal.hpp>
@ -519,7 +520,7 @@ namespace sprout {
{}
base_bitset(base_bitset<1> const&) = default;
SPROUT_CONSTEXPR base_bitset(unsigned long long val) SPROUT_NOEXCEPT
: w_(val)
: w_(static_cast<word_type>(val))
{}
SPROUT_CONSTEXPR base_bitset(sprout::detail::base_bitset_from_words_construct_tag, word_type word)
: w_(word)
@ -728,8 +729,8 @@ namespace sprout {
SPROUT_CXX14_CONSTEXPR word_type
getword(size_type, bool c = false) SPROUT_NOEXCEPT {
return !c ? 0
: throw std::out_of_range("base_bitset::getword")
return SPROUT_ASSERT_MSG(!c, "base_bitset::getword"),
0
;
}
SPROUT_CONSTEXPR word_type

11
sprout/checksum/md5.hpp
View file

@ -116,13 +116,13 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_INNER(SS) \
; \
}; \
SPROUT_CONSTEXPR_OR_CONST typename sprout::md5_detail::round_table<N>::xis_type sprout::md5_detail::round_table<N>::xis \
SPROUT_CONSTEXPR_OR_CONST sprout::md5_detail::round_table<N>::xis_type sprout::md5_detail::round_table<N>::xis \
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_OUTER(XIS) \
; \
SPROUT_CONSTEXPR_OR_CONST typename sprout::md5_detail::round_table<N>::ts_type sprout::md5_detail::round_table<N>::ts \
SPROUT_CONSTEXPR_OR_CONST sprout::md5_detail::round_table<N>::ts_type sprout::md5_detail::round_table<N>::ts \
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_OUTER(TS) \
; \
SPROUT_CONSTEXPR_OR_CONST typename sprout::md5_detail::round_table<N>::ss_type sprout::md5_detail::round_table<N>::ss \
SPROUT_CONSTEXPR_OR_CONST sprout::md5_detail::round_table<N>::ss_type sprout::md5_detail::round_table<N>::ss \
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_OUTER(SS)
SPROUT_MD5_DETAIL_ROUND_TABLE_DEF( \
@ -251,7 +251,7 @@ namespace sprout {
) const
{
return bit_count % (64 * 8) != 0 ? const_type(k, block, bit_count)
: const_type(k, block, bit_count).process_block()
: const_type(k, block, bit_count).c_process_block()
;
}
SPROUT_CONSTEXPR md5 const process_block_1(sprout::array<std::uint32_t, 4> const& x) const {
@ -263,6 +263,9 @@ namespace sprout {
SPROUT_CONSTEXPR md5 const process_block() const {
return process_block_1(sprout::md5_detail::round_all(k_, block_));
}
SPROUT_CONSTEXPR md5 const c_process_block() const {
return process_block_1(sprout::md5_detail::round_all(k_, block_));
}
SPROUT_CONSTEXPR md5 const process_bit_impl(bool bit, std::size_t index, std::size_t offset) const {
return process(
k_,

5
sprout/checksum/sha1.hpp
View file

@ -218,7 +218,7 @@ namespace sprout {
{
return block_byte_index != 64
? const_type(h, block, block_byte_index, bit_count)
: const_type(h, block, 0, bit_count).process_block()
: const_type(h, block, 0, bit_count).c_process_block()
;
}
SPROUT_CONSTEXPR sha1 const process_block_2(
@ -265,6 +265,9 @@ namespace sprout {
SPROUT_CONSTEXPR sha1 const process_block() const {
return process_block_1(h_[0], h_[1], h_[2], h_[3], h_[4]);
}
SPROUT_CONSTEXPR sha1 const c_process_block() const {
return process_block_1(h_[0], h_[1], h_[2], h_[3], h_[4]);
}
template<typename InputIterator, typename... Args>
SPROUT_CONSTEXPR typename std::enable_if<sizeof...(Args) == 64, sha1 const>::type
process_block_impl(InputIterator first, InputIterator last, Args... args) const {

4
sprout/complex/udl.hpp
View file

@ -30,11 +30,11 @@ namespace sprout {
//
inline SPROUT_CONSTEXPR sprout::complex<float>
operator"" _if(long double x) {
return sprout::complex<float>(0, x);
return sprout::complex<float>(0, static_cast<float>(x));
}
inline SPROUT_CONSTEXPR sprout::complex<float>
operator"" _iF(long double x) {
return sprout::complex<float>(0, x);
return sprout::complex<float>(0, static_cast<float>(x));
}
//

14
sprout/container/container_range_traits.hpp
View file

@ -37,7 +37,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_size_test<T>::test(0))>::type>
struct has_mem_size
: public Base_
@ -84,7 +84,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_empty_test<T>::test(0))>::type>
struct has_mem_empty
: public Base_
@ -131,7 +131,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_front_test<T>::test(0))>::type>
struct has_mem_front
: public Base_
@ -203,7 +203,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_back_test<T>::test(0))>::type>
struct has_mem_back
: public Base_
@ -275,7 +275,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_at_test<T>::test(0))>::type>
struct has_mem_at
: public Base_
@ -347,7 +347,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_nth_test<T>::test(0))>::type>
struct has_mem_nth
: public Base_
@ -419,7 +419,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_index_of_test<T>::test(0))>::type>
struct has_mem_index_of
: public Base_

7
sprout/container/deep_internal.hpp
View file

@ -17,7 +17,12 @@ namespace sprout {
namespace containers {
namespace detail {
template<typename Container, typename Prev, typename = void>
struct deep_internal_impl
struct deep_internal_impl;
template<typename Container, typename Prev>
struct deep_internal_impl<
Container, Prev,
typename std::enable_if<!std::is_same<Container, Prev&&>::value>::type
>
: public sprout::containers::detail::deep_internal_impl<
typename sprout::containers::internal<Container>::type, Container
>

2
sprout/container/shrink_to_fit.hpp
View file

@ -32,7 +32,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_shrink_to_fit_test<T>::test(0))>::type>
struct has_mem_shrink_to_fit
: public Base_

2
sprout/container/weak_rebind_size.hpp
View file

@ -24,7 +24,7 @@ namespace sprout {
sprout::true_type sprout_has_xxx_impl_check_template_rebind_size(int);
template<typename T>
sprout::false_type sprout_has_xxx_impl_check_template_rebind_size(long);
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = decltype(sprout::containers::detail::sprout_has_xxx_impl_check_template_rebind_size<T>(0))>
struct has_rebind_size
: public Base_

24
sprout/ctype/ascii.hpp
View file

@ -192,51 +192,51 @@ namespace sprout {
#define SPROUT_CTYPE_ASCII_DECL(CHAR_TYPE, PREFIX) \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, alnum))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & (sprout::ascii::detail::alpha | sprout::ascii::detail::digit); \
return (sprout::ascii::detail::get_value(c) & (sprout::ascii::detail::alpha | sprout::ascii::detail::digit)) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, alpha))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::alpha; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::alpha) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, blank))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::blank; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::blank) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, cntrl))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::cntrl; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::cntrl) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, digit))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::digit; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::digit) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, graph))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::graph; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::graph) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, lower))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::lower; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::lower) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, print))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::print; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::print) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, punct))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::punct; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::punct) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, space))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::space; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::space) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, upper))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::upper; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::upper) != 0; \
} \
inline SPROUT_CONSTEXPR bool \
SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, xdigit))(CHAR_TYPE c) { \
return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::xdigit; \
return (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::xdigit) != 0; \
} \
inline SPROUT_CONSTEXPR CHAR_TYPE \
SPROUT_PP_CAT(to, SPROUT_PP_CAT(PREFIX, lower))(CHAR_TYPE c) { \

10
sprout/detail/integer.hpp
View file

@ -174,11 +174,11 @@ namespace sprout {
struct uint_value_t {
typedef typename sprout::detail::int_least_helper<
5
+ (MaxValue <= sprout::numeric_limits<long long>::max())
+ (MaxValue <= sprout::numeric_limits<long>::max())
+ (MaxValue <= sprout::numeric_limits<int>::max())
+ (MaxValue <= sprout::numeric_limits<short>::max())
+ (MaxValue <= sprout::numeric_limits<signed char>::max())
+ (MaxValue <= static_cast<unsigned long long>(sprout::numeric_limits<long long>::max()))
+ (MaxValue <= static_cast<unsigned long long>(sprout::numeric_limits<long>::max()))
+ (MaxValue <= static_cast<unsigned long long>(sprout::numeric_limits<int>::max()))
+ (MaxValue <= static_cast<unsigned long long>(sprout::numeric_limits<short>::max()))
+ (MaxValue <= static_cast<unsigned long long>(sprout::numeric_limits<signed char>::max()))
>::least least;
typedef typename sprout::detail::int_fast_t<least>::type fast;
};

4
sprout/detail/integer/integer_mask.hpp
View file

@ -43,8 +43,8 @@ namespace sprout {
struct low_bits_mask_t<sprout::numeric_limits<TYPE>::digits> { \
public: \
typedef sprout::numeric_limits<TYPE> limits_type; \
typedef typename sprout::detail::uint_t<limits_type::digits>::least least; \
typedef typename sprout::detail::uint_t<limits_type::digits>::fast fast; \
typedef sprout::detail::uint_t<limits_type::digits>::least least; \
typedef sprout::detail::uint_t<limits_type::digits>::fast fast; \
public: \
SPROUT_STATIC_CONSTEXPR least sig_bits = ~(least(0u)); \
SPROUT_STATIC_CONSTEXPR fast sig_bits_fast = fast(sig_bits); \

24
sprout/detail/math/int.hpp
View file

@ -16,6 +16,30 @@
namespace sprout {
namespace detail {
//
// int_digits_mf
//
template<typename IntType, IntType Val, int Base = 10, bool = Val != 0>
struct int_digits_mf_impl;
template<typename IntType, IntType Val, int Base>
struct int_digits_mf_impl<IntType, Val, Base, false>
: public sprout::integral_constant<IntType, 0>
{};
template<typename IntType, IntType Val, int Base>
struct int_digits_mf_impl<IntType, Val, Base, true>
: public sprout::integral_constant<IntType, 1 + sprout::detail::int_digits_mf_impl<IntType, Val / Base, Base>::value>
{};
template<typename IntType, IntType Val, int Base = 10, bool = Val != 0>
struct int_digits_mf;
template<typename IntType, IntType Val, int Base>
struct int_digits_mf<IntType, Val, Base, false>
: public sprout::integral_constant<IntType, 1>
{};
template<typename IntType, IntType Val, int Base>
struct int_digits_mf<IntType, Val, Base, true>
: public sprout::integral_constant<IntType, 1 + sprout::detail::int_digits_mf_impl<IntType, Val / Base, Base>::value>
{};
//
// int_pow
//

12
sprout/detail/predef.hpp
View file

@ -9,17 +9,7 @@
#define SPROUT_DETAIL_PREDEF_HPP
#include <sprout/config.hpp>
//
// SPROUT_VERSION_NUMBER
//
#define SPROUT_VERSION_NUMBER(MAJOR, MINOR, PATCH) \
((((MAJOR) % 100) * 10000000) + (((MINOR) % 100) * 100000) + ((PATCH) % 100000))
//
// SPROUT_VERSION_NUMBER_ZERO
//
#define SPROUT_VERSION_NUMBER_ZERO \
SPROUT_VERSION_NUMBER(0, 0, 0)
#include <sprout/predef/version_number.hpp>
//
// SPROUT_AVAILABLE_GCC

5
sprout/functional/mem_fn.hpp
View file

@ -13,6 +13,7 @@
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/functional/base.hpp>
#include <sprout/type_traits/identity.hpp>
namespace sprout {
// 20.8.10 member function adaptors
@ -200,13 +201,13 @@ namespace sprout {
template<typename T>
static two check_const(T&, Class const*);
template<typename T>
static two check_const(T&, const volatile void*);
static two check_const(T&, void const volatile*);
public:
template<typename T>
struct result_type
: public sprout::detail::mem_fn_const_or_non<
Res,
(sizeof(two) == sizeof(check_const<T>(get_ref<T>(), (T*)0)))
(sizeof(two) == sizeof(check_const<T>(get_ref<T>(), sprout::identity<T*>::type())))
>
{};
template<typename Signature>

8
sprout/functional/type_traits/weak_result_type.hpp
View file

@ -41,41 +41,49 @@ namespace sprout {
public:
typedef R result_type;
};
#if !defined(_MSC_VER)
template<typename R, typename... Args>
struct weak_result_type_impl<R (Args......)> {
public:
typedef R result_type;
};
#endif
template<typename R, typename... Args>
struct weak_result_type_impl<R (&)(Args...)> {
public:
typedef R result_type;
};
#if !defined(_MSC_VER)
template<typename R, typename... Args>
struct weak_result_type_impl<R (&)(Args......)> {
public:
typedef R result_type;
};
#endif
template<typename R, typename... Args>
struct weak_result_type_impl<R (*)(Args...)> {
public:
typedef R result_type;
};
#if !defined(_MSC_VER)
template<typename R, typename... Args>
struct weak_result_type_impl<R (*)(Args......)> {
public:
typedef R result_type;
};
#endif
template<typename R, typename Class, typename... Args>
struct weak_result_type_impl<R (Class::*)(Args...)> {
public:
typedef R result_type;
};
#if !defined(_MSC_VER)
template<typename R, typename Class, typename... Args>
struct weak_result_type_impl<R (Class::*)(Args......)> {
public:
typedef R result_type;
};
#endif
#if SPROUT_CLANG_OR_LATER(3, 6, 0)
# pragma clang diagnostic pop
#endif

4
sprout/generator/generator_access_traits.hpp
View file

@ -28,7 +28,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::generators::detail::has_mem_generated_value_test<T>::test(0))>::type>
struct has_mem_generated_value
: public Base_
@ -103,7 +103,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::generators::detail::has_mem_next_generator_test<T>::test(0))>::type>
struct has_mem_next_generator
: public Base_

3
sprout/iterator/generator_iterator.hpp
View file

@ -16,6 +16,7 @@
#include <sprout/limits.hpp>
#include <sprout/generator/functions.hpp>
#include <sprout/utility/swap.hpp>
#include <sprout/type_traits/identity.hpp>
namespace sprout {
//
@ -34,7 +35,7 @@ namespace sprout {
public:
typedef Generator generator_type;
typedef std::forward_iterator_tag iterator_category;
typedef decltype(sprout::generators::generated_value(std::declval<Generator const>())) reference;
typedef typename sprout::identity<decltype(sprout::generators::generated_value(std::declval<Generator const>()))>::type reference;
typedef typename std::remove_reference<reference>::type value_type;
typedef std::ptrdiff_t difference_type;
typedef value_type* pointer;

6
sprout/math/bernoulli.hpp
View file

@ -178,7 +178,7 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_INNER(SPROUT_BERNOULLI_TABLE_DEF_FLOAT)
;
};
SPROUT_CONSTEXPR_OR_CONST typename sprout::math::detail::bernoulli_numbers<
SPROUT_CONSTEXPR_OR_CONST sprout::math::detail::bernoulli_numbers<
float
>::table_type sprout::math::detail::bernoulli_numbers<
float
@ -197,7 +197,7 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_INNER(SPROUT_BERNOULLI_TABLE_DEF_DOUBLE)
;
};
SPROUT_CONSTEXPR_OR_CONST typename sprout::math::detail::bernoulli_numbers<
SPROUT_CONSTEXPR_OR_CONST sprout::math::detail::bernoulli_numbers<
double
>::table_type sprout::math::detail::bernoulli_numbers<
double
@ -216,7 +216,7 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR_DATA_MEMBER_INNER(SPROUT_BERNOULLI_TABLE_DEF_LONG_DOUBLE)
;
};
SPROUT_CONSTEXPR_OR_CONST typename sprout::math::detail::bernoulli_numbers<
SPROUT_CONSTEXPR_OR_CONST sprout::math::detail::bernoulli_numbers<
long double
>::table_type sprout::math::detail::bernoulli_numbers<
long double

4
sprout/memory/addressof.hpp
View file

@ -31,7 +31,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_mem_address_op_test<T>::test(0))>::type>
struct has_mem_address_op
: public Base_
@ -53,7 +53,7 @@ namespace sprout {
static sprout::true_type test(int);
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = typename sprout::identity<decltype(sprout::detail::has_nonmem_address_op_test<T>::test(0))>::type>
struct has_nonmem_address_op
: public Base_

8
sprout/net/endian.hpp
View file

@ -54,9 +54,11 @@ namespace sprout {
* Get 'n'th byte from 'val'
*/
template<typename T>
inline SPROUT_CONSTEXPR T
inline SPROUT_CONSTEXPR std::uint_fast8_t
byte_at(T val, std::uint_fast8_t n) {
return sprout::net::detail::rshift_by((val & sprout::net::detail::mask_at<T>(n)), n);
return static_cast<std::uint_fast8_t>(
sprout::net::detail::rshift_by((val & sprout::net::detail::mask_at<T>(n)), n)
);
}
/*
@ -96,7 +98,7 @@ namespace sprout {
template<typename T>
inline SPROUT_CONSTEXPR T
reverse_impl(T val, std::uint_fast8_t n1, std::uint_fast8_t n2) {
return n1 > n2 ? val : sprout::net::detail::reverse_impl(swap(val, n1, n2), n1 + 1, n2 - 1);
return n1 > n2 ? val : sprout::net::detail::reverse_impl(sprout::net::detail::swap(val, n1, n2), n1 + 1, n2 - 1);
}
/*

6
sprout/rational/udl.hpp
View file

@ -21,7 +21,7 @@ namespace sprout {
//
inline SPROUT_CONSTEXPR sprout::rational<int>
operator"" _r(unsigned long long x) {
return sprout::rational<int>(x);
return sprout::rational<int>(static_cast<int>(x));
}
//
@ -30,11 +30,11 @@ namespace sprout {
//
inline SPROUT_CONSTEXPR sprout::rational<long>
operator"" _rl(unsigned long long x) {
return sprout::rational<long>(x);
return sprout::rational<long>(static_cast<long>(x));
}
inline SPROUT_CONSTEXPR sprout::rational<long>
operator"" _rL(unsigned long long x) {
return sprout::rational<long>(x);
return sprout::rational<long>(static_cast<long>(x));
}
//

3
sprout/string/float_to_string.hpp
View file

@ -20,6 +20,7 @@
#include <sprout/math/isnan.hpp>
#include <sprout/math/signbit.hpp>
#include <sprout/math/floor.hpp>
#include <sprout/tpp/algorithm/max_element.hpp>
#include <sprout/detail/char_literal.hpp>
#include <sprout/detail/char_conversion.hpp>
#include <sprout/detail/math/int.hpp>
@ -108,7 +109,7 @@ namespace sprout {
struct printed_float_exponent10_digits
: public sprout::integral_constant<
std::size_t,
NS_SSCRISK_CEL_OR_SPROUT::max(sprout::detail::int_digits(sprout::numeric_limits<FloatType>::max_exponent10), 2)
sprout::tpp::max_element_c<int, sprout::detail::int_digits_mf<int, sprout::numeric_limits<FloatType>::max_exponent10>::value, 2>::value
>
{};
} // namespace detail

8
sprout/tuple/tuple/tuple_element.hpp
View file

@ -23,7 +23,11 @@ namespace sprout {
// tuple_element
//
namespace detail {
#if defined(_MSC_VER)
template<std::size_t I, typename T, bool = true>
#else
template<std::size_t I, typename T, bool = sprout::has_value<std::tuple_size<T> >::value>
#endif
struct valid_tuple_index;
template<std::size_t I, typename T>
struct valid_tuple_index<I, T, false>
@ -34,7 +38,11 @@ namespace sprout {
: public sprout::bool_constant<(I < std::tuple_size<T>::value)>
{};
#if defined(_MSC_VER)
template<std::size_t I, typename T, bool = true>
#else
template<std::size_t I, typename T, bool = sprout::has_type<std::tuple_element<I, T> >::value && sprout::tuples::detail::valid_tuple_index<I, T>::value>
#endif
struct tuple_element_default;
template<std::size_t I, typename T>
struct tuple_element_default<I, T, false>

4
sprout/tuple/tuple/tuple_size.hpp
View file

@ -21,7 +21,11 @@ namespace sprout {
// tuple_size
//
namespace detail {
#if defined(_MSC_VER)
template<typename T, bool = true>
#else
template<typename T, bool = sprout::has_value<std::tuple_size<T> >::value>
#endif
struct tuple_size_default;
template<typename T>
struct tuple_size_default<T, false>

2
sprout/type/string/to_string.hpp
View file

@ -23,6 +23,7 @@
namespace sprout {
namespace types {
#ifndef SPROUT_CONFIG_DISABLE_CONSTEXPR
//
// to_string
//
@ -85,6 +86,7 @@ namespace sprout {
typedef typename sprout::types::to_string<SPROUT_PP_CAT(SPROUT_TYPES_STRING_TYPEDEF_PROXY_, NUM)>::type TYPE
# define SPROUT_TYPES_STRING_TYPEDEF(SOURCE, TYPE) \
SPROUT_TYPES_STRING_TYPEDEF_IMPL(SOURCE, TYPE, SPROUT_PP_SOME_NUMBER())
#endif
} // namespace types
} // namespace sprout

42
sprout/type/type_tuple_decl.hpp
View file

@ -72,13 +72,49 @@ namespace sprout {
: public sprout::identity<sprout::types::type_tuple<Types1..., Types2...> >
{};
// !!! OLD:
//template<std::size_t I, std::size_t N, typename T, typename Enable = void>
//struct tuple_skip;
//template<std::size_t I, std::size_t N, typename Head, typename... Tail>
//struct tuple_skip<
// I, N, sprout::types::type_tuple<Head, Tail...>,
// typename std::enable_if<(I == 0)>::type
//>
// : public sprout::identity<sprout::types::type_tuple<Head, Tail...> >
//{};
//template<std::size_t I, std::size_t N, typename Head, typename... Tail>
//struct tuple_skip<
// I, N, sprout::types::type_tuple<Head, Tail...>,
// typename std::enable_if<(I != 0 && I < N / 2)>::type
//>
// : public sprout::types::detail::tuple_skip<
// I - 1, N / 2 - 1,
// sprout::types::type_tuple<Tail...>
// >
//{};
//template<std::size_t I, std::size_t N, typename Head, typename... Tail>
//struct tuple_skip<
// I, N, sprout::types::type_tuple<Head, Tail...>,
// typename std::enable_if<(I != 0 && I >= N / 2)>::type
//>
// : public sprout::types::detail::tuple_skip<
// I - N / 2, N - N / 2,
// typename sprout::types::detail::tuple_skip<N / 2 - 1, N / 2, sprout::types::type_tuple<Tail...> >::type
// >
//{};
//template<std::size_t I, typename Tup>
//struct tuple_drop;
//template<std::size_t I, typename... Types>
//struct tuple_drop<I, sprout::types::type_tuple<Types...> >
// : public sprout::types::detail::tuple_skip<I, sizeof...(Types), sprout::types::type_tuple<Types...>>
//{};
template<typename IndexTuple>
struct tuple_drop_helper;
template<sprout::index_t... Indexes>
struct tuple_drop_helper<sprout::index_tuple<Indexes...> > {
template<typename... Types>
static sprout::types::type_tuple<typename Types::type...>
eval(typename sprout::types::detail::dummy_index<Indexes>::type*..., Types*...);
eval(typename sprout::types::detail::dummy_index<Indexes>::type*..., Types*...);
};
template<std::size_t I, typename Tup, bool = (I <= std::tuple_size<Tup>::value)>
struct tuple_drop_impl;
@ -90,8 +126,8 @@ namespace sprout {
struct tuple_drop_impl<I, sprout::types::type_tuple<Types...>, true>
: public sprout::identity<decltype(
sprout::types::detail::tuple_drop_helper<typename sprout::index_n<0, I>::type>
::eval(static_cast<sprout::identity<Types>*>(0)...)
)>::type
::eval(typename sprout::identity<sprout::identity<Types>*>::type()...)
)>::type
{};
template<std::size_t I, typename Tup>
struct tuple_drop

6
sprout/type_traits/has_xxx.hpp
View file

@ -18,7 +18,7 @@
// SPROUT_HAS_XXX_TYPE_DEF
// SPROUT_HAS_XXX_TYPE_DEF_LAZY
//
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
#define SPROUT_HAS_XXX_TYPE_DEF_IMPL(NAME, TYPE, NUM) \
template<typename T, typename = typename T::TYPE> \
sprout::true_type SPROUT_PP_CAT(SPROUT_PP_CAT(SPROUT_PP_CAT(sprout_has_xxx_impl_check_type_, TYPE), NAME), NUM)(int); \
@ -48,7 +48,7 @@
// SPROUT_HAS_XXX_VALUE_DEF
// SPROUT_HAS_XXX_VALUE_DEF_LAZY
//
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
#define SPROUT_HAS_XXX_VALUE_DEF_IMPL(NAME, VALUE, NUM) \
template<typename T, typename sprout::identity<decltype(&T::VALUE)>::type = &T::VALUE> \
sprout::true_type SPROUT_PP_CAT(SPROUT_PP_CAT(SPROUT_PP_CAT(sprout_has_xxx_impl_check_value_, VALUE), NAME), NUM)(int); \
@ -78,7 +78,7 @@
// SPROUT_HAS_XXX_TEMPLATE_DEF
// SPROUT_HAS_XXX_TEMPLATE_DEF_LAZY
//
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
#define SPROUT_HAS_XXX_TEMPLATE_DEF_IMPL(NAME, TEMPLATE, NUM) \
template<typename T, template<typename...> class = T::template TEMPLATE> \
sprout::true_type SPROUT_PP_CAT(SPROUT_PP_CAT(SPROUT_PP_CAT(sprout_has_xxx_impl_check_type_, TEMPLATE), NAME), NUM)(int); \

4
sprout/type_traits/inherit_if_xxx.hpp
View file

@ -63,12 +63,12 @@
> { \
public: \
SPROUT_STATIC_CONSTEXPR std::size_t ALIAS = T::CONSTANT; \
}; \
};/* \
template<typename T> \
SPROUT_CONSTEXPR_OR_CONST std::size_t NAME< \
T, \
typename std::enable_if<SPROUT_PP_CAT(SPROUT_PP_CAT(sprout_inherit_if_xxx_constant_def_impl_has_, CONSTANT), NUM)<T>::value>::type \
>::ALIAS
>::ALIAS !!! */
#else
#define SPROUT_INHERIT_ALIAS_IF_XXX_CONSTANT_DEF_IMPL(NAME, ALIAS, CONSTANT, NUM) \
SPROUT_HAS_XXX_VALUE_DEF(SPROUT_PP_CAT(SPROUT_PP_CAT(sprout_inherit_if_xxx_constant_def_impl_has_, CONSTANT), NUM), CONSTANT); \

2
sprout/type_traits/is_destructible.hpp
View file

@ -29,7 +29,7 @@ namespace sprout {
template<typename>
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = sprout::identity<decltype(sprout::detail::is_destructible_helper::test<T>(0))>::type>
struct is_destructible_impl_0
: public Base_

2
sprout/type_traits/is_nothrow_destructible.hpp
View file

@ -26,7 +26,7 @@ namespace sprout {
template<typename>
static sprout::false_type test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<typename T, typename Base_ = sprout::identity<decltype(sprout::detail::is_nothrow_destructible_helper::test<T>(0))>::type>
struct is_nothrow_destructible_impl_0
: public Base_

21
sprout/type_traits/result_of.hpp
View file

@ -8,13 +8,23 @@
#ifndef SPROUT_TYPE_TRAITS_RESULT_OF_HPP
#define SPROUT_TYPE_TRAITS_RESULT_OF_HPP
#if defined(_MSC_VER) && (_MSC_VER <= 1900)
# include <functional>
#endif
#include <utility>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/detail/nil_base.hpp>
#include <sprout/type/type_tuple.hpp>
namespace sprout {
#if defined(_MSC_VER) && (_MSC_VER <= 1900)
//
// result_of
//
using std::result_of;
#else
//
// result_of
//
@ -26,7 +36,7 @@ namespace sprout {
template<typename...>
static sprout::detail::nil_base test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<
typename MemPtr, typename Arg, typename... Args,
typename Base_ = sprout::identity<decltype(sprout::detail::result_of_memfun_ref_helper::test<MemPtr, Arg, Args...>(0))>::type
@ -48,7 +58,7 @@ namespace sprout {
template<typename...>
static sprout::detail::nil_base test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<
typename MemPtr, typename Arg, typename... Args,
typename Base_ = sprout::identity<decltype(sprout::detail::result_of_memfun_deref_helper::test<MemPtr, Arg, Args...>(0))>::type
@ -70,7 +80,7 @@ namespace sprout {
template<typename, typename>
static sprout::detail::nil_base test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<
typename MemPtr, typename Arg,
typename Base_ = sprout::identity<decltype(sprout::detail::result_of_memobj_ref_helper::test<MemPtr, Arg>(0))>::type
@ -92,7 +102,7 @@ namespace sprout {
template<typename, typename>
static sprout::detail::nil_base test(...);
};
#if defined(_MSC_VER)
#if defined(_MSC_VER) && (_MSC_VER > 1900)
template<
typename MemPtr, typename Arg,
typename Base_ = sprout::identity<decltype(sprout::detail::result_of_memobj_deref_helper::test<MemPtr, Arg>(0))>::type
@ -147,7 +157,7 @@ namespace sprout {
public:
template<typename F, typename... Args>
static sprout::identity<decltype(std::declval<F>()(std::declval<Args>()...))> test(int);
template<typename...>
template<typename, typename...>
static sprout::detail::nil_base test(...);
};
#if defined(_MSC_VER)
@ -194,6 +204,7 @@ namespace sprout {
Functor, Args...
>
{};
#endif
#if SPROUT_USE_TEMPLATE_ALIASES
template<typename F, typename... ArgTypes>

2
sprout/utility/forward.hpp
View file

@ -44,7 +44,7 @@ namespace sprout {
//
// SPROUT_FORWARD
//
#if SPROUT_PP_VARIADICS
#if SPROUT_PP_VARIADICS && !defined(_MSC_VER)
# define SPROUT_FORWARD_1(VAR) \
SPROUT_AUTO_FORWARD(VAR)
# define SPROUT_FORWARD(...) \

340
testspr/header_all.hpp
View file

@ -86,179 +86,179 @@
#include <sprout/weed.hpp>
#include <sprout/workaround.hpp>
#include <sprout/algorithm/bogo_sort.hpp>
#include <sprout/algorithm/bogo_sort_result.hpp>
#include <sprout/algorithm/bozo_sort.hpp>
#include <sprout/algorithm/bozo_sort_result.hpp>
#include <sprout/algorithm/clamp_range.hpp>
#include <sprout/algorithm/clamp_range_copy.hpp>
#include <sprout/algorithm/copy.hpp>
#include <sprout/algorithm/copy_backward.hpp>
#include <sprout/algorithm/copy_if.hpp>
#include <sprout/algorithm/copy_n.hpp>
#include <sprout/algorithm/copy_until.hpp>
#include <sprout/algorithm/copy_while.hpp>
#include <sprout/algorithm/fill.hpp>
#include <sprout/algorithm/fill_n.hpp>
#include <sprout/algorithm/generate.hpp>
#include <sprout/algorithm/generate_n.hpp>
#include <sprout/algorithm/inplace_merge.hpp>
#include <sprout/algorithm/iter_swap.hpp>
#include <sprout/algorithm/make_heap.hpp>
#include <sprout/algorithm/make_partial_heap.hpp>
#include <sprout/algorithm/merge.hpp>
#include <sprout/algorithm/move.hpp>
#include <sprout/algorithm/move_backward.hpp>
#include <sprout/algorithm/next_permutation.hpp>
#include <sprout/algorithm/nth_element.hpp>
#include <sprout/algorithm/partial_sort.hpp>
#include <sprout/algorithm/partial_sort_copy.hpp>
#include <sprout/algorithm/partition.hpp>
#include <sprout/algorithm/partition_copy.hpp>
#include <sprout/algorithm/pop_heap.hpp>
#include <sprout/algorithm/prev_permutation.hpp>
#include <sprout/algorithm/push_heap.hpp>
#include <sprout/algorithm/random_shuffle.hpp>
#include <sprout/algorithm/random_swap.hpp>
#include <sprout/algorithm/random_swap_result.hpp>
#include <sprout/algorithm/recurrence.hpp>
#include <sprout/algorithm/recurrence_n.hpp>
#include <sprout/algorithm/remove.hpp>
#include <sprout/algorithm/remove_copy.hpp>
#include <sprout/algorithm/remove_copy_if.hpp>
#include <sprout/algorithm/remove_if.hpp>
#include <sprout/algorithm/replace.hpp>
#include <sprout/algorithm/replace_copy.hpp>
#include <sprout/algorithm/replace_copy_if.hpp>
#include <sprout/algorithm/replace_if.hpp>
#include <sprout/algorithm/reverse.hpp>
#include <sprout/algorithm/reverse_copy.hpp>
#include <sprout/algorithm/rotate.hpp>
#include <sprout/algorithm/rotate_copy.hpp>
#include <sprout/algorithm/sample.hpp>
#include <sprout/algorithm/set_difference.hpp>
#include <sprout/algorithm/set_intersection.hpp>
#include <sprout/algorithm/set_symmetric_difference.hpp>
#include <sprout/algorithm/set_union.hpp>
#include <sprout/algorithm/shuffle.hpp>
#include <sprout/algorithm/shuffle_result.hpp>
#include <sprout/algorithm/sort.hpp>
#include <sprout/algorithm/sort_heap.hpp>
#include <sprout/algorithm/stable_partition.hpp>
#include <sprout/algorithm/stable_partition_copy.hpp>
#include <sprout/algorithm/stable_sort.hpp>
#include <sprout/algorithm/swap_element.hpp>
#include <sprout/algorithm/swap_element_copy.hpp>
#include <sprout/algorithm/swap_ranges.hpp>
#include <sprout/algorithm/transform.hpp>
#include <sprout/algorithm/unfold.hpp>
#include <sprout/algorithm/unfold_n.hpp>
#include <sprout/algorithm/unique.hpp>
#include <sprout/algorithm/unique_copy.hpp>
#include <sprout/algorithm/string/to_lower.hpp>
#include <sprout/algorithm/string/to_lower_copy.hpp>
#include <sprout/algorithm/string/to_upper.hpp>
#include <sprout/algorithm/string/to_upper_copy.hpp>
//#include <sprout/algorithm/bogo_sort.hpp>
//#include <sprout/algorithm/bogo_sort_result.hpp>
//#include <sprout/algorithm/bozo_sort.hpp>
//#include <sprout/algorithm/bozo_sort_result.hpp>
//#include <sprout/algorithm/clamp_range.hpp>
//#include <sprout/algorithm/clamp_range_copy.hpp>
//#include <sprout/algorithm/copy.hpp>
//#include <sprout/algorithm/copy_backward.hpp>
//#include <sprout/algorithm/copy_if.hpp>
//#include <sprout/algorithm/copy_n.hpp>
//#include <sprout/algorithm/copy_until.hpp>
//#include <sprout/algorithm/copy_while.hpp>
//#include <sprout/algorithm/fill.hpp>
//#include <sprout/algorithm/fill_n.hpp>
//#include <sprout/algorithm/generate.hpp>
//#include <sprout/algorithm/generate_n.hpp>
//#include <sprout/algorithm/inplace_merge.hpp>
//#include <sprout/algorithm/iter_swap.hpp>
//#include <sprout/algorithm/make_heap.hpp>
//#include <sprout/algorithm/make_partial_heap.hpp>
//#include <sprout/algorithm/merge.hpp>
//#include <sprout/algorithm/move.hpp>
//#include <sprout/algorithm/move_backward.hpp>
//#include <sprout/algorithm/next_permutation.hpp>
//#include <sprout/algorithm/nth_element.hpp>
//#include <sprout/algorithm/partial_sort.hpp>
//#include <sprout/algorithm/partial_sort_copy.hpp>
//#include <sprout/algorithm/partition.hpp>
//#include <sprout/algorithm/partition_copy.hpp>
//#include <sprout/algorithm/pop_heap.hpp>
//#include <sprout/algorithm/prev_permutation.hpp>
//#include <sprout/algorithm/push_heap.hpp>
//#include <sprout/algorithm/random_shuffle.hpp>
//#include <sprout/algorithm/random_swap.hpp>
//#include <sprout/algorithm/random_swap_result.hpp>
//#include <sprout/algorithm/recurrence.hpp>
//#include <sprout/algorithm/recurrence_n.hpp>
//#include <sprout/algorithm/remove.hpp>
//#include <sprout/algorithm/remove_copy.hpp>
//#include <sprout/algorithm/remove_copy_if.hpp>
//#include <sprout/algorithm/remove_if.hpp>
//#include <sprout/algorithm/replace.hpp>
//#include <sprout/algorithm/replace_copy.hpp>
//#include <sprout/algorithm/replace_copy_if.hpp>
//#include <sprout/algorithm/replace_if.hpp>
//#include <sprout/algorithm/reverse.hpp>
//#include <sprout/algorithm/reverse_copy.hpp>
//#include <sprout/algorithm/rotate.hpp>
//#include <sprout/algorithm/rotate_copy.hpp>
//#include <sprout/algorithm/sample.hpp>
//#include <sprout/algorithm/set_difference.hpp>
//#include <sprout/algorithm/set_intersection.hpp>
//#include <sprout/algorithm/set_symmetric_difference.hpp>
//#include <sprout/algorithm/set_union.hpp>
//#include <sprout/algorithm/shuffle.hpp>
//#include <sprout/algorithm/shuffle_result.hpp>
//#include <sprout/algorithm/sort.hpp>
//#include <sprout/algorithm/sort_heap.hpp>
//#include <sprout/algorithm/stable_partition.hpp>
//#include <sprout/algorithm/stable_partition_copy.hpp>
//#include <sprout/algorithm/stable_sort.hpp>
//#include <sprout/algorithm/swap_element.hpp>
//#include <sprout/algorithm/swap_element_copy.hpp>
//#include <sprout/algorithm/swap_ranges.hpp>
//#include <sprout/algorithm/transform.hpp>
//#include <sprout/algorithm/unfold.hpp>
//#include <sprout/algorithm/unfold_n.hpp>
//#include <sprout/algorithm/unique.hpp>
//#include <sprout/algorithm/unique_copy.hpp>
//#include <sprout/algorithm/string/to_lower.hpp>
//#include <sprout/algorithm/string/to_lower_copy.hpp>
//#include <sprout/algorithm/string/to_upper.hpp>
//#include <sprout/algorithm/string/to_upper_copy.hpp>
#include <sprout/numeric/adjacent_difference.hpp>
#include <sprout/numeric/dft/amplitude_spectrum.hpp>
#include <sprout/numeric/dft/dft.hpp>
#include <sprout/numeric/dft/idft.hpp>
#include <sprout/numeric/dft/phase_spectrum.hpp>
#include <sprout/numeric/dft/sawtooth.hpp>
#include <sprout/numeric/dft/sinusoid.hpp>
#include <sprout/numeric/dft/spectrum.hpp>
#include <sprout/numeric/dft/square.hpp>
#include <sprout/numeric/dft/triangle.hpp>
#include <sprout/numeric/dft/wave.hpp>
#include <sprout/numeric/iota.hpp>
#include <sprout/numeric/partial_sum.hpp>
//#include <sprout/numeric/adjacent_difference.hpp>
//#include <sprout/numeric/dft/amplitude_spectrum.hpp>
//#include <sprout/numeric/dft/dft.hpp>
//#include <sprout/numeric/dft/idft.hpp>
//#include <sprout/numeric/dft/phase_spectrum.hpp>
//#include <sprout/numeric/dft/sawtooth.hpp>
//#include <sprout/numeric/dft/sinusoid.hpp>
//#include <sprout/numeric/dft/spectrum.hpp>
//#include <sprout/numeric/dft/square.hpp>
//#include <sprout/numeric/dft/triangle.hpp>
//#include <sprout/numeric/dft/wave.hpp>
//#include <sprout/numeric/iota.hpp>
//#include <sprout/numeric/partial_sum.hpp>
#include <sprout/operation/append.hpp>
#include <sprout/operation/append_back.hpp>
#include <sprout/operation/append_front.hpp>
#include <sprout/operation/erase.hpp>
#include <sprout/operation/erase_n.hpp>
#include <sprout/operation/insert.hpp>
#include <sprout/operation/insert_n.hpp>
#include <sprout/operation/pop_back.hpp>
#include <sprout/operation/pop_back_n.hpp>
#include <sprout/operation/pop_front.hpp>
#include <sprout/operation/pop_front_n.hpp>
#include <sprout/operation/push_back.hpp>
#include <sprout/operation/push_back_n.hpp>
#include <sprout/operation/push_front.hpp>
#include <sprout/operation/push_front_n.hpp>
#include <sprout/operation/realign.hpp>
#include <sprout/operation/realign_to.hpp>
#include <sprout/operation/resize.hpp>
#include <sprout/operation/resize_backward.hpp>
#include <sprout/operation/set.hpp>
//#include <sprout/operation/append.hpp>
//#include <sprout/operation/append_back.hpp>
//#include <sprout/operation/append_front.hpp>
//#include <sprout/operation/erase.hpp>
//#include <sprout/operation/erase_n.hpp>
//#include <sprout/operation/insert.hpp>
//#include <sprout/operation/insert_n.hpp>
//#include <sprout/operation/pop_back.hpp>
//#include <sprout/operation/pop_back_n.hpp>
//#include <sprout/operation/pop_front.hpp>
//#include <sprout/operation/pop_front_n.hpp>
//#include <sprout/operation/push_back.hpp>
//#include <sprout/operation/push_back_n.hpp>
//#include <sprout/operation/push_front.hpp>
//#include <sprout/operation/push_front_n.hpp>
//#include <sprout/operation/realign.hpp>
//#include <sprout/operation/realign_to.hpp>
//#include <sprout/operation/resize.hpp>
//#include <sprout/operation/resize_backward.hpp>
//#include <sprout/operation/set.hpp>
#include <sprout/range/algorithm/bogo_sort.hpp>
#include <sprout/range/algorithm/bozo_sort.hpp>
#include <sprout/range/algorithm/clamp_range.hpp>
#include <sprout/range/algorithm/clamp_range_copy.hpp>
#include <sprout/range/algorithm/copy.hpp>
#include <sprout/range/algorithm/copy_backward.hpp>
#include <sprout/range/algorithm/copy_if.hpp>
#include <sprout/range/algorithm/copy_until.hpp>
#include <sprout/range/algorithm/copy_while.hpp>
#include <sprout/range/algorithm/fill.hpp>
#include <sprout/range/algorithm/generate.hpp>
#include <sprout/range/algorithm/inplace_merge.hpp>
#include <sprout/range/algorithm/make_heap.hpp>
#include <sprout/range/algorithm/merge.hpp>
#include <sprout/range/algorithm/move.hpp>
#include <sprout/range/algorithm/move_backward.hpp>
#include <sprout/range/algorithm/next_permutation.hpp>
#include <sprout/range/algorithm/nth_element.hpp>
#include <sprout/range/algorithm/partial_sort.hpp>
#include <sprout/range/algorithm/partial_sort_copy.hpp>
#include <sprout/range/algorithm/partition.hpp>
#include <sprout/range/algorithm/partition_copy.hpp>
#include <sprout/range/algorithm/pop_heap.hpp>
#include <sprout/range/algorithm/prev_permutation.hpp>
#include <sprout/range/algorithm/push_heap.hpp>
#include <sprout/range/algorithm/random_shuffle.hpp>
#include <sprout/range/algorithm/random_swap.hpp>
#include <sprout/range/algorithm/remove.hpp>
#include <sprout/range/algorithm/remove_copy.hpp>
#include <sprout/range/algorithm/remove_copy_if.hpp>
#include <sprout/range/algorithm/remove_if.hpp>
#include <sprout/range/algorithm/replace.hpp>
#include <sprout/range/algorithm/replace_copy.hpp>
#include <sprout/range/algorithm/replace_copy_if.hpp>
#include <sprout/range/algorithm/replace_if.hpp>
#include <sprout/range/algorithm/reverse.hpp>
#include <sprout/range/algorithm/reverse_copy.hpp>
#include <sprout/range/algorithm/rotate.hpp>
#include <sprout/range/algorithm/rotate_copy.hpp>
#include <sprout/range/algorithm/sample.hpp>
#include <sprout/range/algorithm/set_difference.hpp>
#include <sprout/range/algorithm/set_intersection.hpp>
#include <sprout/range/algorithm/set_symmetric_difference.hpp>
#include <sprout/range/algorithm/set_union.hpp>
#include <sprout/range/algorithm/shuffle.hpp>
#include <sprout/range/algorithm/sort.hpp>
#include <sprout/range/algorithm/sort_heap.hpp>
#include <sprout/range/algorithm/stable_partition.hpp>
#include <sprout/range/algorithm/stable_partition_copy.hpp>
#include <sprout/range/algorithm/stable_sort.hpp>
#include <sprout/range/algorithm/swap_element_copy.hpp>
#include <sprout/range/algorithm/swap_ranges.hpp>
#include <sprout/range/algorithm/transform.hpp>
#include <sprout/range/algorithm/unique.hpp>
#include <sprout/range/algorithm/unique_copy.hpp>
#include <sprout/range/algorithm/string/to_lower_copy.hpp>
#include <sprout/range/algorithm/string/to_upper_copy.hpp>
//#include <sprout/range/algorithm/bogo_sort.hpp>
//#include <sprout/range/algorithm/bozo_sort.hpp>
//#include <sprout/range/algorithm/clamp_range.hpp>
//#include <sprout/range/algorithm/clamp_range_copy.hpp>
//#include <sprout/range/algorithm/copy.hpp>
//#include <sprout/range/algorithm/copy_backward.hpp>
//#include <sprout/range/algorithm/copy_if.hpp>
//#include <sprout/range/algorithm/copy_until.hpp>
//#include <sprout/range/algorithm/copy_while.hpp>
//#include <sprout/range/algorithm/fill.hpp>
//#include <sprout/range/algorithm/generate.hpp>
//#include <sprout/range/algorithm/inplace_merge.hpp>
//#include <sprout/range/algorithm/make_heap.hpp>
//#include <sprout/range/algorithm/merge.hpp>
//#include <sprout/range/algorithm/move.hpp>
//#include <sprout/range/algorithm/move_backward.hpp>
//#include <sprout/range/algorithm/next_permutation.hpp>
//#include <sprout/range/algorithm/nth_element.hpp>
//#include <sprout/range/algorithm/partial_sort.hpp>
//#include <sprout/range/algorithm/partial_sort_copy.hpp>
//#include <sprout/range/algorithm/partition.hpp>
//#include <sprout/range/algorithm/partition_copy.hpp>
//#include <sprout/range/algorithm/pop_heap.hpp>
//#include <sprout/range/algorithm/prev_permutation.hpp>
//#include <sprout/range/algorithm/push_heap.hpp>
//#include <sprout/range/algorithm/random_shuffle.hpp>
//#include <sprout/range/algorithm/random_swap.hpp>
//#include <sprout/range/algorithm/remove.hpp>
//#include <sprout/range/algorithm/remove_copy.hpp>
//#include <sprout/range/algorithm/remove_copy_if.hpp>
//#include <sprout/range/algorithm/remove_if.hpp>
//#include <sprout/range/algorithm/replace.hpp>
//#include <sprout/range/algorithm/replace_copy.hpp>
//#include <sprout/range/algorithm/replace_copy_if.hpp>
//#include <sprout/range/algorithm/replace_if.hpp>
//#include <sprout/range/algorithm/reverse.hpp>
//#include <sprout/range/algorithm/reverse_copy.hpp>
//#include <sprout/range/algorithm/rotate.hpp>
//#include <sprout/range/algorithm/rotate_copy.hpp>
//#include <sprout/range/algorithm/sample.hpp>
//#include <sprout/range/algorithm/set_difference.hpp>
//#include <sprout/range/algorithm/set_intersection.hpp>
//#include <sprout/range/algorithm/set_symmetric_difference.hpp>
//#include <sprout/range/algorithm/set_union.hpp>
//#include <sprout/range/algorithm/shuffle.hpp>
//#include <sprout/range/algorithm/sort.hpp>
//#include <sprout/range/algorithm/sort_heap.hpp>
//#include <sprout/range/algorithm/stable_partition.hpp>
//#include <sprout/range/algorithm/stable_partition_copy.hpp>
//#include <sprout/range/algorithm/stable_sort.hpp>
//#include <sprout/range/algorithm/swap_element_copy.hpp>
//#include <sprout/range/algorithm/swap_ranges.hpp>
//#include <sprout/range/algorithm/transform.hpp>
//#include <sprout/range/algorithm/unique.hpp>
//#include <sprout/range/algorithm/unique_copy.hpp>
//#include <sprout/range/algorithm/string/to_lower_copy.hpp>
//#include <sprout/range/algorithm/string/to_upper_copy.hpp>
#include <sprout/range/numeric/adjacent_difference.hpp>
#include <sprout/range/numeric/dft/amplitude_spectrum.hpp>
#include <sprout/range/numeric/dft/dft.hpp>
#include <sprout/range/numeric/dft/idft.hpp>
#include <sprout/range/numeric/dft/phase_spectrum.hpp>
#include <sprout/range/numeric/dft/spectrum.hpp>
#include <sprout/range/numeric/partial_sum.hpp>
//#include <sprout/range/numeric/adjacent_difference.hpp>
//#include <sprout/range/numeric/dft/amplitude_spectrum.hpp>
//#include <sprout/range/numeric/dft/dft.hpp>
//#include <sprout/range/numeric/dft/idft.hpp>
//#include <sprout/range/numeric/dft/phase_spectrum.hpp>
//#include <sprout/range/numeric/dft/spectrum.hpp>
//#include <sprout/range/numeric/partial_sum.hpp>
#endif // #ifndef TESTSPR_HEADER_ALL_HPP