folly::gen::detail::Cycle< forever > Class Template Reference

#include <Base-inl.h>

Inheritance diagram for folly::gen::detail::Cycle< forever >:

Classes
class	Generator

Public Member Functions
	Cycle ()=default
	Cycle (off_t limit)
template<class Source , class Value , class Gen = Generator<Value, Source>>
Gen	compose (GenImpl< Value, Source > &&source) const
template<class Source , class Value , class Gen = Generator<Value, Source>>
Gen	compose (const GenImpl< Value, Source > &source) const
Cycle< false >	operator() (off_t limit) const
Public Member Functions inherited from folly::gen::Operator< Cycle< forever > >
ResultGen	compose (const GenImpl< Value, Source > &source) const
Public Member Functions inherited from folly::gen::FBounded< Self >
const Self &	self () const
Self &	self ()

Private Attributes
off_t	limit_

Additional Inherited Members
Protected Member Functions inherited from folly::gen::Operator< Cycle< forever > >
	Operator ()=default
	Operator (Operator &&) noexcept=default
	Operator (const Operator &)=default
Operator &	operator= (Operator &&) noexcept=default
Operator &	operator= (const Operator &)=default

Detailed Description

template<bool forever>
class folly::gen::detail::Cycle< forever >

Cycle - For repeating a sequence forever.

This type is usually used through the 'cycle' static value, like:

auto tests = from(samples) | cycle | take(100);

or in the finite case:

auto thrice = g | cycle(3);

Definition at line 1920 of file Base-inl.h.

Constructor & Destructor Documentation

template<bool forever>

folly::gen::detail::Cycle< forever >::Cycle ( )

default

template<bool forever>

folly::gen::detail::Cycle< forever >::Cycle ( off_t  limit )

inlineexplicit

Definition at line 1925 of file Base-inl.h.

References forever.

                              : limit_(limit) {
    static_assert(
        !forever,
        "Cycle limit constructor should not be used when forever == true.");
  }

Member Function Documentation

template<bool forever>

template<class Source , class Value , class Gen = Generator<Value, Source>>

Gen folly::gen::detail::Cycle< forever >::compose ( GenImpl< Value, Source > &&  source ) const

inline

Definition at line 1968 of file Base-inl.h.

References folly::gen::move.

                                                     {
    return Gen(std::move(source.self()), limit_);
  }

template<bool forever>

template<class Source , class Value , class Gen = Generator<Value, Source>>

Gen folly::gen::detail::Cycle< forever >::compose ( const GenImpl< Value, Source > &  source ) const

inline

Definition at line 1973 of file Base-inl.h.

References folly::gen::FBounded< Self >::self().

                                                          {
    return Gen(source.self(), limit_);
  }

template<bool forever>

Cycle<false> folly::gen::detail::Cycle< forever >::operator() ( off_t  limit ) const

inline

Convenience function for finite cycles used like:

auto tripled = gen | cycle(3);

Definition at line 1982 of file Base-inl.h.

                                             {
    return Cycle<false>(limit);
  }

Member Data Documentation

template<bool forever>

off_t folly::gen::detail::Cycle< forever >::limit_

private

Definition at line 1921 of file Base-inl.h.

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/gen/Base-inl.h