mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-05-10 09:23:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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
Show stats Download patch file Download diff file Expand all files Collapse all files

14
sprout/checksum/sha1.hpp
View file

@ -158,7 +158,12 @@ namespace sprout {
64,
bit_count_ + 64 * 8
)
: sprout::throw_recursive_function_template_instantiation_exeeded()
: /*process<D + 1>(
h_,
sprout::make_array<std::uint8_t>(args...),
64,
bit_count_ + 64 * 8
).template process_block_impl<D + 1>(first, last)*/ sprout::throw_recursive_function_template_instantiation_exeeded()
;
}
template<int D = 16, typename Iterator, typename... Args, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
@ -175,7 +180,12 @@ namespace sprout {
block_byte_index_ + sizeof...(Args),
bit_count_ + sizeof...(Args) * 8
)
: block_byte_index_ + sizeof...(Args) == 64 ? sprout::throw_recursive_function_template_instantiation_exeeded()
: block_byte_index_ + sizeof...(Args) == 64 ? /*process<D + 1>(
h_,
sprout::get_internal(sprout::range::fixed::copy(sprout::make_array<std::uint8_t>(args...), sprout::sub(block_, block_byte_index_))),
block_byte_index_ + sizeof...(Args),
bit_count_ + sizeof...(Args) * 8
).template process_block_impl<D + 1>(first, last)*/ sprout::throw_recursive_function_template_instantiation_exeeded()
: process_block_impl<D + 1>(sprout::next(first), last, args..., *first)
;
}

1
sprout/compost.hpp
View file

@ -5,6 +5,7 @@
#include <sprout/compost/waves.hpp>
#include <sprout/compost/effects.hpp>
#include <sprout/compost/formats.hpp>
#include <sprout/compost/ranges.hpp>
#include <sprout/compost/sources.hpp>
#endif // #ifndef SPROUT_COMPOST_HPP

2
sprout/compost/effects.hpp
View file

@ -15,7 +15,5 @@
#include <sprout/compost/effects/chorus.hpp>
#include <sprout/compost/effects/noise_gated.hpp>
#include <sprout/compost/effects/superposed.hpp>
#include <sprout/compost/effects/jointed.hpp>
#include <sprout/compost/effects/copied.hpp>
#endif // #ifndef SPROUT_COMPOST_EFFECTS_HPP

2
sprout/compost/effects/changed_volume.hpp
View file

@ -65,6 +65,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::changed_volume;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/chorus.hpp
View file

@ -150,6 +150,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::chorus;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/clipped.hpp
View file

@ -79,6 +79,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::clipped;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/compressed.hpp
View file

@ -120,6 +120,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::compressed;
} // namespace compost
} // namespace sprout

20
sprout/compost/effects/copied.hpp
View file

@ -1,20 +0,0 @@
#ifndef SPROUT_COMPOST_EFFECTS_COPIED_HPP
#define SPROUT_COMPOST_EFFECTS_COPIED_HPP
#include <sprout/config.hpp>
#include <sprout/range/adaptor/copied.hpp>
namespace sprout {
namespace compost {
namespace effects {
//
// copied
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::copied_forwarder copied{};
} // anonymous-namespace
} // namespace effects
} // namespace compost
} // namespace sprout
#endif // #ifndef SPROUT_COMPOST_EFFECTS_COPIED_HPP

2
sprout/compost/effects/distorted.hpp
View file

@ -72,6 +72,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::distorted;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/fuzzed.hpp
View file

@ -71,6 +71,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::fuzzed;
} // namespace compost
} // namespace sprout

20
sprout/compost/effects/jointed.hpp
View file

@ -1,20 +0,0 @@
#ifndef SPROUT_COMPOST_EFFECTS_JOINTED_HPP
#define SPROUT_COMPOST_EFFECTS_JOINTED_HPP
#include <sprout/config.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace compost {
namespace effects {
//
// jointed
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::jointed_forwarder jointed{};
} // anonymous-namespace
} // namespace effects
} // namespace compost
} // namespace sprout
#endif // #ifndef SPROUT_COMPOST_EFFECTS_JOINTED_HPP

2
sprout/compost/effects/noise_gated.hpp
View file

@ -110,6 +110,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::noise_gated;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/overdriven.hpp
View file

@ -100,6 +100,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::overdriven;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/rectified.hpp
View file

@ -60,6 +60,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::rectified;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/reverbed.hpp
View file

