mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2024-12-23 21:25:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

add generator_iterator

Browse source 
rename fix random/random_iterator.hpp -> random/iterator.hpp
This commit is contained in:
bolero-MURAKAMI 2012-09-27 21:26:32 +09:00
parent ebadf4fa7c
commit f40ee0a2ff
8 changed files with 235 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
sprout/iterator.hpp
View file

@ -2,9 +2,8 @@
#define SPROUT_ITERATOR_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/traits.hpp>
#include <sprout/iterator/operation.hpp>
#include <sprout/iterator/predefined.hpp>
#include <sprout/iterator/adaptor.hpp>
#include <sprout/iterator/wave.hpp>
#endif // #ifndef SPROUT_ITERATOR_HPP

2
sprout/iterator/adaptor.hpp
View file

@ -5,7 +5,7 @@
#include <sprout/iterator/reverse_iterator.hpp>
#include <sprout/iterator/transform_iterator.hpp>
#include <sprout/iterator/filter_iterator.hpp>
#include <sprout/iterator/counting_iterator.hpp>
#include <sprout/iterator/size_enum_iterator.hpp>
#include <sprout/iterator/bytes_iterator.hpp>
#endif // #ifndef SPROUT_ITERATOR_ADAPTOR_HPP

157
sprout/iterator/generator_iterator.hpp Normal file
View file

@ -0,0 +1,157 @@
#ifndef SPROUT_ITERATOR_GENERATOR_ITERATOR_HPP
#define SPROUT_ITERATOR_GENERATOR_ITERATOR_HPP
#include <cstddef>
#include <iterator>
#include <utility>
#include <stdexcept>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/generator/functions.hpp>
namespace sprout {
//
// generator_iterator
//
template<typename Generator>
class generator_iterator
: public std::iterator<
std::forward_iterator_tag,
typename std::remove_reference<decltype(sprout::generators::generated_value(std::declval<Generator>()))>::type,
std::ptrdiff_t,
typename std::remove_reference<decltype(sprout::generators::generated_value(std::declval<Generator>()))>::type*,
decltype(sprout::generators::generated_value(std::declval<Generator>()))
>
{
public:
typedef Generator generator_type;
typedef std::forward_iterator_tag iterator_category;
typedef decltype(sprout::generators::generated_value(std::declval<Generator>())) reference;
typedef typename std::remove_reference<reference>::type value_type;
typedef std::ptrdiff_t difference_type;
typedef value_type* pointer;
private:
generator_type gen_;
difference_type count_;
public:
SPROUT_CONSTEXPR generator_iterator()
: gen_()
, count_()
{}
explicit SPROUT_CONSTEXPR generator_iterator(
generator_type const& gen,
difference_type count = -1
)
: gen_(gen)
, count_(count)
{}
generator_type& generator() {
return gen_;
}
SPROUT_CONSTEXPR generator_type const& generator() const {
return gen_;
}
SPROUT_CONSTEXPR difference_type count() const {
return count_;
}
SPROUT_CONSTEXPR generator_iterator operator()() const {
return count_ != 0
? generator_iterator(sprout::generators::next_generator(gen_)(), count_ > 0 ? count_ - 1 : count_)
: throw std::out_of_range("generator_iterator<>: increment at out of range")
;
}
SPROUT_CONSTEXPR generator_iterator next() const {
return (*this)();
}
SPROUT_CONSTEXPR reference generated_value() const {
return sprout::generators::generated_value(gen_);
}
SPROUT_CONSTEXPR generator_iterator next_generator() const {
return (*this)();
}
void swap(generator_iterator& other) {
using std::swap;
swap(gen_, other.gen_);
swap(count_, other.count_);
}
friend SPROUT_CONSTEXPR bool operator==(generator_iterator const& lhs, generator_iterator const& rhs) {
return lhs.count_ == rhs.count_;
}
friend SPROUT_CONSTEXPR bool operator!=(generator_iterator const& lhs, generator_iterator const& rhs) {
return !(lhs == rhs);
}
friend SPROUT_CONSTEXPR bool operator<(generator_iterator const& lhs, generator_iterator const& rhs) {
typedef typename std::make_unsigned<difference_type>::type unsigned_type;
return static_cast<unsigned_type>(lhs.count_) > static_cast<unsigned_type>(rhs.count_);
}
friend SPROUT_CONSTEXPR bool operator>(generator_iterator const& lhs, generator_iterator const& rhs) {
return rhs < lhs;
}
friend SPROUT_CONSTEXPR bool operator<=(generator_iterator const& lhs, generator_iterator const& rhs) {
return !(rhs < lhs);
}
friend SPROUT_CONSTEXPR bool operator>=(generator_iterator const& lhs, generator_iterator const& rhs) {
return !(lhs < rhs);
}
SPROUT_CONSTEXPR reference operator*() const {
return count_ != 0
? sprout::generators::generated_value(gen_)
: (throw std::out_of_range("generator_iterator<>: dereference at out of range"), gen_.result())
;
}
SPROUT_CONSTEXPR pointer operator->() const {
return &*(*this);
}
generator_iterator& operator++() {
generator_iterator temp((*this)());
temp.swap(*this);
return *this;
}
generator_iterator operator++(int) {
generator_iterator result(*this);
++*this;
return result;
}
friend SPROUT_CONSTEXPR difference_type operator-(generator_iterator const& lhs, generator_iterator const& rhs) {
return rhs.count_ - lhs.count_;
}
};
//
// swap
//
template<typename Generator>
void swap(
sprout::generator_iterator<Generator>& lhs,
sprout::generator_iterator<Generator>& rhs
)
{
lhs.swap(rhs);
}
//
// iterator_distance
//
template<typename Generator>
inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::generator_iterator<Generator> >::difference_type
iterator_distance(
sprout::generator_iterator<Generator> first,
sprout::generator_iterator<Generator> last
)
{
return last - first;
}
//
// iterator_next
//
template<typename Generator>
SPROUT_CONSTEXPR sprout::generator_iterator<Generator> iterator_next(
sprout::generator_iterator<Generator> const& it
)
{
return it.next();
}
} // namespace sprout
#endif // #ifndef SPROUT_ITERATOR_GENERATOR_ITERATOR_HPP

