King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2024-11-12 21:09:01 +00:00
Code Issues Releases Wiki Activity

fix iota

Browse source
This commit is contained in:
bolero-MURAKAMI 2014-02-20 08:04:36 +09:00
parent 51716cb4af
commit 2905965f24
4 changed files with 116 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
example/fizzbuzz/main.cpp
View file

@ -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()( 2) == "2", "");
static_assert(fizzbuzz()( 3) == "Fizz", "");
static_assert(fizzbuzz()( 5) == "Buzz", "");
static_assert(fizzbuzz()( 1) == "1", "");
static_assert(fizzbuzz()( 2) == "2", "");
static_assert(fizzbuzz()( 3) == "Fizz", "");
static_assert(fizzbuzz()( 5) == "Buzz", "");
static_assert(fizzbuzz()(15) == "FizzBuzz", "");
//
// Sequence [1..15]
//
constexpr auto source = sprout::iota(
sprout::pit<sprout::array<int, 15> >(),
1
);
constexpr auto source = sprout::iota<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;

2
sprout/numeric/fixed/iota.hpp
View file

@ -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)
)...
);

8
sprout/preprocessor/unique_string.hpp
View file

@ -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__)

115
testspr/print.hpp
View file

@ -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(InputIterator first, InputIterator last) {
std::for_each(first, last, [](typename std::iterator_traits<InputIterator>::value_type const& e){ std::cout << e << ' '; });
std::cout << std::endl;
}
template<typename InputRange>
void print(InputRange const& range) {
testspr::print(sprout::begin(range), sprout::end(range));
void print() {}
template<typename Head, typename... Tail>
void print(Head const& head, Tail const&... tail) {
std::cout << head;
testspr::print(tail...);
}
//
@ -35,14 +35,53 @@ namespace testspr {
void print_ln() {
std::cout << std::endl;
}
template<typename T>
void print_ln(T const& t) {
std::cout << t << std::endl;
template<typename... Args>
void print_ln(Args const&... args) {
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) {
std::cout << head;
testspr::print_ln(tail...);
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...);
}
//
// 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