@ -143,6 +143,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::reverbed;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/superposed.hpp
View file

@ -71,6 +71,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::superposed;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/tremolo.hpp
View file

@ -111,6 +111,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::tremolo;
} // namespace compost
} // namespace sprout

2
sprout/compost/effects/vibrato.hpp
View file

@ -149,6 +149,8 @@ namespace sprout {
;
}
} // namespace effects
using sprout::compost::effects::vibrato;
} // namespace compost
} // namespace sprout

4
sprout/compost/formats/as_pcm_wave.hpp
View file

@ -92,6 +92,10 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR sprout::compost::formats::as_pcm_wave_forwarder<std::int16_t> as_pcm_wave16{};
} // anonymous-namespace
} // namespace formats
using sprout::compost::formats::as_pcm_wave;
using sprout::compost::formats::as_pcm_wave8;
using sprout::compost::formats::as_pcm_wave16;
} // namespace compost
} // namespace sprout

8
sprout/compost/ranges.hpp Normal file
View file

@ -0,0 +1,8 @@
#ifndef SPROUT_COMPOST_RANGES_HPP
#define SPROUT_COMPOST_RANGES_HPP
#include <sprout/config.hpp>
#include <sprout/compost/ranges/jointed.hpp>
#include <sprout/compost/ranges/copied.hpp>
#endif // #ifndef SPROUT_COMPOST_RANGES_HPP

20
sprout/compost/ranges/copied.hpp Normal file
View file

@ -0,0 +1,20 @@
#ifndef SPROUT_COMPOST_RANGES_COPIED_HPP
#define SPROUT_COMPOST_RANGES_COPIED_HPP
#include <sprout/config.hpp>
#include <sprout/range/adaptor/copied.hpp>
namespace sprout {
namespace compost {
namespace ranges {
//
// copied
//
using sprout::adaptors::copied;
} // namespace ranges
using sprout::compost::ranges::copied;
} // namespace compost
} // namespace sprout
#endif // #ifndef SPROUT_COMPOST_RANGES_COPIED_HPP

20
sprout/compost/ranges/jointed.hpp Normal file
View file

@ -0,0 +1,20 @@
#ifndef SPROUT_COMPOST_RANGES_JOINTED_HPP
#define SPROUT_COMPOST_RANGES_JOINTED_HPP
#include <sprout/config.hpp>
#include <sprout/range/adaptor/jointed.hpp>
namespace sprout {
namespace compost {
namespace ranges {
//
// jointed
//
using sprout::adaptors::jointed;
} // namespace ranges
using sprout::compost::ranges::jointed;
} // namespace compost
} // namespace sprout
#endif // #ifndef SPROUT_COMPOST_RANGES_JOINTED_HPP

4
sprout/compost/waves/blanked.hpp
View file

@ -32,9 +32,11 @@ namespace sprout {
// blanked
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::compost::waves::blanked_forwarder blanked{};
SPROUT_STATIC_CONSTEXPR sprout::compost::waves::blanked_forwarder blanked{};
} // anonymous-namespace
} // namespace waves
using sprout::compost::waves::blanked;
} // namespace compost
} // namespace sprout

6
sprout/compost/waves/sawtooth_wave.hpp
View file

@ -10,10 +10,10 @@ namespace sprout {
//
// sawtooth_wave
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::sawtooth_wave_forwarder sawtooth_wave{};
} // anonymous-namespace
using sprout::adaptors::sawtooth_wave;
} // namespace waves
using sprout::compost::waves::sawtooth_wave;
} // namespace compost
} // namespace sprout

6
sprout/compost/waves/sinusoidal.hpp
View file

@ -10,10 +10,10 @@ namespace sprout {
//
// sinusoidal
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::sinusoidal_forwarder sinusoidal{};
} // anonymous-namespace
using sprout::adaptors::sinusoidal;
} // namespace waves
using sprout::compost::waves::sinusoidal;
} // namespace compost
} // namespace sprout

6
sprout/compost/waves/square_wave.hpp
View file

@ -10,10 +10,10 @@ namespace sprout {
//
// square_wave
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::square_wave_forwarder square_wave{};
} // anonymous-namespace
using sprout::adaptors::square_wave;
} // namespace waves
using sprout::compost::waves::square_wave;
} // namespace compost
} // namespace sprout

6
sprout/compost/waves/triangle_wave.hpp
View file

