King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

add adaptor piped, taken, dropped, window, offset, adapted_xxx

Browse source
This commit is contained in:
bolero-MURAKAMI 2012-11-24 13:04:02 +09:00
parent 5c9a8153de
commit cc4ade67fd
47 changed files with 1349 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

72
sprout/range/adaptor/adapted_dropped.hpp Normal file
View file

@ -0,0 +1,72 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP
#include <sprout/config.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken.hpp>
#include <sprout/range/adaptor/dropped.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_drop_holder
//
template<typename Adaptor, typename Difference>
class adapt_drop_holder {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR adapt_drop_holder(adaptor_type const& adaptor, difference_type distance)
: adaptor_(adaptor), distance_(distance)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// adapted_dropped_forwarder
//
class adapted_dropped_forwarder {
public:
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_drop_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference distance) {
return sprout::adaptors::adapt_drop_holder<Adaptor, Difference>(adaptor, distance);
}
};
//
// adapted_dropped
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_dropped_forwarder adapted_dropped{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_drop_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()) | rhs.adaptor())
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()) | rhs.adaptor())
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP

72
sprout/range/adaptor/adapted_dropped_end.hpp Normal file
View file

@ -0,0 +1,72 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP
#include <sprout/config.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken_end.hpp>
#include <sprout/range/adaptor/dropped_end.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_drop_end_holder
//
template<typename Adaptor, typename Difference>
class adapt_drop_end_holder {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR adapt_drop_end_holder(adaptor_type const& adaptor, difference_type distance)
: adaptor_(adaptor), distance_(distance)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// adapted_dropped_end_forwarder
//
class adapted_dropped_end_forwarder {
public:
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference distance) {
return sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference>(adaptor, distance);
}
};
//
// adapted_dropped_end
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_dropped_end_forwarder adapted_dropped_end{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance()) | rhs.adaptor()
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()))
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance()) | rhs.adaptor()
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()))
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP

116
sprout/range/adaptor/adapted_offset.hpp Normal file
View file

@ -0,0 +1,116 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP
#include <sprout/config.hpp>
#include <sprout/type_traits/arithmetic_promote.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken.hpp>
#include <sprout/range/adaptor/taken_end.hpp>
#include <sprout/range/adaptor/offset.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_offset_holder
//
template<typename Adaptor, typename Difference1, typename Difference2 = void>
class adapt_offset_holder {
public:
typedef Adaptor adaptor_type;
typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
private:
adaptor_type adaptor_;
difference_type from_begin_;
difference_type from_end_;
public:
explicit SPROUT_CONSTEXPR adapt_offset_holder(adaptor_type const& adaptor, difference_type from_begin, difference_type from_end)
: adaptor_(adaptor), from_begin_(from_begin), from_end_(from_end)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& from_begin() const {
return from_begin_;
}
SPROUT_CONSTEXPR difference_type const& from_end() const {
return from_end_;
}
};
template<typename Adaptor, typename Difference>
class adapt_offset_holder<Adaptor, Difference, void> {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type from_begin_;
public:
explicit SPROUT_CONSTEXPR adapt_offset_holder(adaptor_type const& adaptor, difference_type from_begin)
: adaptor_(adaptor), from_begin_(from_begin)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& from_begin() const {
return from_begin_;
}
};
//
// adapt_offset_forwarder
//
class adapt_offset_forwarder {
public:
template<typename Adaptor, typename Difference1, typename Difference2>
SPROUT_CONSTEXPR sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2>
operator()(Adaptor const& adaptor, Difference1 from_begin, Difference2 from_end) {
return sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2>(adaptor, from_begin, from_end);
}
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_offset_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference from_begin) {
return sprout::adaptors::adapt_offset_holder<Adaptor, Difference>(adaptor, from_begin);
}
};
//
// adapt_offset
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapt_offset_forwarder adapt_offset{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference1, typename Difference2>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin(), rhs.from_end()) | rhs.adaptor())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.from_end()))
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin(), rhs.from_end()) | rhs.adaptor())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.from_end()))
;
}
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_offset_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin()) | rhs.adaptor())
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin()) | rhs.adaptor())
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP

72
sprout/range/adaptor/adapted_taken.hpp Normal file
View file

