afb81b8278
Some checks failed
Docker. / Ubuntu (push) Has been cancelled
User-agent updater. / User-agent (push) Failing after 15s
Lock Threads / lock (push) Failing after 10s
Waiting for answer. / waiting-for-answer (push) Failing after 22s
Needs user action. / needs-user-action (push) Failing after 8s
Can't reproduce. / cant-reproduce (push) Failing after 8s
Close stale issues and PRs / stale (push) Has been cancelled
374 lines
11 KiB
C++
374 lines
11 KiB
C++
// Range v3 library
|
|
//
|
|
// Copyright Eric Niebler 2013-present
|
|
//
|
|
// Use, modification and distribution is subject to 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)
|
|
//
|
|
// Project home: https://github.com/ericniebler/range-v3
|
|
//
|
|
|
|
#include <range/v3/detail/config.hpp>
|
|
|
|
#if RANGES_CXX_RETURN_TYPE_DEDUCTION >= RANGES_CXX_RETURN_TYPE_DEDUCTION_14 && \
|
|
RANGES_CXX_GENERIC_LAMBDAS >= RANGES_CXX_GENERIC_LAMBDAS_14
|
|
|
|
///[calendar]
|
|
|
|
// Usage:
|
|
// calendar 2015
|
|
//
|
|
// Output:
|
|
/*
|
|
January February March
|
|
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5 6 7
|
|
4 5 6 7 8 9 10 8 9 10 11 12 13 14 8 9 10 11 12 13 14
|
|
11 12 13 14 15 16 17 15 16 17 18 19 20 21 15 16 17 18 19 20 21
|
|
18 19 20 21 22 23 24 22 23 24 25 26 27 28 22 23 24 25 26 27 28
|
|
25 26 27 28 29 30 31 29 30 31
|
|
|
|
April May June
|
|
1 2 3 4 1 2 1 2 3 4 5 6
|
|
5 6 7 8 9 10 11 3 4 5 6 7 8 9 7 8 9 10 11 12 13
|
|
12 13 14 15 16 17 18 10 11 12 13 14 15 16 14 15 16 17 18 19 20
|
|
19 20 21 22 23 24 25 17 18 19 20 21 22 23 21 22 23 24 25 26 27
|
|
26 27 28 29 30 24 25 26 27 28 29 30 28 29 30
|
|
31
|
|
July August September
|
|
1 2 3 4 1 1 2 3 4 5
|
|
5 6 7 8 9 10 11 2 3 4 5 6 7 8 6 7 8 9 10 11 12
|
|
12 13 14 15 16 17 18 9 10 11 12 13 14 15 13 14 15 16 17 18 19
|
|
19 20 21 22 23 24 25 16 17 18 19 20 21 22 20 21 22 23 24 25 26
|
|
26 27 28 29 30 31 23 24 25 26 27 28 29 27 28 29 30
|
|
30 31
|
|
October November December
|
|
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5
|
|
4 5 6 7 8 9 10 8 9 10 11 12 13 14 6 7 8 9 10 11 12
|
|
11 12 13 14 15 16 17 15 16 17 18 19 20 21 13 14 15 16 17 18 19
|
|
18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26
|
|
25 26 27 28 29 30 31 29 30 27 28 29 30 31
|
|
// */
|
|
|
|
// Credits:
|
|
// Thanks to H. S. Teoh for the article that served as the
|
|
// inspiration for this example:
|
|
// <http://wiki.dlang.org/Component_programming_with_ranges>
|
|
// Thanks to github's Arzar for bringing date::week_number
|
|
// to my attention.
|
|
|
|
#include <boost/date_time/gregorian/gregorian.hpp>
|
|
#include <boost/format.hpp>
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <boost/program_options.hpp>
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <range/v3/action/join.hpp>
|
|
#include <range/v3/algorithm/copy.hpp>
|
|
#include <range/v3/algorithm/for_each.hpp>
|
|
#include <range/v3/algorithm/mismatch.hpp>
|
|
#include <range/v3/core.hpp>
|
|
#include <range/v3/iterator/stream_iterators.hpp>
|
|
#include <range/v3/view/all.hpp>
|
|
#include <range/v3/view/chunk.hpp>
|
|
#include <range/v3/view/chunk_by.hpp>
|
|
#include <range/v3/view/concat.hpp>
|
|
#include <range/v3/view/iota.hpp>
|
|
#include <range/v3/view/join.hpp>
|
|
#include <range/v3/view/repeat_n.hpp>
|
|
#include <range/v3/view/single.hpp>
|
|
#include <range/v3/view/take.hpp>
|
|
#include <range/v3/view/transform.hpp>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace po = boost::program_options;
|
|
namespace greg = boost::gregorian;
|
|
using date = greg::date;
|
|
using day = greg::date_duration;
|
|
using namespace ranges;
|
|
|
|
namespace boost
|
|
{
|
|
namespace gregorian
|
|
{
|
|
date &operator++(date &d)
|
|
{
|
|
return d = d + day(1);
|
|
}
|
|
date operator++(date &d, int)
|
|
{
|
|
return ++d - day(1);
|
|
}
|
|
}
|
|
}
|
|
namespace ranges
|
|
{
|
|
template<>
|
|
struct incrementable_traits<date>
|
|
{
|
|
using difference_type = date::duration_type::duration_rep::int_type;
|
|
};
|
|
}
|
|
CPP_assert(incrementable<date>);
|
|
|
|
auto
|
|
dates(unsigned short start, unsigned short stop)
|
|
{
|
|
return views::iota(date{start, greg::Jan, 1}, date{stop, greg::Jan, 1});
|
|
}
|
|
|
|
auto
|
|
dates_from(unsigned short year)
|
|
{
|
|
return views::iota(date{year, greg::Jan, 1});
|
|
}
|
|
|
|
auto
|
|
by_month()
|
|
{
|
|
return views::chunk_by(
|
|
[](date a, date b) { return a.month() == b.month(); });
|
|
}
|
|
|
|
auto
|
|
by_week()
|
|
{
|
|
return views::chunk_by([](date a, date b) {
|
|
// ++a because week_number is Mon-Sun and we want Sun-Sat
|
|
return (++a).week_number() == (++b).week_number();
|
|
});
|
|
}
|
|
|
|
std::string
|
|
format_day(date d)
|
|
{
|
|
return boost::str(boost::format("%|3|") % d.day());
|
|
}
|
|
|
|
// In: range<range<date>>: month grouped by weeks.
|
|
// Out: range<std::string>: month with formatted weeks.
|
|
auto
|
|
format_weeks()
|
|
{
|
|
return views::transform([](/*range<date>*/ auto week) {
|
|
return boost::str(boost::format("%1%%2%%|22t|") %
|
|
std::string(front(week).day_of_week() * 3u, ' ') %
|
|
(week | views::transform(format_day) | actions::join));
|
|
});
|
|
}
|
|
|
|
// Return a formatted string with the title of the month
|
|
// corresponding to a date.
|
|
std::string
|
|
month_title(date d)
|
|
{
|
|
return boost::str(boost::format("%|=22|") % d.month().as_long_string());
|
|
}
|
|
|
|
// In: range<range<date>>: year of months of days
|
|
// Out: range<range<std::string>>: year of months of formatted wks
|
|
auto
|
|
layout_months()
|
|
{
|
|
return views::transform([](/*range<date>*/ auto month) {
|
|
auto week_count =
|
|
static_cast<std::ptrdiff_t>(distance(month | by_week()));
|
|
return views::concat(
|
|
views::single(month_title(front(month))),
|
|
month | by_week() | format_weeks(),
|
|
views::repeat_n(std::string(22, ' '), 6 - week_count));
|
|
});
|
|
}
|
|
|
|
// Flattens a range of ranges by iterating the inner
|
|
// ranges in round-robin fashion.
|
|
template<class Rngs>
|
|
class interleave_view : public view_facade<interleave_view<Rngs>>
|
|
{
|
|
friend range_access;
|
|
std::vector<range_value_t<Rngs>> rngs_;
|
|
struct cursor;
|
|
cursor begin_cursor()
|
|
{
|
|
return {0, &rngs_, views::transform(rngs_, ranges::begin) | to<std::vector>};
|
|
}
|
|
|
|
public:
|
|
interleave_view() = default;
|
|
explicit interleave_view(Rngs rngs)
|
|
: rngs_(std::move(rngs) | to<std::vector>)
|
|
{}
|
|
};
|
|
|
|
template<class Rngs>
|
|
struct interleave_view<Rngs>::cursor
|
|
{
|
|
std::size_t n_;
|
|
std::vector<range_value_t<Rngs>> *rngs_;
|
|
std::vector<iterator_t<range_value_t<Rngs>>> its_;
|
|
decltype(auto) read() const
|
|
{
|
|
return *its_[n_];
|
|
}
|
|
void next()
|
|
{
|
|
if(0 == ((++n_) %= its_.size()))
|
|
for_each(its_, [](auto &it) { ++it; });
|
|
}
|
|
bool equal(default_sentinel_t) const
|
|
{
|
|
if(n_ != 0)
|
|
return false;
|
|
auto ends = *rngs_ | views::transform(ranges::end);
|
|
return its_.end() != std::mismatch(
|
|
its_.begin(), its_.end(), ends.begin(), std::not_equal_to<>{}).first;
|
|
}
|
|
CPP_member
|
|
auto equal(cursor const& that) const -> CPP_ret(bool)(
|
|
requires forward_range<range_value_t<Rngs>>)
|
|
{
|
|
return n_ == that.n_ && its_ == that.its_;
|
|
}
|
|
};
|
|
|
|
// In: range<range<T>>
|
|
// Out: range<T>, flattened by walking the ranges
|
|
// round-robin fashion.
|
|
auto
|
|
interleave()
|
|
{
|
|
return make_view_closure([](auto &&rngs) {
|
|
using Rngs = decltype(rngs);
|
|
return interleave_view<views::all_t<Rngs>>(
|
|
views::all(std::forward<Rngs>(rngs)));
|
|
});
|
|
}
|
|
|
|
// In: range<range<T>>
|
|
// Out: range<range<T>>, transposing the rows and columns.
|
|
auto
|
|
transpose()
|
|
{
|
|
return make_view_closure([](auto &&rngs) {
|
|
using Rngs = decltype(rngs);
|
|
CPP_assert(forward_range<Rngs>);
|
|
return std::forward<Rngs>(rngs)
|
|
| interleave()
|
|
| views::chunk(static_cast<std::size_t>(distance(rngs)));
|
|
});
|
|
}
|
|
|
|
// In: range<range<range<string>>>
|
|
// Out: range<range<range<string>>>, transposing months.
|
|
auto
|
|
transpose_months()
|
|
{
|
|
return views::transform(
|
|
[](/*range<range<string>>*/ auto rng) { return rng | transpose(); });
|
|
}
|
|
|
|
// In: range<range<string>>
|
|
// Out: range<string>, joining the strings of the inner ranges
|
|
auto
|
|
join_months()
|
|
{
|
|
return views::transform(
|
|
[](/*range<string>*/ auto rng) { return actions::join(rng); });
|
|
}
|
|
|
|
// In: range<date>
|
|
// Out: range<string>, lines of formatted output
|
|
auto
|
|
format_calendar(std::size_t months_per_line)
|
|
{
|
|
return
|
|
// Group the dates by month:
|
|
by_month()
|
|
// Format the month into a range of strings:
|
|
| layout_months()
|
|
// Group the months that belong side-by-side:
|
|
| views::chunk(months_per_line)
|
|
// Transpose the rows and columns of the size-by-side months:
|
|
| transpose_months()
|
|
// Ungroup the side-by-side months:
|
|
| views::join
|
|
// Join the strings of the transposed months:
|
|
| join_months();
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[]) try
|
|
{
|
|
// Declare the supported options.
|
|
po::options_description desc("Allowed options");
|
|
desc.add_options()("help", "produce help message")(
|
|
"start", po::value<unsigned short>(), "Year to start")(
|
|
"stop", po::value<std::string>(), "Year to stop")(
|
|
"per-line",
|
|
po::value<std::size_t>()->default_value(3u),
|
|
"Nbr of months per line");
|
|
|
|
po::positional_options_description p;
|
|
p.add("start", 1).add("stop", 1);
|
|
|
|
po::variables_map vm;
|
|
po::store(
|
|
po::command_line_parser(argc, argv).options(desc).positional(p).run(),
|
|
vm);
|
|
po::notify(vm);
|
|
|
|
if(vm.count("help") || 1 != vm.count("start"))
|
|
{
|
|
std::cerr << desc << '\n';
|
|
return 1;
|
|
}
|
|
|
|
auto const start = vm["start"].as<unsigned short>();
|
|
auto const stop = 0 == vm.count("stop")
|
|
? (unsigned short)(start + 1)
|
|
: vm["stop"].as<std::string>() == "never"
|
|
? (unsigned short)-1
|
|
: boost::lexical_cast<unsigned short>(
|
|
vm["stop"].as<std::string>());
|
|
auto const months_per_line = vm["per-line"].as<std::size_t>();
|
|
|
|
if(stop != (unsigned short)-1 && stop <= start)
|
|
{
|
|
std::cerr << "ERROR: The stop year must be larger than the start"
|
|
<< '\n';
|
|
return 1;
|
|
}
|
|
|
|
if((unsigned short)-1 != stop)
|
|
{
|
|
copy(dates(start, stop) | format_calendar(months_per_line),
|
|
ostream_iterator<>(std::cout, "\n"));
|
|
}
|
|
else
|
|
{
|
|
copy(dates_from(start) | format_calendar(months_per_line),
|
|
ostream_iterator<>(std::cout, "\n"));
|
|
}
|
|
}
|
|
catch(std::exception &e)
|
|
{
|
|
std::cerr << "ERROR: Unhandled exception\n";
|
|
std::cerr << " what(): " << e.what();
|
|
return 1;
|
|
}
|
|
///[calendar]
|
|
|
|
#else
|
|
#pragma message( \
|
|
"calendar requires C++14 return type deduction and generic lambdas")
|
|
int
|
|
main()
|
|
{}
|
|
#endif
|