7
sprout/iterator/predefined.hpp
View file

@ -2,9 +2,8 @@
#define SPROUT_ITERATOR_PREDEFINED_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/reverse_iterator.hpp>
#include <sprout/iterator/index_iterator.hpp>
#include <sprout/iterator/value_iterator.hpp>
#include <sprout/iterator/bytes_iterator.hpp>
#include <sprout/iterator/various.hpp>
#include <sprout/iterator/adaptor.hpp>
#include <sprout/iterator/wave.hpp>
#endif // #ifndef SPROUT_ITERATOR_PREDEFINED_HPP

10
sprout/iterator/various.hpp Normal file
View file

@ -0,0 +1,10 @@
#ifndef SPROUT_ITERATOR_VARIOUS_HPP
#define SPROUT_ITERATOR_VARIOUS_HPP
#include <sprout/config.hpp>
#include <sprout/iterator/index_iterator.hpp>
#include <sprout/iterator/value_iterator.hpp>
#include <sprout/iterator/counting_iterator.hpp>
#include <sprout/iterator/generator_iterator.hpp>
#endif // #ifndef SPROUT_ITERATOR_VARIOUS_HPP

2
sprout/random.hpp
View file

@ -21,7 +21,7 @@
#include <sprout/random/default_random_engine.hpp>
#include <sprout/random/variate_generator.hpp>
#include <sprout/random/random_result.hpp>
#include <sprout/random/random_iterator.hpp>
#include <sprout/random/iterator.hpp>
#include <sprout/random/unique_seed.hpp>
#endif // #ifndef SPROUT_RANDOM_HPP

62
sprout/random/iterator.hpp Normal file
View file