@ -0,0 +1,72 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP
#include <sprout/config.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken.hpp>
#include <sprout/range/adaptor/dropped.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_take_holder
//
template<typename Adaptor, typename Difference>
class adapt_take_holder {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR adapt_take_holder(adaptor_type const& adaptor, difference_type distance)
: adaptor_(adaptor), distance_(distance)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// adapted_taken_forwarder
//
class adapted_taken_forwarder {
public:
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_take_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference distance) {
return sprout::adaptors::adapt_take_holder<Adaptor, Difference>(adaptor, distance);
}
};
//
// adapted_taken
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_taken_forwarder adapted_taken{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_take_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance()) | rhs.adaptor()
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()))
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance()) | rhs.adaptor()
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()))
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP

72
sprout/range/adaptor/adapted_taken_end.hpp Normal file
View file

@ -0,0 +1,72 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP
#include <sprout/config.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken_end.hpp>
#include <sprout/range/adaptor/dropped_end.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_take_end_holder
//
template<typename Adaptor, typename Difference>
class adapt_take_end_holder {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR adapt_take_end_holder(adaptor_type const& adaptor, difference_type distance)
: adaptor_(adaptor), distance_(distance)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// adapted_taken_end_forwarder
//
class adapted_taken_end_forwarder {
public:
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_take_end_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference distance) {
return sprout::adaptors::adapt_take_end_holder<Adaptor, Difference>(adaptor, distance);
}
};
//
// adapted_taken_end
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_taken_end_forwarder adapted_taken_end{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_take_end_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()) | rhs.adaptor())
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()) | rhs.adaptor())
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP

116
sprout/range/adaptor/adapted_window.hpp Normal file
View file

@ -0,0 +1,116 @@
#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP
#define SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP
#include <sprout/config.hpp>
#include <sprout/type_traits/arithmetic_promote.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/range/adaptor/taken.hpp>
#include <sprout/range/adaptor/dropped.hpp>
#include <sprout/range/adaptor/window.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace adaptors {
//
// adapt_window_holder
//
template<typename Adaptor, typename Difference1, typename Difference2 = void>
class adapt_window_holder {
public:
typedef Adaptor adaptor_type;
typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
private:
adaptor_type adaptor_;
difference_type to_first_;
difference_type to_last_;
public:
explicit SPROUT_CONSTEXPR adapt_window_holder(adaptor_type const& adaptor, difference_type to_first, difference_type to_last)
: adaptor_(adaptor), to_first_(to_first), to_last_(to_last)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& to_first() const {
return to_first_;
}
SPROUT_CONSTEXPR difference_type const& to_last() const {
return to_last_;
}
};
template<typename Adaptor, typename Difference>
class adapt_window_holder<Adaptor, Difference, void> {
public:
typedef Adaptor adaptor_type;
typedef Difference difference_type;
private:
adaptor_type adaptor_;
difference_type to_first_;
public:
explicit SPROUT_CONSTEXPR adapt_window_holder(adaptor_type const& adaptor, difference_type to_first)
: adaptor_(adaptor), to_first_(to_first)
{}
SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
return adaptor_;
}
SPROUT_CONSTEXPR difference_type const& to_first() const {
return to_first_;
}
};
//
// adapt_window_forwarder
//
class adapt_window_forwarder {
public:
template<typename Adaptor, typename Difference1, typename Difference2>
SPROUT_CONSTEXPR sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2>
operator()(Adaptor const& adaptor, Difference1 to_first, Difference2 to_last) {
return sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2>(adaptor, to_first, to_last);
}
template<typename Adaptor, typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::adapt_window_holder<Adaptor, Difference>
operator()(Adaptor const& adaptor, Difference to_first) {
return sprout::adaptors::adapt_window_holder<Adaptor, Difference>(adaptor, to_first);
}
};
//
// adapt_window
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapt_window_forwarder adapt_window{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Adaptor, typename Difference1, typename Difference2>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first(), rhs.to_last()) | rhs.adaptor())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.to_last()))
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first(), rhs.to_last()) | rhs.adaptor())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.to_last()))
;
}
template<typename Range, typename Adaptor, typename Difference>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::adapt_window_holder<Adaptor, Difference> const& rhs)
-> decltype(
sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first()) | rhs.adaptor())
)
{
return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first()) | rhs.adaptor())
;
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP

4
sprout/range/adaptor/blanked.hpp
View file

