Base.h File Reference

#include <algorithm>
#include <functional>
#include <memory>
#include <random>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <folly/Conv.h>
#include <folly/Optional.h>
#include <folly/Range.h>
#include <folly/Utility.h>
#include <folly/gen/Core.h>
#include <folly/gen/Base-inl.h>

Go to the source code of this file.

Classes
class	folly::gen::Less
class	folly::gen::Greater
class	folly::gen::Get< n >
class	folly::gen::MemberFunction< Class, Result >
class	folly::gen::ConstMemberFunction< Class, Result >
class	folly::gen::Field< Class, FieldType >
class	folly::gen::Move
class	folly::gen::Negate< Predicate >
class	folly::gen::Cast< Dest >
class	folly::gen::To< Dest >
class	folly::gen::TryTo< Dest >
class	folly::gen::To< StringPiece >
class	folly::gen::Group< Key, Value >
struct	folly::gen::detail::FBounded< Self >
struct	folly::gen::detail::ValueTypeOfRange< Container >
class	folly::gen::detail::ReferencedSource< Container, Value >
class	folly::gen::detail::CopiedSource< StorageType, Container >
class	folly::gen::detail::Sequence< Value, SequenceImpl >
class	folly::gen::detail::RangeImpl< Value >
class	folly::gen::detail::RangeWithStepImpl< Value, Distance >
class	folly::gen::detail::SeqImpl< Value >
class	folly::gen::detail::SeqWithStepImpl< Value, Distance >
class	folly::gen::detail::InfiniteImpl< Value >
class	folly::gen::detail::Yield< Value, Source >
class	folly::gen::detail::Empty< Value >
class	folly::gen::detail::SingleReference< Value >
class	folly::gen::detail::SingleCopy< Value >
class	folly::gen::detail::Map< Predicate >
class	folly::gen::detail::Filter< Predicate >
class	folly::gen::detail::Until< Predicate >
class	folly::gen::detail::Sample< Random >
class	folly::gen::detail::Visit< Visitor >
class	folly::gen::detail::Order< Selector, Comparer >
class	folly::gen::detail::GroupBy< Selector >
class	folly::gen::detail::GroupByAdjacent< Selector >
class	folly::gen::detail::Distinct< Selector >
class	folly::gen::detail::Composer< Operators >
class	folly::gen::detail::TypeAssertion< Expected >
class	folly::gen::detail::Cycle< forever >
class	folly::gen::detail::FoldLeft< Seed, Fold >
class	folly::gen::detail::IsEmpty< emptyResult >
class	folly::gen::detail::Reduce< Reducer >
class	folly::gen::detail::Min< Selector, Comparer >
class	folly::gen::detail::Collect< Collection >
class	folly::gen::detail::CollectTemplate< Container, Allocator >
class	folly::gen::detail::Append< Collection >
struct	folly::gen::detail::GeneratorBuilder< Value >
class	folly::gen::detail::Contains< Needle >
class	folly::gen::detail::GuardImpl< Exception, ErrorHandler >
class	folly::gen::detail::UnwrapOr< T >
class	folly::gen::VirtualGen< Value >
struct	folly::gen::ExprIsConst< Constness >
struct	folly::gen::ExprIsMutable< Constness >

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::gen
	folly::gen::detail

Macros
#define	FOLLY_GEN_BASE_H_
#define	GENERATOR(TYPE)   ::folly::gen::detail::GeneratorBuilder<TYPE>() + [=](auto&& yield)

Enumerations
enum	folly::gen::MemberType { folly::gen::Const, folly::gen::Mutable }