@ -10,10 +10,10 @@ namespace sprout {
//
// triangle_wave
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::triangle_wave_forwarder triangle_wave{};
} // anonymous-namespace
using sprout::adaptors::triangle_wave;
} // namespace waves
using sprout::compost::waves::triangle_wave;
} // namespace compost
} // namespace sprout

2
sprout/compost/waves/white_noise.hpp
View file

@ -146,6 +146,8 @@ namespace sprout {
);
}
} // namespace waves
using sprout::compost::waves::white_noise;
} // namespace compost
//

9
sprout/iterator/generator_iterator.hpp
View file

@ -2,6 +2,7 @@
#define SPROUT_ITERATOR_GENERATOR_ITERATOR_HPP
#include <cstddef>
#include <limits>
#include <iterator>
#include <utility>
#include <stdexcept>
@ -36,15 +37,13 @@ namespace sprout {
difference_type count_;
public:
SPROUT_CONSTEXPR generator_iterator()
: gen_()
, count_()
: gen_(), count_()
{}
explicit SPROUT_CONSTEXPR generator_iterator(
generator_type const& gen,
difference_type count = -1
difference_type count = std::numeric_limits<difference_type>::max()
)
: gen_(gen)
, count_(count)
: gen_(gen), count_(count)
{}
generator_type& generator() {
return gen_;

17
sprout/iterator/value_iterator.hpp
View file

@ -2,6 +2,7 @@
#define SPROUT_ITERATOR_VALUE_ITERATOR_HPP
#include <cstddef>
#include <limits>
#include <iterator>
#include <utility>
#include <stdexcept>
@ -52,19 +53,19 @@ namespace sprout {
sprout::value_holder<T> holder_;
difference_type count_;
private:
SPROUT_CONSTEXPR value_iterator(sprout::value_holder<T> const& r, std::size_t count)
: holder_(r)
, count_(count)
SPROUT_CONSTEXPR value_iterator(sprout::value_holder<T> const& r, difference_type count)
: holder_(r), count_(count)
{}
public:
SPROUT_CONSTEXPR value_iterator()
: holder_()
, count_()
: holder_(), count_()
{}
value_iterator(value_iterator const&) = default;
explicit SPROUT_CONSTEXPR value_iterator(typename sprout::value_holder<T>::param_type p, std::size_t count = -1)
: holder_(p)
, count_(count)
explicit SPROUT_CONSTEXPR value_iterator(
typename sprout::value_holder<T>::param_type p,
difference_type count = std::numeric_limits<difference_type>::max()
)
: holder_(p), count_(count)
{}
operator value_iterator<const_type>() const {
return value_iterator<const_type>(holder_.get(), count_);

10
sprout/random/iterator.hpp
View file

@ -22,7 +22,10 @@ namespace sprout {
)
-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
{
return sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine), count);
return count >= 0
? sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine), count)
: sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine))
;
}
template<typename Engine>
inline SPROUT_CONSTEXPR auto
@ -32,7 +35,10 @@ namespace sprout {
)
-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
{
return sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine(), count);
return count >= 0
? sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine(), count)
: sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine())
;
}
//

13
sprout/range/adaptor.hpp
View file

@ -10,6 +10,19 @@
#include <sprout/range/adaptor/filtered.hpp>
#include <sprout/range/adaptor/counting.hpp>
#include <sprout/range/adaptor/outdirected.hpp>
#include <sprout/range/adaptor/piped.hpp>
#include <sprout/range/adaptor/taken.hpp>
#include <sprout/range/adaptor/taken_end.hpp>
#include <sprout/range/adaptor/dropped.hpp>
#include <sprout/range/adaptor/dropped_end.hpp>
#include <sprout/range/adaptor/window.hpp>
#include <sprout/range/adaptor/offset.hpp>
#include <sprout/range/adaptor/adapted_taken.hpp>
#include <sprout/range/adaptor/adapted_taken_end.hpp>
#include <sprout/range/adaptor/adapted_dropped.hpp>
#include <sprout/range/adaptor/adapted_dropped_end.hpp>
#include <sprout/range/adaptor/adapted_window.hpp>
#include <sprout/range/adaptor/adapted_offset.hpp>
#include <sprout/range/adaptor/jointed.hpp>
#include <sprout/range/adaptor/deep_copied.hpp>
#include <sprout/range/adaptor/indexed.hpp>

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