@ -55,7 +55,7 @@ namespace sprout {
difference_type n
)
: base_type(
iterator(value_type(), static_cast<difference_type>(NS_SSCRISK_CEL_OR_SPROUT::min<size_type>(n, sprout::size(range)))),
iterator(value_type(), NS_SSCRISK_CEL_OR_SPROUT::min(n, sprout::size(range))),
iterator(value_type(), 0)
)
{}
@ -65,7 +65,7 @@ namespace sprout {
value_type const& value
)
: base_type(
iterator(value, static_cast<difference_type>(NS_SSCRISK_CEL_OR_SPROUT::min<size_type>(n, sprout::size(range)))),
iterator(value, NS_SSCRISK_CEL_OR_SPROUT::min(n, sprout::size(range))),
iterator(value, 0)
)
{}

77
sprout/range/adaptor/dropped.hpp Normal file
View file

@ -0,0 +1,77 @@
#ifndef SPROUT_RANGE_ADAPTOR_DROPPED_HPP
#define SPROUT_RANGE_ADAPTOR_DROPPED_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// drop_holder
//
template<typename Difference>
class drop_holder {
public:
typedef Difference difference_type;
private:
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR drop_holder(difference_type distance)
: distance_(distance)
{}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// dropped_forwarder
//
class dropped_forwarder {
public:
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::drop_holder<Difference>
operator()(Difference distance) {
return sprout::adaptors::drop_holder<Difference>(distance);
}
};
//
// dropped
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::dropped_forwarder dropped{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::drop_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.distance(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::end(sprout::lvalue_forward<Range>(lhs))
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_DROPPED_HPP

77
sprout/range/adaptor/dropped_end.hpp Normal file
View file

@ -0,0 +1,77 @@
#ifndef SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP
#define SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// drop_end_holder
//
template<typename Difference>
class drop_end_holder {
public:
typedef Difference difference_type;
private:
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR drop_end_holder(difference_type distance)
: distance_(distance)
{}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// dropped_end_forwarder
//
class dropped_end_forwarder {
public:
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::drop_end_holder<Difference>
operator()(Difference distance) {
return sprout::adaptors::drop_end_holder<Difference>(distance);
}
};
//
// dropped_end
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::dropped_end_forwarder dropped_end{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::drop_end_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
sprout::next(
sprout::end(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(rhs.distance(), -sprout::size(sprout::lvalue_forward<Range>(lhs)))
)
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP

125
sprout/range/adaptor/offset.hpp Normal file
View file

@ -0,0 +1,125 @@
#ifndef SPROUT_RANGE_ADAPTOR_OFFSET_HPP
#define SPROUT_RANGE_ADAPTOR_OFFSET_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/type_traits/arithmetic_promote.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// offset_holder
//
template<typename Difference1, typename Difference2 = void>
class offset_holder {
public:
typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
private:
difference_type from_begin_;
difference_type from_end_;
public:
SPROUT_CONSTEXPR offset_holder(difference_type from_begin, difference_type from_end)
: from_begin_(from_begin), from_end_(from_end)
{}
SPROUT_CONSTEXPR difference_type const& from_begin() const {
return from_begin_;
}
SPROUT_CONSTEXPR difference_type const& from_end() const {
return from_end_;
}
};
template<typename Difference>
class offset_holder<Difference, void> {
public:
typedef Difference difference_type;
private:
difference_type from_begin_;
public:
explicit SPROUT_CONSTEXPR offset_holder(difference_type from_begin)
: from_begin_(from_begin)
{}
SPROUT_CONSTEXPR difference_type const& from_begin() const {
return from_begin_;
}
};
//
// offset_forwarder
//
class offset_forwarder {
public:
template<typename Difference1, typename Difference2>
SPROUT_CONSTEXPR sprout::adaptors::offset_holder<Difference1, Difference2>
operator()(Difference1 from_begin, Difference2 from_end) {
return sprout::adaptors::offset_holder<Difference1, Difference2>(from_begin, from_end);
}
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::offset_holder<Difference>
operator()(Difference from_begin) {
return sprout::adaptors::offset_holder<Difference>(from_begin);
}
};
//
// offset
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::offset_forwarder offset{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference1, typename Difference2>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::offset_holder<Difference1, Difference2> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::next(
sprout::end(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(
rhs.from_end(),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin() - sprout::size(sprout::lvalue_forward<Range>(lhs)), 0)
)
)
);
}
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::offset_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::end(sprout::lvalue_forward<Range>(lhs))
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_OFFSET_HPP

129
sprout/range/adaptor/piped.hpp Normal file
View file

@ -0,0 +1,129 @@
#ifndef SPROUT_RANGE_ADAPTOR_PIPED_HPP
#define SPROUT_RANGE_ADAPTOR_PIPED_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/tuple/tuple.hpp>
namespace sprout {
namespace adaptors {
namespace detail {
template<typename Range>
inline SPROUT_CONSTEXPR auto
apply_adaptors_impl(Range&& range)
-> decltype(sprout::forward<Range>(range))
{
return sprout::forward<Range>(range);
}
template<typename Range, typename Adaptor>
inline SPROUT_CONSTEXPR auto
apply_adaptors_impl(Range&& range, Adaptor const& adaptor)
-> decltype(sprout::forward<Range>(range) | adaptor)
{
return sprout::forward<Range>(range) | adaptor;
}
template<typename Range, typename Adaptor, typename... Tail>
inline SPROUT_CONSTEXPR auto
apply_adaptors_impl(Range&& range, Adaptor const& adaptor, Tail const&... tail)
-> decltype(sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range) | adaptor, tail...))
{
return sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range) | adaptor, tail...);
}
} // namespace detail
//
// apply_adaptors
//
template<typename Range, typename... Adaptors>
SPROUT_CONSTEXPR auto
apply_adaptors(Range&& range, Adaptors const&... adaptors)
-> decltype(sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range), adaptors...))
{
return sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range), adaptors...);
}
namespace detail {
template<typename Range, typename AdaptorsTuple, sprout::index_t... Indexes>
SPROUT_CONSTEXPR auto
apply_adaptors_tuple_impl(Range&& range, AdaptorsTuple const& adaptors, sprout::index_tuple<Indexes...>)
-> decltype(sprout::adaptors::apply_adaptors(sprout::forward<Range>(range), sprout::tuples::get<Indexes>(adaptors)...))
{
return sprout::adaptors::apply_adaptors(sprout::forward<Range>(range), sprout::tuples::get<Indexes>(adaptors)...);
}
template<typename Range, typename AdaptorsTuple>
SPROUT_CONSTEXPR auto
apply_adaptors_tuple(Range&& range, AdaptorsTuple const& adaptors)
-> decltype(
sprout::adaptors::detail::apply_adaptors_tuple_impl(
sprout::forward<Range>(range), adaptors,
sprout::index_range<0, sprout::tuples::tuple_size<AdaptorsTuple>::value>::make()
)
)
{
return sprout::adaptors::detail::apply_adaptors_tuple_impl(
sprout::forward<Range>(range), adaptors,
sprout::index_range<0, sprout::tuples::tuple_size<AdaptorsTuple>::value>::make()
);
}
} // namespace detail
//
// pipe_holder
//
template<typename... Adaptors>
class pipe_holder {
public:
typedef sprout::tuples::tuple<Adaptors...> adaptors_type;
private:
adaptors_type adaptors_;
public:
explicit SPROUT_CONSTEXPR pipe_holder(Adaptors const&... adaptors)
: adaptors_(adaptors...)
{}
SPROUT_CONSTEXPR adaptors_type const& adaptors() const {
return adaptors_;
}
template<typename Range>
SPROUT_CONSTEXPR auto
apply(Range&& range) const
-> decltype(sprout::adaptors::detail::apply_adaptors_tuple(sprout::forward<Range>(range), adaptors_))
{
return sprout::adaptors::detail::apply_adaptors_tuple(sprout::forward<Range>(range), adaptors_);
}
};
//
// piped_forwarder
//
class piped_forwarder {
public:
template<typename... Adaptors>
SPROUT_CONSTEXPR sprout::adaptors::pipe_holder<Adaptors...>
operator()(Adaptors const&... adaptors) {
return sprout::adaptors::pipe_holder<Adaptors...>(adaptors...);
}
};
//
// piped
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::piped_forwarder piped{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename... Adaptors>
inline SPROUT_CONSTEXPR auto
operator|(Range&& lhs, sprout::adaptors::pipe_holder<Adaptors...> const& rhs)
-> decltype(rhs.apply(sprout::lvalue_forward<Range>(lhs)))
{
return rhs.apply(sprout::lvalue_forward<Range>(lhs));
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_PIPED_HPP

3
sprout/range/adaptor/sized.hpp
View file

@ -81,8 +81,7 @@ namespace sprout {
explicit SPROUT_CONSTEXPR sized_range(range_type& range)
: base_type(
sprout::begin(range),
sized_impl_type::static_size
< static_cast<typename sprout::container_traits<Range>::size_type>(sprout::size(range))
sized_impl_type::static_size < static_cast<typename sprout::container_traits<Range>::size_type>(sprout::size(range))
? sprout::next(sprout::begin(range), sized_impl_type::static_size)
: sprout::end(range)
)

77
sprout/range/adaptor/taken.hpp Normal file
View file

@ -0,0 +1,77 @@
#ifndef SPROUT_RANGE_ADAPTOR_TAKEN_HPP
#define SPROUT_RANGE_ADAPTOR_TAKEN_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// take_holder
//
template<typename Difference>
class take_holder {
public:
typedef Difference difference_type;
private:
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR take_holder(difference_type distance)
: distance_(distance)
{}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// taken_forwarder
//
class taken_forwarder {
public:
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::take_holder<Difference>
operator()(Difference distance) {
return sprout::adaptors::take_holder<Difference>(distance);
}
};
//
// taken
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::taken_forwarder taken{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::take_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.distance(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
)
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_TAKEN_HPP

77
sprout/range/adaptor/taken_end.hpp Normal file
View file

@ -0,0 +1,77 @@
#ifndef SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP
#define SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// take_end_holder
//
template<typename Difference>
class take_end_holder {
public:
typedef Difference difference_type;
private:
difference_type distance_;
public:
explicit SPROUT_CONSTEXPR take_end_holder(difference_type distance)
: distance_(distance)
{}
SPROUT_CONSTEXPR difference_type const& distance() const {
return distance_;
}
};
//
// taken_end_forwarder
//
class taken_end_forwarder {
public:
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::take_end_holder<Difference>
operator()(Difference distance) {
return sprout::adaptors::take_end_holder<Difference>(distance);
}
};
//
// taken_end
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::taken_end_forwarder taken_end{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::take_end_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::end(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(rhs.distance(), -sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::end(sprout::lvalue_forward<Range>(lhs))
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP

122
sprout/range/adaptor/window.hpp Normal file
View file

@ -0,0 +1,122 @@
#ifndef SPROUT_RANGE_ADAPTOR_WINDOW_HPP
#define SPROUT_RANGE_ADAPTOR_WINDOW_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/range/range_container.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/type_traits/arithmetic_promote.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
namespace sprout {
namespace adaptors {
//
// window_holder
//
template<typename Difference1, typename Difference2 = void>
class window_holder {
public:
typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
private:
difference_type to_first_;
difference_type to_last_;
public:
SPROUT_CONSTEXPR window_holder(difference_type to_first, difference_type to_last)
: to_first_(to_first), to_last_(to_last)
{}
SPROUT_CONSTEXPR difference_type const& to_first() const {
return to_first_;
}
SPROUT_CONSTEXPR difference_type const& to_last() const {
return to_last_;
}
};
template<typename Difference>
class window_holder<Difference, void> {
public:
typedef Difference difference_type;
private:
difference_type to_first_;
public:
explicit SPROUT_CONSTEXPR window_holder(difference_type to_first)
: to_first_(to_first)
{}
SPROUT_CONSTEXPR difference_type const& to_first() const {
return to_first_;
}
};
//
// window_forwarder
//
class window_forwarder {
public:
template<typename Difference1, typename Difference2>
SPROUT_CONSTEXPR sprout::adaptors::window_holder<Difference1, Difference2>
operator()(Difference1 to_first, Difference2 to_last) {
return sprout::adaptors::window_holder<Difference1, Difference2>(to_first, to_last);
}
template<typename Difference>
SPROUT_CONSTEXPR sprout::adaptors::window_holder<Difference>
operator()(Difference to_first) {
return sprout::adaptors::window_holder<Difference>(to_first);
}
};
//
// window
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::window_forwarder window{};
} // anonymous-namespace
//
// operator|
//
template<typename Range, typename Difference1, typename Difference2>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::window_holder<Difference1, Difference2> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_first(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_last(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
)
);
}
template<typename Range, typename Difference>
inline SPROUT_CONSTEXPR sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>
operator|(Range&& lhs, sprout::adaptors::window_holder<Difference> const& rhs) {
typedef typename sprout::container_traits<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>::difference_type difference_type;
return sprout::range::range_container<
typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
>(
sprout::next(
sprout::begin(sprout::lvalue_forward<Range>(lhs)),
NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_first(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
),
sprout::end(sprout::lvalue_forward<Range>(lhs))
);
}
} // namespace adaptors
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_WINDOW_HPP