Functions
template<class Predicate >
Negate< Predicate >	folly::gen::negate (Predicate pred)
template<class Container , class From = detail::ReferencedSource<const Container>>
From	folly::gen::fromConst (const Container &source)
template<class Container , class From = detail::ReferencedSource<Container>>
From	folly::gen::from (Container &source)
template<class Container , class Value = typename detail::ValueTypeOfRange<Container>::StorageType, class CopyOf = detail::CopiedSource<Value>>
CopyOf	folly::gen::fromCopy (Container &&source)
template<class Value , class From = detail::CopiedSource<Value>>
From	folly::gen::from (std::initializer_list< Value > source)
template<class Container , class From = detail::CopiedSource<typename Container::value_type, Container>>
From	folly::gen::from (Container &&source)
template<class Value , class Impl = detail::RangeImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	folly::gen::range (Value begin, Value end)
template<class Value , class Distance , class Impl = detail::RangeWithStepImpl<Value, Distance>, class Gen = detail::Sequence<Value, Impl>>
Gen	folly::gen::range (Value begin, Value end, Distance step)
template<class Value , class Impl = detail::SeqImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	folly::gen::seq (Value first, Value last)
template<class Value , class Distance , class Impl = detail::SeqWithStepImpl<Value, Distance>, class Gen = detail::Sequence<Value, Impl>>
Gen	folly::gen::seq (Value first, Value last, Distance step)
template<class Value , class Impl = detail::InfiniteImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	folly::gen::seq (Value first)
template<class Value , class Source , class Yield = detail::Yield<Value, Source>>
Yield	folly::gen::generator (Source &&source)
template<class Value >
detail::Empty< Value >	folly::gen::empty ()
template<class Value , class Just = typename std::conditional< std::is_reference<Value>::value, detail::SingleReference<typename std::remove_reference<Value>::type>, detail::SingleCopy<Value>>::type>
Just	folly::gen::just (Value &&value)
template<class Predicate , class Map = detail::Map<Predicate>>
Map	folly::gen::mapped (Predicate pred=Predicate())
template<class Predicate , class Map = detail::Map<Predicate>>
Map	folly::gen::map (Predicate pred=Predicate())
template<class Operator , class Map = detail::Map<detail::Composer<Operator>>>
Map	folly::gen::mapOp (Operator op)
template<MemberType Constness = Const, class Class , class Return , class Mem = ConstMemberFunction<Class, Return>, class Map = detail::Map<Mem>>
std::enable_if< ExprIsConst< Constness >::value, Map >::type	folly::gen::member (Return(Class::*member)() const)
template<MemberType Constness = Mutable, class Class , class Return , class Mem = MemberFunction<Class, Return>, class Map = detail::Map<Mem>>
std::enable_if< ExprIsMutable< Constness >::value, Map >::type	folly::gen::member (Return(Class::*member)())
template<class Class , class FieldType , class Field = Field<Class, FieldType>, class Map = detail::Map<Field>>
Map	folly::gen::field (FieldType Class::*field)
template<class Predicate = Identity, class Filter = detail::Filter<Predicate>>
Filter	folly::gen::filter (Predicate pred=Predicate())
template<class Visitor = Ignore, class Visit = detail::Visit<Visitor>>
Visit	folly::gen::visit (Visitor visitor=Visitor())
template<class Predicate = Identity, class Until = detail::Until<Predicate>>
Until	folly::gen::until (Predicate pred=Predicate())
template<class Predicate = Identity, class TakeWhile = detail::Until<Negate<Predicate>>>
TakeWhile	folly::gen::takeWhile (Predicate pred=Predicate())
template<class Selector = Identity, class Comparer = Less, class Order = detail::Order<Selector, Comparer>>
Order	folly::gen::orderBy (Selector selector=Selector(), Comparer comparer=Comparer())
template<class Selector = Identity, class Order = detail::Order<Selector, Greater>>
Order	folly::gen::orderByDescending (Selector selector=Selector())
template<class Selector = Identity, class GroupBy = detail::GroupBy<Selector>>
GroupBy	folly::gen::groupBy (Selector selector=Selector())
template<class Selector = Identity, class GroupByAdjacent = detail::GroupByAdjacent<Selector>>
GroupByAdjacent	folly::gen::groupByAdjacent (Selector selector=Selector())
template<class Selector = Identity, class Distinct = detail::Distinct<Selector>>
Distinct	folly::gen::distinctBy (Selector selector=Selector())
template<int n, class Get = detail::Map<Get<n>>>
Get	folly::gen::get ()
template<class Dest , class Cast = detail::Map<Cast<Dest>>>
Cast	folly::gen::eachAs ()
template<class Dest , class EachTo = detail::Map<To<Dest>>>
EachTo	folly::gen::eachTo ()
template<class Dest , class EachTryTo = detail::Map<TryTo<Dest>>>
EachTryTo	folly::gen::eachTryTo ()
template<class Value >
detail::TypeAssertion< Value >	folly::gen::assert_type ()
template<class Predicate = Identity, class Filter = detail::Filter<Predicate>, class NotEmpty = detail::IsEmpty<false>, class Composed = detail::Composed<Filter, NotEmpty>>
Composed	folly::gen::any (Predicate pred=Predicate())
template<class Predicate = Identity, class Filter = detail::Filter<Negate<Predicate>>, class IsEmpty = detail::IsEmpty<true>, class Composed = detail::Composed<Filter, IsEmpty>>
Composed	folly::gen::all (Predicate pred=Predicate())
template<class Seed , class Fold , class FoldLeft = detail::FoldLeft<Seed, Fold>>
FoldLeft	folly::gen::foldl (Seed seed=Seed(), Fold fold=Fold())
template<class Reducer , class Reduce = detail::Reduce<Reducer>>
Reduce	folly::gen::reduce (Reducer reducer=Reducer())
template<class Selector = Identity, class Min = detail::Min<Selector, Less>>
Min	folly::gen::minBy (Selector selector=Selector())
template<class Selector , class MaxBy = detail::Min<Selector, Greater>>
MaxBy	folly::gen::maxBy (Selector selector=Selector())
template<class Collection , class Collect = detail::Collect<Collection>>
Collect	folly::gen::as ()
template<template< class, class > class Container = std::vector, template< class > class Allocator = std::allocator, class Collect = detail::CollectTemplate<Container, Allocator>>
Collect	folly::gen::as ()
template<class Collection , class Append = detail::Append<Collection>>
Append	folly::gen::appendTo (Collection &collection)
template<class Needle , class Contains = detail::Contains<typename std::decay<Needle>::type>>
Contains	folly::gen::contains (Needle &&needle)
template<class Exception , class ErrorHandler , class GuardImpl = detail::GuardImpl<Exception, typename std::decay<ErrorHandler>::type>>
GuardImpl	folly::gen::guard (ErrorHandler &&handler)
template<class Fallback , class UnwrapOr = detail::UnwrapOr<typename std::decay<Fallback>::type>>
UnwrapOr	folly::gen::unwrapOr (Fallback &&fallback)

Macro Definition Documentation

#define FOLLY_GEN_BASE_H_

Definition at line 18 of file Base.h.

#define GENERATOR

(

TYPE

)

::folly::gen::detail::GeneratorBuilder<TYPE>() + [=](auto&& yield)

Definition at line 515 of file Base.h.

Referenced by BENCHMARK_RELATIVE(), and TEST().