add shrink_to_fit, unmove

sprout/assert.hpp

@@ -117,7 +117,7 @@ namespace sprout {
 
 namespace sprout {
 	namespace detail {
-		inline bool
+		inline SPROUT_NON_CONSTEXPR bool
 		assertion_failed_msg(char const* formatted, char const* msg) {
 			return (std::cerr << formatted << ": " << msg << std::endl), std::abort(), false;
 		}
@@ -184,7 +184,7 @@ namespace sprout {
 
 namespace sprout {
 	namespace detail {
-		inline bool
+		inline SPROUT_NON_CONSTEXPR bool
 		assertion_failed(bool cond, char const* formatted, char const* expr, char const* function, char const* file, long line) {
 			return cond ? true
 				: ((void)sprout::assertion_failed(sprout::assertion_info(expr, function, file, line)), false)
@@ -210,7 +210,7 @@ namespace sprout {
 
 namespace sprout {
 	namespace detail {
-		inline bool
+		inline SPROUT_NON_CONSTEXPR bool
 		assertion_failed(char const* formatted) {
 			return (std::cerr << formatted << std::endl), std::abort(), false;
 		}

sprout/complex/complex.hpp

@@ -8,6 +8,7 @@
 #ifndef SPROUT_COMPLEX_COMPLEX_HPP
 #define SPROUT_COMPLEX_COMPLEX_HPP
 
+#include <complex>
 #include <sprout/config.hpp>
 #include <sprout/array/array.hpp>
 
@@ -50,8 +51,12 @@ namespace sprout {
 			: elems_{{re, im}}
 		{}
 		SPROUT_CXX14_CONSTEXPR complex(complex const&) = default;
-		template<typename X>
-		SPROUT_CONSTEXPR complex(complex<X> const& other) SPROUT_NOEXCEPT
+		template<typename U>
+		SPROUT_CONSTEXPR complex(complex<U> const& other) SPROUT_NOEXCEPT
+			: elems_{{other.real(), other.imag()}}
+		{}
+		template<typename U>
+		SPROUT_CONSTEXPR complex(std::complex<U> const& other) SPROUT_NOEXCEPT
 			: elems_{{other.real(), other.imag()}}
 		{}
 		SPROUT_CONSTEXPR T const& real() const SPROUT_NOEXCEPT {
@@ -218,6 +223,11 @@ namespace sprout {
 		SPROUT_CONSTEXPR const_pointer c_array() const SPROUT_NOEXCEPT {
 			return elems_.c_array();
 		}
+
+		template<typename U>
+		SPROUT_EXPLICIT_CONVERSION SPROUT_CONSTEXPR operator std::complex<U>() const SPROUT_NOEXCEPT {
+			return std::complex<U>(real(), imag());
+		}
 	};
 	template<typename T>
 	SPROUT_CONSTEXPR_OR_CONST typename sprout::complex<T>::size_type sprout::complex<T>::static_size;

sprout/container/container_range_traits.hpp

@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <sprout/workaround/std/cstddef.hpp>
 #include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
 #include <sprout/type_traits/identity.hpp>
 #include <sprout/container/traits_fwd.hpp>
 #include <sprout/container/container_traits.hpp>

sprout/container/functions.hpp

@@ -14,5 +14,6 @@
 #include <sprout/container/construct_functions.hpp>
 #include <sprout/container/fitness_functions.hpp>
 #include <sprout/container/sub_functions.hpp>
+#include <sprout/container/shrink_to_fit.hpp>
 
 #endif	// #ifndef SPROUT_CONTAINER_FUNCTIONS_HPP

sprout/container/shrink_to_fit.hpp

@@ -0,0 +1,89 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_CONTAINER_SHRINK_TO_FIT_HPP
+#define SPROUT_CONTAINER_SHRINK_TO_FIT_HPP
+
+#include <utility>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/identity.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/adl/not_found.hpp>
+
+namespace sprout_adl {
+	sprout::not_found_via_adl container_shrink_to_fit(...);
+}	// namespace sprout_adl
+
+namespace sprout {
+	namespace detail {
+		template<typename T>
+		struct has_mem_shrink_to_fit_test {
+		public:
+			template<
+				typename U = T,
+				typename = typename sprout::identity<decltype(std::declval<U>().shrink_to_fit())>::type
+			>
+			static sprout::true_type test(int);
+			static sprout::false_type test(...);
+		};
+#if defined(_MSC_VER)
+		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_
+		{};
+#else
+		template<typename T>
+		struct has_mem_shrink_to_fit
+			: public sprout::identity<decltype(sprout::detail::has_mem_shrink_to_fit_test<T>::test(0))>::type
+		{};
+#endif
+
+		template<typename Container>
+		inline SPROUT_CXX14_CONSTEXPR typename std::enable_if<
+			sprout::detail::has_mem_shrink_to_fit<Container&&>::value
+		>::type
+		container_shrink_to_fit_default(Container&& cont) {
+			return SPROUT_FORWARD(Container, cont).shrink_to_fit();
+		}
+		template<typename Container>
+		inline SPROUT_CXX14_CONSTEXPR typename std::enable_if<
+			!sprout::detail::has_mem_shrink_to_fit<Container&&>::value
+		>::type
+		container_shrink_to_fit_default(Container&&) {}
+	}	// namespace detail
+
+	namespace container_detail {
+		template<typename Container>
+		inline SPROUT_CXX14_CONSTEXPR void
+		container_shrink_to_fit(Container&& cont) {
+			return sprout::detail::container_shrink_to_fit_default(SPROUT_FORWARD(Container, cont));
+		}
+	}	// namespace container_detail
+
+	//
+	// shrink_to_fit
+	//
+	//	effect:
+	//		ADL callable container_shrink_to_fit(cont) -> container_shrink_to_fit(cont)
+	//		[default]
+	//			callable cont.shrink_to_fit() -> cont.shrink_to_fit()
+	//			otherwise -> no effects
+	//
+	template<typename Container>
+	inline SPROUT_CXX14_CONSTEXPR void
+	shrink_to_fit(Container&& cont) {
+		using sprout::container_detail::container_shrink_to_fit;
+		using sprout_adl::container_shrink_to_fit;
+		return container_shrink_to_fit(SPROUT_FORWARD(Container, cont));
+	}
+}	// namespace sprout
+
+#include <sprout/container/container_range_traits.hpp>
+
+#endif	// #ifndef SPROUT_CONTAINER_SHRINK_TO_FIT_HPP

sprout/optional/io.hpp

@@ -19,7 +19,7 @@ namespace sprout {
 	// operator>>
 	//
 	template<typename Elem, typename Traits, typename T>
-	inline std::basic_istream<Elem, Traits>&
+	inline SPROUT_NON_CONSTEXPR std::basic_istream<Elem, Traits>&
 	operator>>(std::basic_istream<Elem, Traits>& lhs, sprout::optional<T>& rhs) {
 		if (lhs.good()) {
 			int d = lhs.get();
@@ -44,7 +44,7 @@ namespace sprout {
 	// operator<<
 	//
 	template<typename Elem, typename Traits, typename T>
-	inline std::basic_ostream<Elem, Traits>&
+	inline SPROUT_NON_CONSTEXPR std::basic_ostream<Elem, Traits>&
 	operator<<(std::basic_ostream<Elem, Traits>& lhs, sprout::optional<T> const& rhs) {
 		if (lhs.good()) {
 			if (!rhs) {

sprout/utility/operation.hpp

@@ -14,5 +14,6 @@
 #include <sprout/utility/move.hpp>
 #include <sprout/utility/swap.hpp>
 #include <sprout/utility/exchange.hpp>
+#include <sprout/utility/unmove.hpp>
 
 #endif	// #ifndef SPROUT_UTILITY_OPERATION_HPP

sprout/utility/unmove.hpp

@@ -0,0 +1,22 @@
+/*=============================================================================
+  Copyright (c) 2011-2014 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_UTILITY_UNMOVE_HPP
+#define SPROUT_UTILITY_UNMOVE_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+
+namespace sprout {
+	template<typename T>
+	inline SPROUT_CONSTEXPR typename std::remove_reference<T>::type&
+	unmove(T&& x) SPROUT_NOEXCEPT {
+		return static_cast<typename std::remove_reference<T>::type&>(x);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_UTILITY_UNMOVE_HPP

testspr/assert.hpp

@@ -23,10 +23,10 @@ namespace testspr {
 		: public std::runtime_error
 	{
 	public:
-		explicit assertion_failed(std::string const& msg)
+		explicit SPROUT_NON_CONSTEXPR assertion_failed(std::string const& msg)
 			: std::runtime_error(msg)
 		{}
-		explicit assertion_failed(char const* msg)
+		explicit SPROUT_NON_CONSTEXPR assertion_failed(char const* msg)
 			: std::runtime_error(msg)
 		{}
 	};

testspr/iterator.hpp

@@ -54,7 +54,7 @@ namespace testspr {
 			: current(it.base())
 		{}
 		template<typename U, typename V, typename sprout::enabler_if<sprout::is_convert_constructible<Iterator, U>::value>::type = sprout::enabler>
-		reduct_iterator& operator=(reduct_iterator<U, V> const& it) {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator& operator=(reduct_iterator<U, V> const& it) {
 			reduct_iterator temp(it);
 			temp.swap(*this);
 			return *this;
@@ -68,20 +68,20 @@ namespace testspr {
 		SPROUT_CONSTEXPR pointer operator->() const {
 			return &*current;
 		}
-		reduct_iterator& operator++() {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator& operator++() {
 			++current;
 			return *this;
 		}
-		reduct_iterator operator++(int) {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator operator++(int) {
 			reduct_iterator result(*this);
 			++current;
 			return result;
 		}
-		reduct_iterator& operator--() {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator& operator--() {
 			--current;
 			return *this;
 		}
-		reduct_iterator operator--(int) {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator operator--(int) {
 			reduct_iterator temp(*this);
 			--current;
 			return temp;
@@ -92,12 +92,12 @@ namespace testspr {
 		SPROUT_CONSTEXPR reduct_iterator operator-(difference_type n) const {
 			return reduct_iterator(current - n);
 		}
-		reduct_iterator& operator+=(difference_type n) {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator& operator+=(difference_type n) {
 			reduct_iterator temp(current + n);
 			temp.swap(*this);
 			return *this;
 		}
-		reduct_iterator& operator-=(difference_type n) {
+		SPROUT_CXX14_CONSTEXPR reduct_iterator& operator-=(difference_type n) {
 			reduct_iterator temp(current - n);
 			temp.swap(*this);
 			return *this;
@@ -111,7 +111,7 @@ namespace testspr {
 		SPROUT_CONSTEXPR reduct_iterator prev() const {
 			return reduct_iterator(sprout::prev(current));
 		}
-		void swap(reduct_iterator& other)
+		SPROUT_CXX14_CONSTEXPR void swap(reduct_iterator& other)
 		SPROUT_NOEXCEPT_EXPR(
 			SPROUT_NOEXCEPT_EXPR(swap(current, other.current))
 			)
@@ -211,7 +211,7 @@ namespace testspr {
 	// swap
 	//
 	template<typename Category, typename Iterator>
-	inline void
+	inline SPROUT_CXX14_CONSTEXPR void
 	swap(testspr::reduct_iterator<Iterator, Category>& lhs, testspr::reduct_iterator<Iterator, Category>& rhs)
 	SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
 	{

testspr/print.hpp

@@ -14,6 +14,7 @@
 #include <utility>
 #include <iostream>
 #include <iomanip>
+#include <sprout/config.hpp>
 #include <sprout/container.hpp>
 #include <sprout/detail/io/ios_state.hpp>
 #include <testspr/typeinfo.hpp>
@@ -22,9 +23,11 @@ namespace testspr {
 	//
 	// print
 	//
-	void print() {}
+	inline SPROUT_NON_CONSTEXPR void
+	print() {}
 	template<typename Head, typename... Tail>
-	void print(Head const& head, Tail const&... tail) {
+	inline SPROUT_NON_CONSTEXPR void
+	print(Head const& head, Tail const&... tail) {
 		std::cout << head;
 		testspr::print(tail...);
 	}
@@ -32,11 +35,13 @@ namespace testspr {
 	//
 	// print_ln
 	//
-	void print_ln() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_ln() {
 		std::cout << std::endl;
 	}
 	template<typename... Args>
-	void print_ln(Args const&... args) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_ln(Args const&... args) {
 		sprout::detail::io::ios_all_saver saver(std::cout);
 		testspr::print(args...);
 		std::cout << std::endl;
@@ -45,11 +50,13 @@ namespace testspr {
 	//
 	// print_tokens
 	//
-	void print_tokens() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_tokens() {
 		testspr::print_ln();
 	}
 	template<typename Head, typename... Tail>
-	void print_tokens(Head const& head, Tail const&... tail) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_tokens(Head const& head, Tail const&... tail) {
 		sprout::detail::io::ios_all_saver saver(std::cout);
 		testspr::print(head, ' ');
 		testspr::print_tokens(tail...);
@@ -58,11 +65,13 @@ namespace testspr {
 	//
 	// print_quotes
 	//
-	void print_quotes() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_quotes() {
 		testspr::print_ln();
 	}
 	template<typename Head, typename... Tail>
-	void print_quotes(Head const& head, Tail const&... tail) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_quotes(Head const& head, Tail const&... tail) {
 		sprout::detail::io::ios_all_saver saver(std::cout);
 		testspr::print('\"', head, "\" ");
 		testspr::print_quotes(tail...);
@@ -72,7 +81,8 @@ namespace testspr {
 	// print_range
 	//
 	template<typename InputIterator>
-	void print_range(InputIterator first, InputIterator last) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_range(InputIterator first, InputIterator last) {
 		sprout::detail::io::ios_all_saver saver(std::cout);
 		for (; first != last; ++first) {
 			std::cout << *first << ' ';
@@ -80,7 +90,8 @@ namespace testspr {
 		std::cout << std::endl;
 	}
 	template<typename InputRange>
-	void print_range(InputRange const& range) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_range(InputRange const& range) {
 		testspr::print_range(sprout::begin(range), sprout::end(range));
 	}
 
@@ -88,7 +99,8 @@ namespace testspr {
 	// print_bits
 	//
 	template<typename T>
-	void print_bits(T const& t) {
+	inline SPROUT_NON_CONSTEXPR void
+	print_bits(T const& t) {
 		testspr::print_ln(std::bitset<sizeof(T) * 8>(t).template to_string<char>());
 	}
 
@@ -96,7 +108,8 @@ namespace testspr {
 	// print_typename
 	//
 	template<typename T>
-	void print_typename() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_typename() {
 		testspr::print_ln(testspr::typename_of<T>());
 	}
 
@@ -104,14 +117,16 @@ namespace testspr {
 	// print_type
 	//
 	template<typename T>
-	void print_type() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_type() {
 		testspr::print_typename<testspr::id<T> >();
 	}
 
 	//
 	// print_hl
 	//
-	void print_hl() {
+	inline SPROUT_NON_CONSTEXPR void
+	print_hl() {
 		testspr::print_ln("--------------------------------------------------------------------------------");
 	}
 
@@ -125,40 +140,42 @@ namespace testspr {
 	private:
 		value_type m_;
 	public:
-		manip_holder(value_type const& m)
+		SPROUT_CONSTEXPR manip_holder(value_type const& m)
 			: m_(m)
 		{}
-		value_type const& get() const {
+		SPROUT_CONSTEXPR value_type const& get() const {
 			return m_;
 		}
 	};
 	template<typename T, typename Elem, typename Traits>
-	std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& lhs, testspr::manip_holder<T> const& rhs) {
+	inline SPROUT_NON_CONSTEXPR std::basic_ostream<Elem, Traits>&
+	operator<<(std::basic_ostream<Elem, Traits>& lhs, testspr::manip_holder<T> const& rhs) {
 		return lhs << rhs.get();
 	}
 	template<typename T, typename Elem, typename Traits>
-	std::basic_istream<Elem, Traits>& operator>>(std::basic_istream<Elem, Traits>& lhs, testspr::manip_holder<T> const& rhs) {
+	inline SPROUT_NON_CONSTEXPR std::basic_istream<Elem, Traits>&
+	operator>>(std::basic_istream<Elem, Traits>& lhs, testspr::manip_holder<T> const& rhs) {
 		return lhs >> rhs.get();
 	}
 	//
 	// manip
 	//
 	template<typename T>
-	T&&
+	inline SPROUT_NON_CONSTEXPR T&&
 	manip(T&& t) {
 		return std::forward<T>(t);
 	}
 	template<typename Elem, typename Traits>
-	testspr::manip_holder<std::basic_ostream<Elem, Traits>& (*)(std::basic_ostream<Elem, Traits>&)>
+	inline SPROUT_NON_CONSTEXPR testspr::manip_holder<std::basic_ostream<Elem, Traits>& (*)(std::basic_ostream<Elem, Traits>&)>
 	manip(std::basic_ostream<Elem, Traits>& (*pf)(std::basic_ostream<Elem, Traits>&)) {
 		return pf;
 	}
 	template<typename Elem, typename Traits>
-	testspr::manip_holder<std::basic_ios<Elem, Traits>& (*)(std::basic_ios<Elem, Traits>&)>
+	inline SPROUT_NON_CONSTEXPR testspr::manip_holder<std::basic_ios<Elem, Traits>& (*)(std::basic_ios<Elem, Traits>&)>
 	manip(std::basic_ios<Elem, Traits>& (*pf)(std::basic_ios<Elem, Traits>&)) {
 		return pf;
 	}
-	testspr::manip_holder<std::ios_base& (*)(std::ios_base&)>
+	inline SPROUT_NON_CONSTEXPR testspr::manip_holder<std::ios_base& (*)(std::ios_base&)>
 	manip(std::ios_base& (*pf)(std::ios_base&)) {
 		return pf;
 	}

testspr/typeinfo.hpp

@@ -26,6 +26,7 @@
 #	include <cstdlib>
 #	include <cxxabi.h>
 #endif
+#include <sprout/config.hpp>
 
 namespace testspr {
 	//
@@ -42,7 +43,8 @@ namespace testspr {
 	//
 #ifdef TESTSPR_HAS_CXXABI_H
 	namespace detail {
-		std::string cxa_demangle(char const* mangled) {
+		inline SPROUT_NON_CONSTEXPR std::string
+		cxa_demangle(char const* mangled) {
 			int status;
 			char* demangled = abi::__cxa_demangle(mangled, 0, 0, &status);
 			std::string result(demangled);
@@ -51,20 +53,24 @@ namespace testspr {
 		}
 	}	// namespace detail
 	template<typename T>
-	inline std::string typename_of() {
+	inline SPROUT_NON_CONSTEXPR std::string
+	typename_of() {
 		return testspr::detail::cxa_demangle(typeid(T).name());
 	}
 	template<typename T>
-	inline std::string typename_of(T&& t) {
+	inline SPROUT_NON_CONSTEXPR std::string
+	typename_of(T&& t) {
 		return testspr::detail::cxa_demangle(typeid(std::forward<T>(t)).name());
 	}
 #else
 	template<typename T>
-	inline std::string typename_of() {
+	inline SPROUT_NON_CONSTEXPR std::string
+	typename_of() {
 		return std::string(typeid(T).name());
 	}
 	template<typename T>
-	inline std::string typename_of(T&& t) {
+	inline SPROUT_NON_CONSTEXPR std::string
+	typename_of(T&& t) {
 		return std::string(typeid(std::forward<T>(t)).name());
 	}
 #endif