fix iota

example/fizzbuzz/main.cpp

@@ -16,7 +16,6 @@
 #include <sprout/array.hpp>
 #include <sprout/string.hpp>
 #include <sprout/numeric/iota.hpp>
-#include <sprout/pit.hpp>
 #include <iostream>
 
 
@@ -24,7 +23,7 @@ struct fizzbuzz{
 	typedef sprout::string<12> result_type;
 
 	constexpr result_type
-	operator ()(int n) const{
+	operator()(int n) const {
 		return n % 15 == 0 ? sprout::to_string("FizzBuzz")
 			 : n %  3 == 0 ? sprout::to_string("Fizz")
 			 : n %  5 == 0 ? sprout::to_string("Buzz")
@@ -40,29 +39,25 @@ main(){
 	//
 	// Test
 	//
-	static_assert(fizzbuzz()( 1) == "1", "");
+	static_assert(fizzbuzz()( 1) == "1",        "");
-	static_assert(fizzbuzz()( 2) == "2", "");
+	static_assert(fizzbuzz()( 2) == "2",        "");
-	static_assert(fizzbuzz()( 3) == "Fizz", "");
+	static_assert(fizzbuzz()( 3) == "Fizz",     "");
-	static_assert(fizzbuzz()( 5) == "Buzz", "");
+	static_assert(fizzbuzz()( 5) == "Buzz",     "");
 	static_assert(fizzbuzz()(15) == "FizzBuzz", "");
 	
 	//
 	// Sequence [1..15]
 	//
-	constexpr auto source = sprout::iota(
+	constexpr auto source = sprout::iota<sprout::array<int, 15> >(1);
-		sprout::pit<sprout::array<int, 15> >(),
-		1
-	);
 
 	//
 	// Transform to FizzBuzz
 	//
-	constexpr auto result = sprout::transform(
+	constexpr auto result = sprout::transform<sprout::array<string, 15> >(
 		sprout::begin(source),
 		sprout::end(source),
-		sprout::pit<sprout::array<string, 15> >(),
 		fizzbuzz()
-	);
+		);
 	
 	//
 	// Check result
@@ -83,14 +78,14 @@ main(){
 		sprout::to_string("13"),
 		sprout::to_string("14"),
 		sprout::to_string("FizzBuzz")
-	);
+		);
 	// Equal result sequence
 	static_assert(result == fizzbuzz_result, "");
 
 	//
 	// Output
 	//
-	for(auto&& str : result){
+	for (auto&& str : result){
 		std::cout << str << ", ";
 	}
 	std::cout << std::endl;

sprout/numeric/fixed/iota.hpp

@@ -34,7 +34,7 @@ namespace sprout {
 					cont,
 					sprout::size(cont),
 					(Indexes >= offset && Indexes < offset + size
-						? value + (Indexes - offset)
+						? static_cast<typename sprout::container_traits<Container>::value_type>(value + (Indexes - offset))
 						: *sprout::next(sprout::internal_begin(cont), Indexes)
 						)...
 					);

sprout/preprocessor/unique_string.hpp

@@ -20,19 +20,19 @@
 // SPROUT_PP_UNIQUE_U32STRING
 //
 #define SPROUT_PP_UNIQUE_STRING \
-	SPROUT_PP_STRINGIZE(SPROUT_PP_SOME_NUMBER_OR_EMPTY()) " " \
+	SPROUT_PP_STRINGIZE(SPROUT_PP_SOME_NUMBER()) " " \
 	__DATE__ " " __TIME__ \
 	" : " __FILE__ ":" SPROUT_PP_STRINGIZE(__LINE__)
 #define SPROUT_PP_UNIQUE_WSTRING \
-	SPROUT_PP_WSTRINGIZE(SPROUT_PP_SOME_NUMBER_OR_EMPTY()) SPROUT_PP_WSTR(" ") \
+	SPROUT_PP_WSTRINGIZE(SPROUT_PP_SOME_NUMBER()) SPROUT_PP_WSTR(" ") \
 	SPROUT_PP_WSTR(__DATE__) SPROUT_PP_WSTR(" ") SPROUT_PP_WSTR(__TIME__) \
 	SPROUT_PP_WSTR(" : ") SPROUT_PP_WSTR(__FILE__) SPROUT_PP_WSTR(":") SPROUT_PP_WSTRINGIZE(__LINE__)
 #define SPROUT_PP_UNIQUE_U16STRING \
-	SPROUT_PP_U16STRINGIZE(SPROUT_PP_SOME_NUMBER_OR_EMPTY()) SPROUT_PP_U16STR(" ") \
+	SPROUT_PP_U16STRINGIZE(SPROUT_PP_SOME_NUMBER()) SPROUT_PP_U16STR(" ") \
 	SPROUT_PP_U16STR(__DATE__) SPROUT_PP_U16STR(" ") SPROUT_PP_U16STR(__TIME__) \
 	SPROUT_PP_U16STR(" : ") SPROUT_PP_U16STR(__FILE__) SPROUT_PP_U16STR(":") SPROUT_PP_U16STRINGIZE(__LINE__)
 #define SPROUT_PP_UNIQUE_U32STRING \
-	SPROUT_PP_U32STRINGIZE(SPROUT_PP_SOME_NUMBER_OR_EMPTY()) SPROUT_PP_U32STR(" ") \
+	SPROUT_PP_U32STRINGIZE(SPROUT_PP_SOME_NUMBER()) SPROUT_PP_U32STR(" ") \
 	SPROUT_PP_U32STR(__DATE__) SPROUT_PP_U32STR(" ") SPROUT_PP_U32STR(__TIME__) \
 	SPROUT_PP_U32STR(" : ") SPROUT_PP_U32STR(__FILE__) SPROUT_PP_U32STR(":") SPROUT_PP_U32STRINGIZE(__LINE__)
 

testspr/print.hpp

@@ -11,22 +11,22 @@
 #include <algorithm>
 #include <iterator>
 #include <bitset>
+#include <utility>
 #include <iostream>
+#include <iomanip>
 #include <sprout/container.hpp>
+#include <sprout/detail/io/ios_state.hpp>
 #include <testspr/typeinfo.hpp>
 
 namespace testspr {
 	//
 	// print
 	//
-	template<typename InputIterator>
+	void print() {}
-	void print(InputIterator first, InputIterator last) {
+	template<typename Head, typename... Tail>
-		std::for_each(first, last, [](typename std::iterator_traits<InputIterator>::value_type const& e){ std::cout << e << ' '; });
+	void print(Head const& head, Tail const&... tail) {
-		std::cout << std::endl;
+		std::cout << head;
-	}
+		testspr::print(tail...);
-	template<typename InputRange>
-	void print(InputRange const& range) {
-		testspr::print(sprout::begin(range), sprout::end(range));
 	}
 
 	//
@@ -35,14 +35,53 @@ namespace testspr {
 	void print_ln() {
 		std::cout << std::endl;
 	}
-	template<typename T>
+	template<typename... Args>
-	void print_ln(T const& t) {
+	void print_ln(Args const&... args) {
-		std::cout << t << std::endl;
+		sprout::detail::io::ios_all_saver saver(std::cout);
+		testspr::print(args...);
+		std::cout << std::endl;
+	}
+
+	//
+	// print_tokens
+	//
+	void print_tokens() {
+		testspr::print_ln();
 	}
 	template<typename Head, typename... Tail>
-	void print_ln(Head const& head, Tail const&... tail) {
+	void print_tokens(Head const& head, Tail const&... tail) {
-		std::cout << head;
+		sprout::detail::io::ios_all_saver saver(std::cout);
-		testspr::print_ln(tail...);
+		testspr::print(head, ' ');
+		testspr::print_tokens(tail...);
+	}
+
+	//
+	// print_quotes
+	//
+	void print_quotes() {
+		testspr::print_ln();
+	}
+	template<typename Head, typename... Tail>
+	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...);
+	}
+
+	//
+	// print_range
+	//
+	template<typename InputIterator>
+	void print_range(InputIterator first, InputIterator last) {
+		sprout::detail::io::ios_all_saver saver(std::cout);
+		for (; first != last; ++first) {
+			std::cout << *first << ' ';
+		}
+		std::cout << std::endl;
+	}
+	template<typename InputRange>
+	void print_range(InputRange const& range) {
+		testspr::print_range(sprout::begin(range), sprout::end(range));
 	}
 
 	//
@@ -75,6 +114,54 @@ namespace testspr {
 	void print_hl() {
 		testspr::print_ln("--------------------------------------------------------------------------------");
 	}
+
+	//
+	// manip_holder
+	//
+	template<typename T>
+	class manip_holder {
+	public:
+		typedef T value_type;
+	private:
+		value_type m_;
+	public:
+		manip_holder(value_type const& m)
+			: m_(m)
+		{}
+		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) {
+		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) {
+		return lhs >> rhs.get();
+	}
+	//
+	// manip
+	//
+	template<typename T>
+	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>&)>
+	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>&)>
+	manip(std::basic_ios<Elem, Traits>& (*pf)(std::basic_ios<Elem, Traits>&)) {
+		return pf;
+	}
+	testspr::manip_holder<std::ios_base& (*)(std::ios_base&)>
+	manip(std::ios_base& (*pf)(std::ios_base&)) {
+		return pf;
+	}
 }	// namespace testspr
 
 #endif	// #ifndef TESTSPR_PRINT_HPP