@ -0,0 +1,62 @@
#ifndef SPROUT_RANDOM_ITERATOR_HPP
#define SPROUT_RANDOM_ITERATOR_HPP
#include <utility>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/iterator/generator_iterator.hpp>
#include <sprout/type_traits/enabler_if.hpp>
namespace sprout {
namespace random {
//
// begin
//
template<
typename Engine, typename Distribution,
typename sprout::enabler_if<!std::is_integral<Distribution>::value>::tyep = sprout::enabler
>
inline SPROUT_CONSTEXPR auto
begin(
Engine const& engine, Distribution const& distribution,
typename sprout::generator_iterator<typename std::decay<decltype(distribution(engine))>::type>::difference_type count = -1
)
-> sprout::generator_iterator<typename std::decay<decltype(distribution(engine))>::type>
{
return sprout::generator_iterator<typename std::decay<decltype(distribution(engine))>::type>(distribution(engine), count);
}
template<typename Engine>
inline SPROUT_CONSTEXPR auto
begin(
Engine const& engine,
typename sprout::generator_iterator<typename std::decay<decltype(engine())>::type>::difference_type count = -1
)
-> sprout::generator_iterator<typename std::decay<decltype(engine())>::type>
{
return sprout::generator_iterator<typename std::decay<decltype(engine())>::type>(engine(), count);
}
//
// end
//
template<
typename Engine, typename Distribution,
typename sprout::enabler_if<!std::is_integral<Distribution>::value>::tyep = sprout::enabler
>
inline SPROUT_CONSTEXPR auto
end(Engine const& engine, Distribution const& distribution)
-> sprout::generator_iterator<typename std::decay<decltype(distribution(engine))>::type>
{
return sprout::generator_iterator<typename std::decay<decltype(distribution(engine))>::type>();
}
template<typename Engine>
inline SPROUT_CONSTEXPR auto
end(Engine const& engine)
-> sprout::generator_iterator<typename std::decay<decltype(engine())>::type>
{
return sprout::generator_iterator<typename std::decay<decltype(engine())>::type>();
}
} // namespace random
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_ITERATOR_HPP

323
sprout/random/random_iterator.hpp
View file

@ -1,323 +0,0 @@
#ifndef SPROUT_RANDOM_RANDOM_ITERATOR_HPP
#define SPROUT_RANDOM_RANDOM_ITERATOR_HPP
#include <cstddef>
#include <iterator>
#include <utility>
#include <stdexcept>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/iterator/next.hpp>
#include <sprout/random/random_result.hpp>
namespace sprout {
namespace random {
//
// random_iterator
//
template<typename Engine, typename Distribution = void, typename Enable = void>
class random_iterator;
template<typename Engine, typename Distribution>
class random_iterator<
Engine,
Distribution,
typename std::enable_if<!std::is_same<Distribution, void>::value>::type
>
: public std::iterator<
typename std::iterator_traits<sprout::random::random_result<Engine, Distribution> >::iterator_category,
typename std::iterator_traits<sprout::random::random_result<Engine, Distribution> >::value_type,
typename std::iterator_traits<sprout::random::random_result<Engine, Distribution> >::difference_type,
typename std::iterator_traits<sprout::random::random_result<Engine, Distribution> >::pointer,
typename std::iterator_traits<sprout::random::random_result<Engine, Distribution> >::reference
>
{
public:
typedef sprout::random::random_result<Engine, Distribution> random_result_type;
typedef typename random_result_type::engine_type engine_type;
typedef typename random_result_type::distribution_type distribution_type;
typedef typename random_result_type::result_type result_type;
typedef typename std::iterator_traits<random_result_type>::iterator_category iterator_category;
typedef typename std::iterator_traits<random_result_type>::value_type value_type;
typedef typename std::iterator_traits<random_result_type>::difference_type difference_type;
typedef typename std::iterator_traits<random_result_type>::pointer pointer;
typedef typename std::iterator_traits<random_result_type>::reference reference;
private:
random_result_type random_;
difference_type count_;
public:
SPROUT_CONSTEXPR random_iterator()
: random_()
, count_()
{}
SPROUT_CONSTEXPR random_iterator(
engine_type const& engine,
distribution_type const& distribution,
difference_type count = -1
)
: random_(distribution(engine))
, count_(count)
{}
explicit SPROUT_CONSTEXPR random_iterator(
random_result_type const& random,
difference_type count = -1
)
: random_(random)
, count_(count)
{}
SPROUT_CONSTEXPR random_iterator operator()() const {
return count_ != 0
? random_iterator(random_(), count_ > 0 ? count_ - 1 : count_)
: throw std::out_of_range("random_iterator<>: increment at out of range")
;
}
random_result_type& random_result() {
return random_;
}
SPROUT_CONSTEXPR random_result_type const& random_result() const {
return random_;
}
result_type& result() {
return random_.result();
}
SPROUT_CONSTEXPR result_type const& result() const {
return random_.result();
}
engine_type& engine() {
return random_.engine();
}
SPROUT_CONSTEXPR engine_type const& engine() const {
return random_.engine();
}
distribution_type& distribution() {
return random_.distribution();
}
SPROUT_CONSTEXPR distribution_type const& distribution() const {
return random_.distribution();
}
SPROUT_CONSTEXPR result_type min() const {
return random_.min();
}
SPROUT_CONSTEXPR result_type max() const {
return random_.max();
}
SPROUT_CONSTEXPR result_type count() const {
return count_;
}
void swap(random_iterator& other) {
using std::swap;
swap(random_, other.random_);
swap(count_, other.count_);
}
friend SPROUT_CONSTEXPR bool operator==(random_iterator const& lhs, random_iterator const& rhs) {
return lhs.count_ == rhs.count_ && (lhs.count_ == 0 || lhs.random_ == rhs.random_);
}
friend SPROUT_CONSTEXPR bool operator!=(random_iterator const& lhs, random_iterator const& rhs) {
return !(lhs == rhs);
}
SPROUT_CONSTEXPR reference operator*() const {
return count_ != 0
? random_.result()
: (throw std::out_of_range("random_iterator<>: dereference at out of range"), random_.result())
;
}
SPROUT_CONSTEXPR pointer operator->() const {
return count_ != 0
? &random_.result()
: throw std::out_of_range("random_iterator<>: dereference at out of range")
;
}
random_iterator& operator++() {
random_iterator temp((*this)());
temp.swap(*this);
return *this;
}
random_iterator operator++(int) {
random_iterator result(*this);
++*this;
return result;
}
};
template<typename Engine, typename Distribution>
class random_iterator<
Engine,
Distribution,
typename std::enable_if<std::is_same<Distribution, void>::value>::type
>
: public std::iterator<
typename std::iterator_traits<sprout::random::random_result<Engine> >::iterator_category,
typename std::iterator_traits<sprout::random::random_result<Engine> >::value_type,
typename std::iterator_traits<sprout::random::random_result<Engine> >::difference_type,
typename std::iterator_traits<sprout::random::random_result<Engine> >::pointer,
typename std::iterator_traits<sprout::random::random_result<Engine> >::reference
>
{
public:
typedef sprout::random::random_result<Engine> random_result_type;
typedef typename random_result_type::engine_type engine_type;
typedef typename random_result_type::result_type result_type;
typedef typename std::iterator_traits<random_result_type>::iterator_category iterator_category;
typedef typename std::iterator_traits<random_result_type>::value_type value_type;
typedef typename std::iterator_traits<random_result_type>::difference_type difference_type;
typedef typename std::iterator_traits<random_result_type>::pointer pointer;
typedef typename std::iterator_traits<random_result_type>::reference reference;
private:
random_result_type random_;
difference_type count_;
public:
SPROUT_CONSTEXPR random_iterator()
: random_()
, count_()
{}
SPROUT_CONSTEXPR random_iterator(
engine_type const& engine,
difference_type count = -1
)
: random_(engine())
, count_(count)
{}
explicit SPROUT_CONSTEXPR random_iterator(
random_result_type const& random,
difference_type count = -1
)
: random_(random)
, count_(count)
{}
SPROUT_CONSTEXPR random_iterator operator()() const {
return count_ != 0
? random_iterator(random_(), count_ > 0 ? count_ - 1 : count_)
: throw std::out_of_range("random_iterator<>: increment at out of range")
;
}
random_result_type& random_result() {
return random_;
}
SPROUT_CONSTEXPR random_result_type const& random_result() const {
return random_;
}
result_type& result() {
return random_.result();
}
SPROUT_CONSTEXPR result_type const& result() const {
return random_.result();
}
engine_type& engine() {
return random_.engine();
}
SPROUT_CONSTEXPR engine_type const& engine() const {
return random_.engine();
}
SPROUT_CONSTEXPR result_type min() const {
return random_.min();
}
SPROUT_CONSTEXPR result_type max() const {
return random_.max();
}
SPROUT_CONSTEXPR result_type count() const {
return count_;
}
void swap(random_iterator& other) {
using std::swap;
swap(random_, other.random_);
swap(count_, other.count_);
}
friend SPROUT_CONSTEXPR bool operator==(random_iterator const& lhs, random_iterator const& rhs) {
return lhs.count_ == rhs.count_ && (lhs.count_ == 0 || lhs.random_ == rhs.random_);
}
friend SPROUT_CONSTEXPR bool operator!=(random_iterator const& lhs, random_iterator const& rhs) {
return !(lhs == rhs);
}
SPROUT_CONSTEXPR reference operator*() const {
return count_ != 0
? random_.result()
: (throw std::out_of_range("random_iterator<>: dereference at out of range"), random_.result())
;
}
SPROUT_CONSTEXPR pointer operator->() const {
return count_ > 0
? &random_.result()
: throw std::out_of_range("random_iterator<>: dereference at out of range")
;
}
random_iterator& operator++() {
random_iterator temp((*this)());
temp.swap(*this);
return *this;
}
random_iterator operator++(int) {
random_iterator result(*this);
++*this;
return result;
}
};
//
// swap
//
template<typename Engine, typename Distribution>
void swap(
sprout::random::random_iterator<Engine, Distribution>& lhs,
sprout::random::random_iterator<Engine, Distribution>& rhs
)
{
lhs.swap(rhs);
}
//
// begin
//
template<typename Engine, typename Distribution>
SPROUT_CONSTEXPR typename std::enable_if<
!std::is_integral<Distribution>::value,
sprout::random::random_iterator<Engine, Distribution>
>::type begin(
Engine const& engine,
Distribution const& distribution,
typename sprout::random::random_iterator<Engine, Distribution>::difference_type count = -1
)
{
return sprout::random::random_iterator<Engine, Distribution>(engine, distribution, count);
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_iterator<Engine> begin(
Engine const& engine,
typename sprout::random::random_iterator<Engine>::difference_type count = -1
)
{
return sprout::random::random_iterator<Engine>(engine, count);
}
//
// end
//
template<typename Engine, typename Distribution>
SPROUT_CONSTEXPR sprout::random::random_iterator<Engine, Distribution> end(
Engine const& engine,
Distribution const& distribution
)
{
return sprout::random::random_iterator<Engine, Distribution>();
}
template<typename Engine>
SPROUT_CONSTEXPR sprout::random::random_iterator<Engine> end(
Engine const& engine
)
{
return sprout::random::random_iterator<Engine>();
}
//
// iterator_next
//
template<typename Engine, typename Distribution>
SPROUT_CONSTEXPR sprout::random::random_iterator<Engine, Distribution> iterator_next(
sprout::random::random_iterator<Engine, Distribution> const& it
)
{
return it();
}
} // namespace random
using sprout::random::random_iterator;
} // namespace sprout
#endif // #ifndef SPROUT_RANDOM_RANDOM_ITERATOR_HPP