mirror of
https://github.com/bolero-MURAKAMI/Sprout.git
synced 2024-12-23 21:25:49 +00:00
add adaptors::counting
This commit is contained in:
bolero-MURAKAMI
parent
e078a9c749
commit
ea22a6ba5c
9 changed files with 771 additions and 353 deletions
243
sprout/iterator/counting_iterator.hpp
Normal file
243
sprout/iterator/counting_iterator.hpp
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
#ifndef SPROUT_ITERATOR_COUNTING_ITERATOR_HPP
|
||||
#define SPROUT_ITERATOR_COUNTING_ITERATOR_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/iterator/next.hpp>
|
||||
#include <sprout/iterator/prev.hpp>
|
||||
#include <sprout/iterator/distance.hpp>
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// counting_iterator
|
||||
//
|
||||
template<typename Incrementable>
|
||||
class counting_iterator
|
||||
: public std::iterator<
|
||||
std::random_access_iterator_tag,
|
||||
Incrementable,
|
||||
std::ptrdiff_t,
|
||||
Incrementable*,
|
||||
Incrementable
|
||||
>
|
||||
{
|
||||
public:
|
||||
typedef std::random_access_iterator_tag iterator_category;
|
||||
typedef Incrementable value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef value_type* pointer;
|
||||
typedef value_type reference;
|
||||
private:
|
||||
value_type current_;
|
||||
private:
|
||||
public:
|
||||
counting_iterator() = default;
|
||||
counting_iterator(counting_iterator const&) = default;
|
||||
explicit SPROUT_CONSTEXPR counting_iterator(value_type const& v)
|
||||
: current_(v)
|
||||
{}
|
||||
template<typename U>
|
||||
SPROUT_CONSTEXPR counting_iterator(counting_iterator<U> const& it)
|
||||
: current_(it.current_)
|
||||
{}
|
||||
template<typename U>
|
||||
counting_iterator& operator=(counting_iterator<U> const& it) {
|
||||
counting_iterator temp(it);
|
||||
temp.swap(*this);
|
||||
return *this;
|
||||
}
|
||||
SPROUT_CONSTEXPR reference operator*() const {
|
||||
return current_;
|
||||
}
|
||||
SPROUT_CONSTEXPR pointer operator->() const {
|
||||
return ¤t_;
|
||||
}
|
||||
counting_iterator& operator++() {
|
||||
++current_;
|
||||
return *this;
|
||||
}
|
||||
counting_iterator operator++(int) {
|
||||
counting_iterator result(*this);
|
||||
++current_;
|
||||
return result;
|
||||
}
|
||||
counting_iterator& operator--() {
|
||||
--current_;
|
||||
return *this;
|
||||
}
|
||||
counting_iterator operator--(int) {
|
||||
counting_iterator temp(*this);
|
||||
--current_;
|
||||
return temp;
|
||||
}
|
||||
SPROUT_CONSTEXPR counting_iterator operator+(difference_type n) const {
|
||||
return counting_iterator(current_ + n);
|
||||
}
|
||||
SPROUT_CONSTEXPR counting_iterator operator-(difference_type n) const {
|
||||
return counting_iterator(current_ - n);
|
||||
}
|
||||
counting_iterator& operator+=(difference_type n) {
|
||||
counting_iterator temp(current_ + n);
|
||||
temp.swap(*this);
|
||||
return *this;
|
||||
}
|
||||
counting_iterator& operator-=(difference_type n) {
|
||||
counting_iterator temp(current_ - n);
|
||||
temp.swap(*this);
|
||||
return *this;
|
||||
}
|
||||
SPROUT_CONSTEXPR reference operator[](difference_type n) const {
|
||||
return current_ + n;
|
||||
}
|
||||
SPROUT_CONSTEXPR counting_iterator next() const {
|
||||
return counting_iterator(current_ + 1);
|
||||
}
|
||||
SPROUT_CONSTEXPR counting_iterator prev() const {
|
||||
return counting_iterator(current_ - 1);
|
||||
}
|
||||
void swap(counting_iterator& other) {
|
||||
using std::swap;
|
||||
swap(current_, other.current_);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator==(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return *lhs == *rhs;
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator!=(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator<(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return *lhs < *rhs;
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator>(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return rhs < lhs;
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator<=(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return !(rhs < lhs);
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR bool operator>=(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return !(lhs < rhs);
|
||||
}
|
||||
template<typename Incrementable1, typename Incrementable2>
|
||||
SPROUT_CONSTEXPR typename sprout::counting_iterator<Incrementable1>::difference_type operator-(
|
||||
sprout::counting_iterator<Incrementable1> const& lhs,
|
||||
sprout::counting_iterator<Incrementable2> const& rhs
|
||||
)
|
||||
{
|
||||
return static_cast<typename sprout::counting_iterator<Incrementable1>::difference_type>(*lhs - *rhs);
|
||||
}
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable> operator+(
|
||||
typename sprout::counting_iterator<Incrementable>::difference_type n,
|
||||
sprout::counting_iterator<Incrementable> const& it
|
||||
)
|
||||
{
|
||||
return it + n;
|
||||
}
|
||||
|
||||
//
|
||||
// make_counting_iterator
|
||||
//
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable>
|
||||
make_counting_iterator(Incrementable const& v) {
|
||||
return sprout::counting_iterator<Incrementable>(v);
|
||||
}
|
||||
|
||||
//
|
||||
// swap
|
||||
//
|
||||
template<typename Incrementable>
|
||||
void swap(sprout::counting_iterator<Incrementable>& lhs, sprout::counting_iterator<Incrementable>& rhs)
|
||||
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
|
||||
{
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
//
|
||||
// next
|
||||
//
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable> next(
|
||||
sprout::counting_iterator<Incrementable> const& it
|
||||
)
|
||||
{
|
||||
return it.next();
|
||||
}
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable> next(
|
||||
sprout::counting_iterator<Incrementable> const& it,
|
||||
typename sprout::counting_iterator<Incrementable>::difference_type n
|
||||
)
|
||||
{
|
||||
return it + n;
|
||||
}
|
||||
|
||||
//
|
||||
// prev
|
||||
//
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable> prev(
|
||||
sprout::counting_iterator<Incrementable> const& it
|
||||
)
|
||||
{
|
||||
return it.prev();
|
||||
}
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::counting_iterator<Incrementable> prev(
|
||||
sprout::counting_iterator<Incrementable> const& it,
|
||||
typename sprout::counting_iterator<Incrementable>::difference_type n
|
||||
)
|
||||
{
|
||||
return it - n;
|
||||
}
|
||||
|
||||
//
|
||||
// distance
|
||||
//
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR typename std::iterator_traits<sprout::counting_iterator<Incrementable> >::difference_type
|
||||
distance(
|
||||
sprout::counting_iterator<Incrementable> first,
|
||||
sprout::counting_iterator<Incrementable> last
|
||||
)
|
||||
{
|
||||
return last - first;
|
||||
}
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_ITERATOR_COUNTING_ITERATOR_HPP
|
||||
|
|
@ -4,6 +4,7 @@
|
|||
#include <sprout/config.hpp>
|
||||
#include <sprout/range/adaptor/copied.hpp>
|
||||
#include <sprout/range/adaptor/transformed.hpp>
|
||||
#include <sprout/range/adaptor/size_enumed.hpp>
|
||||
#include <sprout/range/adaptor/sinusoidal.hpp>
|
||||
|
||||
#endif // #ifndef SPROUT_RANGE_ADAPTOR_HPP
|
||||
|
|
|
|||
174
sprout/range/adaptor/counting.hpp
Normal file
174
sprout/range/adaptor/counting.hpp
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
#ifndef SPROUT_RANGE_ADAPTOR_COUNTING_HPP
|
||||
#define SPROUT_RANGE_ADAPTOR_COUNTING_HPP
|
||||
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/pit.hpp>
|
||||
#include <sprout/container/traits.hpp>
|
||||
#include <sprout/container/functions.hpp>
|
||||
#include <sprout/iterator/counting_iterator.hpp>
|
||||
#include <sprout/range/range_container.hpp>
|
||||
#include <sprout/range/algorithm/copy.hpp>
|
||||
#include <sprout/type_traits/lvalue_reference.hpp>
|
||||
#include <sprout/utility/forward.hpp>
|
||||
#include <sprout/utility/lvalue_forward.hpp>
|
||||
|
||||
namespace sprout {
|
||||
namespace adaptors {
|
||||
//
|
||||
// counting_range
|
||||
//
|
||||
template<typename Incrementable, typename Range = void>
|
||||
class counting_range
|
||||
: public sprout::range::range_container<
|
||||
sprout::counting_iterator<Incrementable>
|
||||
>
|
||||
, public sprout::detail::container_nosy_static_size<Range>
|
||||
, public sprout::detail::container_nosy_fixed_size<Range>
|
||||
{
|
||||
public:
|
||||
typedef Range range_type;
|
||||
typedef sprout::range::range_container<
|
||||
sprout::counting_iterator<Incrementable>
|
||||
> base_type;
|
||||
typedef typename base_type::iterator iterator;
|
||||
typedef typename base_type::value_type value_type;
|
||||
typedef typename base_type::difference_type difference_type;
|
||||
public:
|
||||
counting_range() = default;
|
||||
counting_range(counting_range const&) = default;
|
||||
explicit SPROUT_CONSTEXPR counting_range(range_type& range)
|
||||
: base_type(
|
||||
iterator(),
|
||||
sprout::next(iterator(), sprout::size(range))
|
||||
)
|
||||
{}
|
||||
SPROUT_CONSTEXPR counting_range(
|
||||
range_type& range,
|
||||
value_type const& first
|
||||
)
|
||||
: base_type(
|
||||
iterator(first),
|
||||
sprout::next(iterator(first), sprout::size(range))
|
||||
)
|
||||
{}
|
||||
SPROUT_CONSTEXPR counting_range(
|
||||
range_type& range,
|
||||
value_type const& first,
|
||||
value_type const& last
|
||||
)
|
||||
: base_type(
|
||||
iterator(first),
|
||||
sprout::size(range) < last - first ? sprout::next(iterator(first), sprout::size(range))
|
||||
: iterator(last)
|
||||
)
|
||||
{}
|
||||
};
|
||||
|
||||
template<typename Incrementable>
|
||||
class counting_range<Incrementable, void>
|
||||
: public sprout::range::range_container<
|
||||
sprout::counting_iterator<Incrementable>
|
||||
>
|
||||
{
|
||||
public:
|
||||
typedef sprout::range::range_container<
|
||||
sprout::counting_iterator<Incrementable>
|
||||
> base_type;
|
||||
typedef typename base_type::iterator iterator;
|
||||
typedef typename base_type::value_type value_type;
|
||||
typedef typename base_type::difference_type difference_type;
|
||||
public:
|
||||
counting_range() = default;
|
||||
counting_range(counting_range const&) = default;
|
||||
explicit SPROUT_CONSTEXPR counting_range(value_type const& first)
|
||||
: base_type(
|
||||
iterator(first),
|
||||
iterator(std::numeric_limits<value_type>::max())
|
||||
)
|
||||
{}
|
||||
SPROUT_CONSTEXPR counting_range(
|
||||
value_type const& first,
|
||||
value_type const& last
|
||||
)
|
||||
: base_type(
|
||||
iterator(first),
|
||||
iterator(last)
|
||||
)
|
||||
{}
|
||||
};
|
||||
|
||||
//
|
||||
// counting_forwarder
|
||||
//
|
||||
class counting_forwarder {
|
||||
public:
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::adaptors::counting_range<Incrementable>
|
||||
operator()(Incrementable const& first) const {
|
||||
return sprout::adaptors::counting_range<Incrementable>(first);
|
||||
}
|
||||
template<typename Incrementable>
|
||||
SPROUT_CONSTEXPR sprout::adaptors::counting_range<Incrementable>
|
||||
operator()(Incrementable const& first, Incrementable const& last) const {
|
||||
return sprout::adaptors::counting_range<Incrementable>(first, last);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// counting
|
||||
//
|
||||
namespace {
|
||||
SPROUT_STATIC_CONSTEXPR sprout::adaptors::counting_forwarder counting{};
|
||||
} // anonymous-namespace
|
||||
|
||||
//
|
||||
// operator|
|
||||
//
|
||||
template<typename Range, typename Incrementable>
|
||||
inline SPROUT_CONSTEXPR sprout::adaptors::counting_range<
|
||||
Incrementable,
|
||||
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
|
||||
>
|
||||
operator|(Range&& lhs, sprout::adaptors::counting_range<Incrementable> const& rhs) {
|
||||
return sprout::adaptors::counting_range<
|
||||
Incrementable,
|
||||
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
|
||||
>(
|
||||
sprout::lvalue_forward<Range>(lhs),
|
||||
*rhs.begin(),
|
||||
*rhs.end()
|
||||
);
|
||||
}
|
||||
} // namespace adaptors
|
||||
|
||||
//
|
||||
// container_construct_traits
|
||||
//
|
||||
template<typename Incrementable, typename Range>
|
||||
struct container_construct_traits<sprout::adaptors::counting_range<Incrementable, Range> > {
|
||||
public:
|
||||
typedef typename sprout::container_construct_traits<Range>::copied_type copied_type;
|
||||
public:
|
||||
template<typename Cont>
|
||||
static SPROUT_CONSTEXPR copied_type deep_copy(Cont&& cont) {
|
||||
return sprout::range::fixed::copy(sprout::forward<Cont>(cont), sprout::pit<copied_type>());
|
||||
}
|
||||
template<typename... Args>
|
||||
static SPROUT_CONSTEXPR copied_type make(Args&&... args) {
|
||||
return sprout::make<copied_type>(sprout::forward<Args>(args)...);
|
||||
}
|
||||
template<typename Cont, typename... Args>
|
||||
static SPROUT_CONSTEXPR copied_type remake(
|
||||
Cont&& cont,
|
||||
typename sprout::container_traits<sprout::adaptors::counting_range<Incrementable, Range> >::difference_type size,
|
||||
Args&&... args
|
||||
)
|
||||
{
|
||||
return sprout::remake<copied_type>(sprout::forward<Cont>(cont), size, sprout::forward<Args>(args)...);
|
||||
}
|
||||
};
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_RANGE_ADAPTOR_COUNTING_HPP
|
||||
|
|
@ -45,8 +45,8 @@ namespace sprout {
|
|||
typedef typename base_type::iterator iterator;
|
||||
typedef typename base_type::size_type size_type;
|
||||
public:
|
||||
SPROUT_CONSTEXPR transformed_range() = default;
|
||||
SPROUT_CONSTEXPR transformed_range(transformed_range const&) = default;
|
||||
transformed_range() = default;
|
||||
transformed_range(transformed_range const&) = default;
|
||||
SPROUT_CONSTEXPR transformed_range(functor_type func, range_type& range1, range2_type& range2)
|
||||
: base_type(
|
||||
iterator(sprout::begin(range1), sprout::begin(range2), func),
|
||||
|
|
@ -77,8 +77,8 @@ namespace sprout {
|
|||
> base_type;
|
||||
typedef typename base_type::iterator iterator;
|
||||
public:
|
||||
SPROUT_CONSTEXPR transformed_range() = default;
|
||||
SPROUT_CONSTEXPR transformed_range(transformed_range const&) = default;
|
||||
transformed_range() = default;
|
||||
transformed_range(transformed_range const&) = default;
|
||||
SPROUT_CONSTEXPR transformed_range(functor_type func, range_type& range)
|
||||
: base_type(
|
||||
iterator(sprout::begin(range), func),
|
||||
|
|
|
|||
Loading…
Reference in a new issue