folly::gen Namespace Reference

Namespaces
	detail

Classes
struct	ArgumentReference
class	Cast
class	ConstMemberFunction
struct	ExprIsConst
struct	ExprIsMutable
struct	FBounded
class	Field
class	GenImpl
class	Get
class	Greater
class	Group
class	IsCompatibleSignature
class	IsCompatibleSignature< Candidate, ExpectedReturn(ArgTypes...)>
class	Less
class	MemberFunction
class	MixedNewlines
class	Move
class	Negate
class	Operator
class	StreamSplitter
class	To
class	To< StringPiece >
class	TryTo
class	VirtualGen

Enumerations
enum	MemberType { Const, Mutable }

Functions
template<class Number >
detail::Take	take (Number count)
detail::Stride	stride (size_t s)
template<class Random = std::default_random_engine>
detail::Sample< Random >	sample (size_t count, Random rng=Random())
detail::Skip	skip (size_t count)
detail::Batch	batch (size_t batchSize)
detail::Window	window (size_t windowSize)
template<class Predicate >
Negate< Predicate >	negate (Predicate pred)
template<class Container , class From = detail::ReferencedSource<const Container>>
From	fromConst (const Container &source)
template<class Container , class From = detail::ReferencedSource<Container>>
From	from (Container &source)
template<class Container , class Value = typename detail::ValueTypeOfRange<Container>::StorageType, class CopyOf = detail::CopiedSource<Value>>
CopyOf	fromCopy (Container &&source)
template<class Value , class From = detail::CopiedSource<Value>>
From	from (std::initializer_list< Value > source)
template<class Container , class From = detail::CopiedSource<typename Container::value_type, Container>>
From	from (Container &&source)
template<class Value , class Impl = detail::RangeImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	range (Value begin, Value end)
template<class Value , class Distance , class Impl = detail::RangeWithStepImpl<Value, Distance>, class Gen = detail::Sequence<Value, Impl>>
Gen	range (Value begin, Value end, Distance step)
template<class Value , class Impl = detail::SeqImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	seq (Value first, Value last)
template<class Value , class Distance , class Impl = detail::SeqWithStepImpl<Value, Distance>, class Gen = detail::Sequence<Value, Impl>>
Gen	seq (Value first, Value last, Distance step)
template<class Value , class Impl = detail::InfiniteImpl<Value>, class Gen = detail::Sequence<Value, Impl>>
Gen	seq (Value first)
template<class Value , class Source , class Yield = detail::Yield<Value, Source>>
Yield	generator (Source &&source)
template<class Value >
detail::Empty< Value >	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	just (Value &&value)
template<class Predicate , class Map = detail::Map<Predicate>>
Map	mapped (Predicate pred=Predicate())
template<class Predicate , class Map = detail::Map<Predicate>>
Map	map (Predicate pred=Predicate())
template<class Operator , class Map = detail::Map<detail::Composer<Operator>>>
Map	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	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	member (Return(Class::*member)())
template<class Class , class FieldType , class Field = Field<Class, FieldType>, class Map = detail::Map<Field>>
Map	field (FieldType Class::*field)
template<class Predicate = Identity, class Filter = detail::Filter<Predicate>>
Filter	filter (Predicate pred=Predicate())
template<class Visitor = Ignore, class Visit = detail::Visit<Visitor>>
Visit	visit (Visitor visitor=Visitor())
template<class Predicate = Identity, class Until = detail::Until<Predicate>>
Until	until (Predicate pred=Predicate())
template<class Predicate = Identity, class TakeWhile = detail::Until<Negate<Predicate>>>
TakeWhile	takeWhile (Predicate pred=Predicate())
template<class Selector = Identity, class Comparer = Less, class Order = detail::Order<Selector, Comparer>>
Order	orderBy (Selector selector=Selector(), Comparer comparer=Comparer())
template<class Selector = Identity, class Order = detail::Order<Selector, Greater>>
Order	orderByDescending (Selector selector=Selector())
template<class Selector = Identity, class GroupBy = detail::GroupBy<Selector>>
GroupBy	groupBy (Selector selector=Selector())
template<class Selector = Identity, class GroupByAdjacent = detail::GroupByAdjacent<Selector>>
GroupByAdjacent	groupByAdjacent (Selector selector=Selector())
template<class Selector = Identity, class Distinct = detail::Distinct<Selector>>
Distinct	distinctBy (Selector selector=Selector())
template<int n, class Get = detail::Map<Get<n>>>
Get	get ()
template<class Dest , class Cast = detail::Map<Cast<Dest>>>
Cast	eachAs ()
template<class Dest , class EachTo = detail::Map<To<Dest>>>
EachTo	eachTo ()
template<class Dest , class EachTryTo = detail::Map<TryTo<Dest>>>
EachTryTo	eachTryTo ()
template<class Value >
detail::TypeAssertion< Value >	assert_type ()
template<class Predicate = Identity, class Filter = detail::Filter<Predicate>, class NotEmpty = detail::IsEmpty<false>, class Composed = detail::Composed<Filter, NotEmpty>>
Composed	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	all (Predicate pred=Predicate())
template<class Seed , class Fold , class FoldLeft = detail::FoldLeft<Seed, Fold>>
FoldLeft	foldl (Seed seed=Seed(), Fold fold=Fold())
template<class Reducer , class Reduce = detail::Reduce<Reducer>>
Reduce	reduce (Reducer reducer=Reducer())
template<class Selector = Identity, class Min = detail::Min<Selector, Less>>
Min	minBy (Selector selector=Selector())
template<class Selector , class MaxBy = detail::Min<Selector, Greater>>
MaxBy	maxBy (Selector selector=Selector())
template<class Collection , class Collect = detail::Collect<Collection>>
Collect	as ()
template<template< class, class > class Container = std::vector, template< class > class Allocator = std::allocator, class Collect = detail::CollectTemplate<Container, Allocator>>
Collect	as ()
template<class Collection , class Append = detail::Append<Collection>>
Append	appendTo (Collection &collection)
template<class Needle , class Contains = detail::Contains<typename std::decay<Needle>::type>>
Contains	contains (Needle &&needle)
template<class Exception , class ErrorHandler , class GuardImpl = detail::GuardImpl<Exception, typename std::decay<ErrorHandler>::type>>
GuardImpl	guard (ErrorHandler &&handler)
template<class Fallback , class UnwrapOr = detail::UnwrapOr<typename std::decay<Fallback>::type>>
UnwrapOr	unwrapOr (Fallback &&fallback)
template<class Source , class Zip = detail::Zip<typename std::decay<Source>::type>>
Zip	zip (Source &&source)
template<class Source2 , class Source2Decayed = typename std::decay<Source2>::type, class Interleave = detail::Interleave<Source2Decayed>>
Interleave	interleave (Source2 &&source2)
template<class Left , class Right , class Composed = detail::Composed<Left, Right>>
Composed	operator| (const Operator< Left > &left, const Operator< Right > &right)
template<class Left , class Right , class Composed = detail::Composed<Left, Right>>
Composed	operator| (const Operator< Left > &left, Operator< Right > &&right)
template<class Left , class Right , class Composed = detail::Composed<Left, Right>>
Composed	operator| (Operator< Left > &&left, const Operator< Right > &right)
template<class Left , class Right , class Composed = detail::Composed<Left, Right>>
Composed	operator| (Operator< Left > &&left, Operator< Right > &&right)
template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>
Chain	operator+ (const GenImpl< LeftValue, Left > &left, const GenImpl< RightValue, Right > &right)
template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>
Chain	operator+ (const GenImpl< LeftValue, Left > &left, GenImpl< RightValue, Right > &&right)
template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>
Chain	operator+ (GenImpl< LeftValue, Left > &&left, const GenImpl< RightValue, Right > &right)
template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>
Chain	operator+ (GenImpl< LeftValue, Left > &&left, GenImpl< RightValue, Right > &&right)
template<class Value , class Gen , class Handler >
std::enable_if< IsCompatibleSignature< Handler, void(Value)>::value >::type	operator| (const GenImpl< Value, Gen > &gen, Handler &&handler)
template<class Value , class Gen , class Handler >
std::enable_if< IsCompatibleSignature< Handler, bool(Value)>::value, bool >::type	operator| (const GenImpl< Value, Gen > &gen, Handler &&handler)
template<class Value , class Gen , class Op >
auto	operator| (const GenImpl< Value, Gen > &gen, const Operator< Op > &op) -> decltype(op.self().compose(gen.self()))
template<class Value , class Gen , class Op >
auto	operator| (GenImpl< Value, Gen > &&gen, const Operator< Op > &op) -> decltype(op.self().compose(std::move(gen.self())))
auto	byLineFull (File file, char delim= '\n')
auto	byLineFull (int fd, char delim= '\n')
auto	byLineFull (const char *f, char delim= '\n')
auto	byLine (File file, char delim= '\n')
auto	byLine (int fd, char delim= '\n')
auto	byLine (const char *f, char delim= '\n')
template<class S = detail::FileReader>
S	fromFile (File file, size_t bufferSize=4096)
template<class S = detail::FileReader>
S	fromFile (File file, std::unique_ptr< IOBuf > buffer)
template<class S = detail::FileWriter>
S	toFile (File file, size_t bufferSize=4096)
template<class S = detail::FileWriter>
S	toFile (File file, std::unique_ptr< IOBuf > buffer)
detail::IStreamByLine	byLine (std::istream &in)
template<class Container , class Iterator = typename Container::const_iterator, class Chunked = detail::ChunkedRangeSource<Iterator>>
Chunked	chunked (const Container &container, int chunkSize=256)
template<class Container , class Iterator = typename Container::iterator, class Chunked = detail::ChunkedRangeSource<Iterator>>
Chunked	chunked (Container &container, int chunkSize=256)
template<class Ops , class Parallel = detail::Parallel<Ops>>
Parallel	parallel (Ops ops, size_t threads=0)
template<class Sink , class Sub = detail::Sub<Sink>>
Sub	sub (Sink sink)
template<class Predicate , class PMap = detail::PMap<Predicate>>
PMap	pmap (Predicate pred=Predicate(), size_t nThreads=0)
template<class S = detail::StringResplitter>
S	resplit (char delimiter, bool keepDelimiter=false)
template<class S = detail::SplitStringSource<char>>
S	split (const StringPiece source, char delimiter)
template<class S = detail::SplitStringSource<StringPiece>>
S	split (StringPiece source, StringPiece delimiter)
template<class S = detail::SplitStringSource<MixedNewlines>>
S	lines (StringPiece source)
template<class Output = folly::fbstring, class Delimiter , class Unsplit = detail::Unsplit<Delimiter, Output>>
Unsplit	unsplit (const Delimiter &delimiter)
template<class Output = folly::fbstring, class Unsplit = detail::Unsplit<fbstring, Output>>
Unsplit	unsplit (const char *delimiter)
template<class Delimiter , class OutputBuffer , class UnsplitBuffer = detail::UnsplitBuffer<Delimiter, OutputBuffer>>
UnsplitBuffer	unsplit (Delimiter delimiter, OutputBuffer *outputBuffer)
template<class OutputBuffer , class UnsplitBuffer = detail::UnsplitBuffer<fbstring, OutputBuffer>>
UnsplitBuffer	unsplit (const char *delimiter, OutputBuffer *outputBuffer)
template<class... Targets>
detail::Map< detail::SplitTo< std::tuple< Targets... >, char, Targets... > >	eachToTuple (char delim)
template<class... Targets>
detail::Map< detail::SplitTo< std::tuple< Targets... >, fbstring, Targets... > >	eachToTuple (StringPiece delim)
template<class First , class Second >
detail::Map< detail::SplitTo< std::pair< First, Second >, char, First, Second > >	eachToPair (char delim)
template<class First , class Second >
detail::Map< detail::SplitTo< std::pair< First, Second >, fbstring, First, Second > >	eachToPair (StringPiece delim)
template<class Callback >
StreamSplitter< Callback >	streamSplitter (char delimiter, Callback &&pieceCb, uint64_t capacity=0)
	TEST (IStream, ByLine)

Variables
constexpr detail::Sum	sum {}
constexpr detail::Count	count {}
constexpr detail::First	first {}
constexpr detail::IsEmpty< true >	isEmpty {}
constexpr detail::IsEmpty< false >	notEmpty {}
constexpr detail::Min< Identity, Less >	min {}
constexpr detail::Min< Identity, Greater >	max {}
constexpr detail::Order< Identity >	order {}
constexpr detail::Distinct< Identity >	distinct {}
constexpr detail::Map< Move >	move {}
constexpr detail::Concat	concat {}
constexpr detail::RangeConcat	rconcat {}
constexpr detail::Cycle< true >	cycle {}
constexpr detail::Dereference	dereference {}
constexpr detail::Indirect	indirect {}
constexpr detail::Unwrap	unwrap {}

Enumeration Type Documentation

enum folly::gen::MemberType

Enumerator
Const
Mutable

Definition at line 575 of file Base.h.

                {
  Const,
  Mutable,
};

Function Documentation

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()

)

all() - For determining whether all values in a sequence satisfy a predicate.

The following is an example for checking if all members of a team are cool:

bool isAwesomeTeam = from(team) | all(isCool);

Note that if no predicate is provided, 'all()'' checks if all of the values are true when cased to bool. The following makes sure none of 'pointers' are nullptr:

bool allNonNull = from(pointers) | all();

Note: Passing an empty sequence through 'all()' will always return true. In fact, 'all()' is equivilent to the composition of 'filter()' with the reversed predicate and 'isEmpty'.

from(source) | all(pred) == from(source) | filter(negate(pred)) | isEmpty

Definition at line 786 of file Base.h.

References move, and negate().

Referenced by proxygen::QPACKEncoder::allowVulnerable(), cmake_minimum_required(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::Pusher< all >::compose(), proxygen::HTTP2PriorityQueue::iterate(), proxygen::HTTP2PriorityQueue::iterateBFS(), proxygen::QPACKEncoder::onHeaderAck(), option(), set(), TEST(), and folly::exception_wrapper::with_exception_().

                                           {
  return Composed(Filter(std::move(negate(pred))), IsEmpty());
}

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()

)

any() - For determining if any value in a sequence satisfies a predicate.

The following is an example for checking if any computer is broken:

bool schrepIsMad = from(computers) | any(isBroken);

(because everyone knows Schrep hates broken computers).

Note that if no predicate is provided, 'any()' checks if any of the values are true when cased to bool. To check if any of the scores are nonZero:

bool somebodyScored = from(scores) | any();

Note: Passing an empty sequence through 'any()' will always return false. In fact, 'any()' is equivilent to the composition of 'filter()' and 'notEmpty'.

from(source) | any(pred) == from(source) | filter(pred) | notEmpty

Definition at line 758 of file Base.h.

References move.

Referenced by deadlock::is_thread_blocked_with_frame(), and TEST().

                                           {
  return Composed(Filter(std::move(pred)), NotEmpty());
}

template<class Collection , class Append = detail::Append<Collection>>

Append folly::gen::appendTo

(

Collection &

collection

)

Definition at line 824 of file Base.h.

References testing::Contains().

Referenced by BENCHMARK_RELATIVE(), folly::BaseFormatter< Formatter< containerMode, Args... >, containerMode, Args... >::fbstr(), folly::BaseFormatter< Formatter< containerMode, Args... >, containerMode, Args... >::str(), and TEST().

                                        {
  return Append(&collection);
}

template<class Collection , class Collect = detail::Collect<Collection>>

Collect folly::gen::as

(

)

Definition at line 811 of file Base.h.

Referenced by folly::fibers::StackCache::borrow(), folly::exception_wrapper::Buffer::Buffer(), folly::exception_wrapper::exception_wrapper(), folly::fibers::StackCache::giveBack(), folly::exception_wrapper::SharedPtr::Impl< Ex >::Impl(), folly::make_exception_wrapper(), folly::poly_call(), folly::detail::partial::Partial< F, Tuple >::std::declval(), folly::detail::SynchronizedLocker< Synchronized, LockFunc, TryLockFunc, Args >::SynchronizedLocker(), TEST(), folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::try_lock_for(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::try_lock_until().

             {
  return Collect();
}

template<template< class, class > class Container = std::vector, template< class > class Allocator = std::allocator, class Collect = detail::CollectTemplate<Container, Allocator>>

Collect folly::gen::as

(

)

Definition at line 819 of file Base.h.

             {
  return Collect();
}

template<class Value >

detail::TypeAssertion<Value> folly::gen::assert_type

(

)

Definition at line 725 of file Base.h.

Referenced by TEST().

                                         {
  return {};
}

detail::Batch folly::gen::batch ( size_t  batchSize )

inline

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

Referenced by doubleBatchInnerDispatch(), doubleBatchOuterDispatch(), singleBatchDispatch(), and TEST().

                                           {
  return detail::Batch(batchSize);
}

detail::IStreamByLine folly::gen::byLine ( std::istream &  in )

inline

Definition at line 54 of file IStream.h.

                                                  {
  return detail::IStreamByLine(in);
}

auto folly::gen::byLine ( File  file, char  delim = '\n'  )

inline

Definition at line 148 of file File-inl.h.

References folly::gen::detail::byLineImpl(), and move.

Referenced by BENCHMARK(), byLine(), TEST(), TEST(), and TEST_P().

                                                 {
  return detail::byLineImpl(std::move(file), delim, false);
}

auto folly::gen::byLine ( int  fd, char  delim = '\n'  )

inline

Definition at line 152 of file File-inl.h.

References byLine().

                                              {
  return byLine(File(fd), delim);
}

auto folly::gen::byLine ( const char *  f, char  delim = '\n'  )

inline

Definition at line 156 of file File-inl.h.

References byLine().

                                                     {
  return byLine(File(f), delim);
}

auto folly::gen::byLineFull ( File  file, char  delim = '\n'  )

inline

Generator which reads lines from a file. Note: This produces StringPieces which reference temporary strings which are only valid during iteration.

Definition at line 136 of file File-inl.h.

References folly::gen::detail::byLineImpl(), and move.

Referenced by byLineFull(), and TEST().

                                                     {
  return detail::byLineImpl(std::move(file), delim, true);
}

auto folly::gen::byLineFull ( int  fd, char  delim = '\n'  )

inline

Definition at line 140 of file File-inl.h.

References byLineFull().

                                                  {
  return byLineFull(File(fd), delim);
}

auto folly::gen::byLineFull ( const char *  f, char  delim = '\n'  )

inline

Definition at line 144 of file File-inl.h.

References byLineFull().

                                                         {
  return byLineFull(File(f), delim);
}

template<class Container , class Iterator = typename Container::const_iterator, class Chunked = detail::ChunkedRangeSource<Iterator>>

Chunked folly::gen::chunked	(	const Container &	container,
		int	chunkSize = 256
	)

chunked() - For producing values from a container in slices.

Especially for use with 'parallel()', chunked can be used to process values from a persistent container in chunks larger than one value at a time. The values produced are generators for slices of the input container.

Definition at line 49 of file Parallel.h.

References folly::range().

Referenced by fizz::test::chunkIOBuf(), proxygen::ResponseBuilder::send(), and proxygen::HTTPMessage::setIsChunked().

                                                                 {
  return Chunked(chunkSize, folly::range(container.begin(), container.end()));
}

template<class Container , class Iterator = typename Container::iterator, class Chunked = detail::ChunkedRangeSource<Iterator>>

Chunked folly::gen::chunked	(	Container &	container,
		int	chunkSize = 256
	)

Definition at line 57 of file Parallel.h.

References folly::range().

                                                           {
  return Chunked(chunkSize, folly::range(container.begin(), container.end()));
}

template<class Needle , class Contains = detail::Contains<typename std::decay<Needle>::type>>

Contains folly::gen::contains

(

Needle &&

needle

)

Definition at line 831 of file Base.h.

References testing::Contains(), and needle.

Referenced by folly::ConcurrentSkipList< T, Comp, NodeAlloc, MAX_HEIGHT >::Accessor::count(), and TEST().

                                   {
  return Contains(std::forward<Needle>(needle));
}

template<class Selector = Identity, class Distinct = detail::Distinct<Selector>>

Distinct folly::gen::distinctBy

(

Selector

selector = Selector()

)

Definition at line 697 of file Base.h.

References move.

Referenced by TEST().

                                                    {
  return Distinct(std::move(selector));
}

template<class Dest , class Cast = detail::Map<Cast<Dest>>>

Cast folly::gen::eachAs

(

)

Definition at line 708 of file Base.h.

              {
  return Cast();
}

template<class Dest , class EachTo = detail::Map<To<Dest>>>

EachTo folly::gen::eachTo

(

)

Definition at line 714 of file Base.h.

                {
  return EachTo();
}

template<class First , class Second >

detail::Map<detail::SplitTo<std::pair<First, Second>, char, First, Second> > folly::gen::eachToPair

(

char

delim

)

Definition at line 158 of file String.h.

                       {
  return detail::Map<
      detail::SplitTo<std::pair<First, Second>, char, First, Second>>(
      detail::SplitTo<std::pair<First, Second>, char, First, Second>(delim));
}

template<class First , class Second >

detail::Map<detail::SplitTo<std::pair<First, Second>, fbstring, First, Second> > folly::gen::eachToPair

(

StringPiece

delim

)

Definition at line 166 of file String.h.

                              {
  return detail::Map<
      detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>>(
      detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>(
          to<fbstring>(delim)));
}

template<class... Targets>

detail::Map<detail::SplitTo<std::tuple<Targets...>, char, Targets...> > folly::gen::eachToTuple

(

char

delim

)

Definition at line 143 of file String.h.

                        {
  return detail::Map<detail::SplitTo<std::tuple<Targets...>, char, Targets...>>(
      detail::SplitTo<std::tuple<Targets...>, char, Targets...>(delim));
}

template<class... Targets>

detail::Map<detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...> > folly::gen::eachToTuple

(

StringPiece

delim

)

Definition at line 150 of file String.h.

                               {
  return detail::Map<
      detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>>(
      detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>(delim));
}

template<class Dest , class EachTryTo = detail::Map<TryTo<Dest>>>

EachTryTo folly::gen::eachTryTo

(

)

Definition at line 720 of file Base.h.

                      {
  return EachTryTo();
}

template<class Value >

detail::Empty<Value> folly::gen::empty

(

)

Definition at line 522 of file Base.h.

References type, value, and testing::Value().

Referenced by TEST().

                           {
  return {};
}

template<class Class , class FieldType , class Field = Field<Class, FieldType>, class Map = detail::Map<Field>>

Map folly::gen::field

(

FieldType Class::*

field

)

Definition at line 641 of file Base.h.

References testing::Field().

Referenced by proxygen::HTTPMessage::describe(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and TEST().

                                 {
  return Map(Field(field));
}

template<class Predicate = Identity, class Filter = detail::Filter<Predicate>>

Filter folly::gen::filter

(

Predicate

pred = Predicate()

)

Definition at line 646 of file Base.h.

References move.

Referenced by BENCHMARK_RELATIVE(), and TEST().

                                            {
  return Filter(std::move(pred));
}

template<class Seed , class Fold , class FoldLeft = detail::FoldLeft<Seed, Fold>>

FoldLeft folly::gen::foldl	(	Seed	seed = Seed(),
		Fold	fold = Fold()
	)

Definition at line 791 of file Base.h.

References folly::exception_wrapper_detail::fold(), move, and seed.

Referenced by folly::gen::detail::Count::compose(), folly::gen::detail::Sum::compose(), and TEST().

                                                       {
  return FoldLeft(std::move(seed), std::move(fold));
}

template<class Container , class From = detail::ReferencedSource<Container>>

From folly::gen::from

(

Container &

source

)

Definition at line 438 of file Base.h.

References testing::Value().

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), operator<<(), StringUnsplit_Gen(), TEST(), and TEST_P().

                             {
  return From(&source);
}

template<class Value , class From = detail::CopiedSource<Value>>

From folly::gen::from

(

std::initializer_list< Value >

source

)

Definition at line 451 of file Base.h.

                                             {
  return From(source);
}

template<class Container , class From = detail::CopiedSource<typename Container::value_type, Container>>

From folly::gen::from

(

Container &&

source

)

Definition at line 459 of file Base.h.

References move, and testing::Value().

                              {
  return From(std::move(source));
}

template<class Container , class From = detail::ReferencedSource<const Container>>

From folly::gen::fromConst

(

const Container &

source

)

Definition at line 433 of file Base.h.

Referenced by TEST().

                                        {
  return From(&source);
}

template<class Container , class Value = typename detail::ValueTypeOfRange<Container>::StorageType, class CopyOf = detail::CopiedSource<Value>>

CopyOf folly::gen::fromCopy

(

Container &&

source

)

Definition at line 446 of file Base.h.

Referenced by TEST().

                                    {
  return CopyOf(std::forward<Container>(source));
}

template<class S = detail::FileReader>

S folly::gen::fromFile	(	File	file,
		size_t	bufferSize = 4096
	)

Generator that reads from a file with a buffer of the given size. Reads must be buffered (the generator interface expects the generator to hold each value).

Definition at line 38 of file File.h.

References folly::IOBuf::create(), and move.

Referenced by folly::gen::detail::byLineImpl(), and proxygen::compress::CompressionSimulator::readInputFromFileAndSchedule().

                                                {
  return S(std::move(file), IOBuf::create(bufferSize));
}

template<class S = detail::FileReader>

S folly::gen::fromFile	(	File	file,
		std::unique_ptr< IOBuf >	buffer
	)

Generator that reads from a file using a given buffer.

Definition at line 46 of file File.h.

References move.

                                                   {
  return S(std::move(file), std::move(buffer));
}

template<class Value , class Source , class Yield = detail::Yield<Value, Source>>

Yield folly::gen::generator

(

Source &&

source

)

Definition at line 506 of file Base.h.

                                 {
  return Yield(std::forward<Source>(source));
}

template<int n, class Get = detail::Map<Get<n>>>

Get folly::gen::get

(

)

Definition at line 702 of file Base.h.

          {
  return Get();
}

template<class Selector = Identity, class GroupBy = detail::GroupBy<Selector>>

GroupBy folly::gen::groupBy

(

Selector

selector = Selector()

)

Definition at line 683 of file Base.h.

References move.

Referenced by TEST().

                                                {
  return GroupBy(std::move(selector));
}

template<class Selector = Identity, class GroupByAdjacent = detail::GroupByAdjacent<Selector>>

GroupByAdjacent folly::gen::groupByAdjacent

(

Selector

selector = Selector()

)

Definition at line 690 of file Base.h.

References move.

Referenced by TEST().

                                                                {
  return GroupByAdjacent(std::move(selector));
}

template<class Exception , class ErrorHandler , class GuardImpl = detail::GuardImpl<Exception, typename std::decay<ErrorHandler>::type>>

GuardImpl folly::gen::guard

(

ErrorHandler &&

handler

)

Definition at line 840 of file Base.h.

References handler().

Referenced by folly::ThreadPoolExecutor::StoppedThreadQueue::add(), wangle::SSLContextManager::addSSLContextConfig(), folly::SharedMutexImpl< true >::annotateLazyCreate(), folly::IOBufQueue::append(), folly::python::bridgeFibers(), folly::python::bridgeFuture(), folly::IOBufQueue::clear(), wangle::ContextImpl< H >::close(), wangle::OutboundContextImpl< H >::close(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::copy(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), proxygen::HTTPSession::detach(), wangle::Observable< T, InlineObservers >::Unsubscriber::disable(), folly::pushmi::subject< PS, TN... >::subject_shared::done(), folly::pushmi::strand_queue< E, Executor >::done(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::done(), folly::fibers::TimedRWMutex< BatonType >::downgrade(), folly::errnoStr(), folly::pushmi::subject< PS, TN... >::subject_shared::error(), folly::pushmi::strand_queue< E, Executor >::error(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::error(), wangle::ContextImpl< H >::fireClose(), wangle::OutboundContextImpl< H >::fireClose(), wangle::ContextImpl< H >::fireRead(), wangle::InboundContextImpl< H >::fireRead(), wangle::ContextImpl< H >::fireReadEOF(), wangle::InboundContextImpl< H >::fireReadEOF(), wangle::ContextImpl< H >::fireReadException(), wangle::InboundContextImpl< H >::fireReadException(), wangle::ContextImpl< H >::fireTransportActive(), wangle::InboundContextImpl< H >::fireTransportActive(), wangle::ContextImpl< H >::fireTransportInactive(), wangle::InboundContextImpl< H >::fireTransportInactive(), wangle::ContextImpl< H >::fireWrite(), wangle::OutboundContextImpl< H >::fireWrite(), wangle::ContextImpl< H >::fireWriteException(), wangle::OutboundContextImpl< H >::fireWriteException(), folly::IOBufQueue::gather(), wangle::SSLUtil::getSubjectAltName(), wangle::SSLContextManager::insert(), folly::pushmi::time_source_shared< E, time_point >::insert(), folly::pushmi::time_source_shared< E, time_point >::join(), wangle::Observable< T >::makeSubscription(), folly::IOBufQueue::move(), proxygen::HTTPTransaction::notifyTransportPendingEgress(), folly::symbolizer::ElfFile::openNoThrow(), folly::pushmi::detail::blocking_submit_fn::on_value_impl::operator()(), folly::pushmi::detail::blocking_submit_fn::on_error_impl::operator()(), folly::pushmi::detail::blocking_submit_fn::on_done_impl::operator()(), folly::pushmi::detail::blocking_submit_fn::fn< AN >::operator()(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::operator=(), folly::DynamicParser::parse(), folly::IOBufQueue::pop_front(), folly::DynamicParser::ParserStack::push(), FileServerHandler::read(), wangle::ContextImpl< H >::read(), wangle::InboundContextImpl< H >::read(), wangle::ContextImpl< H >::readEOF(), proxygen::HTTPSession::readEOF(), wangle::InboundContextImpl< H >::readEOF(), proxygen::HTTPSession::readErr(), wangle::ContextImpl< H >::readException(), wangle::InboundContextImpl< H >::readException(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestNoFC(), folly::ThreadLocalPtr< SubscriberMap >::reset(), proxygen::HTTPTransaction::sendBody(), folly::threadlocal_detail::ElementWrapper::set(), folly::DestructorCheck::ForwardLink::setAllDestroyed(), proxygen::HTTPSession::shutdownTransport(), proxygen::HTTPSession::shutdownTransportWithReset(), folly::ThreadPoolExecutor::StoppedThreadQueue::size(), folly::IOBufQueue::split(), folly::AsyncSSLSocket::sslAccept(), proxygen::WorkerThread::start(), folly::IOThreadPoolExecutor::stopThreads(), folly::pushmi::subject< PS, TN... >::subject_shared::submit(), folly::pushmi::strand_executor< E, Executor >::submit(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::swap(), folly::ThreadPoolExecutor::StoppedThreadQueue::take(), TEST(), TEST_F(), testFinally(), testUndoAction(), folly::IOThreadPoolExecutor::threadRun(), folly::fibers::TimedRWMutex< BatonType >::timed_read_lock(), folly::fibers::TimedRWMutex< BatonType >::timed_write_lock(), wangle::ContextImpl< H >::transportActive(), wangle::InboundContextImpl< H >::transportActive(), wangle::ContextImpl< H >::transportInactive(), wangle::InboundContextImpl< H >::transportInactive(), folly::IOBufQueue::trimEndAtMost(), folly::IOBufQueue::trimStartAtMost(), folly::fibers::TimedRWMutex< BatonType >::try_read_lock(), folly::ThreadPoolExecutor::StoppedThreadQueue::try_take_for(), folly::fibers::TimedRWMutex< BatonType >::try_write_lock(), folly::fibers::TimedRWMutex< BatonType >::unlock(), wangle::Observable< T, InlineObservers >::Unsubscriber::unsubscribe(), folly::pushmi::subject< PS, TN... >::subject_shared::value(), folly::pushmi::strand_queue< E, Executor >::value(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::value(), virtualExecutorTest(), proxygen::WorkerThread::wait(), folly::pushmi::time_source_shared< E, time_point >::worker(), wangle::ContextImpl< H >::write(), wangle::OutboundContextImpl< H >::write(), wangle::ContextImpl< H >::writeException(), and wangle::OutboundContextImpl< H >::writeException().

                                        {
  return GuardImpl(std::forward<ErrorHandler>(handler));
}

template<class Source2 , class Source2Decayed = typename std::decay<Source2>::type, class Interleave = detail::Interleave<Source2Decayed>>

Interleave folly::gen::interleave

(

Source2 &&

source2

)

Definition at line 38 of file Combine.h.

Referenced by TEST().

                                         {
  return Interleave(std::forward<Source2>(source2));
}

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

)

Definition at line 532 of file Base.h.

References folly::value().

Referenced by TEST().

                         {
  return Just(std::forward<Value>(value));
}

template<class S = detail::SplitStringSource<MixedNewlines>>

S folly::gen::lines

(

StringPiece

source

)

Split by EOL ("\r", "\n", or "\r\n").

See also

split().

Definition at line 80 of file String.h.

References folly::Delimiter.

Referenced by testing::internal::edit_distance::CreateUnifiedDiff(), getline(), Lines_Gen(), testing::internal::ParseGoogleTestFlag(), readNote(), folly::test::run_test(), TEST(), and TEST_P().

                            {
  return S(source, MixedNewlines{});
}

template<class Predicate , class Map = detail::Map<Predicate>>

Map folly::gen::map

(

Predicate

pred = Predicate()

)

Definition at line 545 of file Base.h.

References move.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), TEST(), and TEST_F().

                                      {
  return Map(std::move(pred));
}

template<class Operator , class Map = detail::Map<detail::Composer<Operator>>>

Map folly::gen::mapOp

(

Operator

op

)

mapOp - Given a generator of generators, maps the application of the given operator on to each inner gen. Especially useful in aggregating nested data structures:

chunked(samples, 256) | mapOp(filter(sampleTest) | count) | sum;

Definition at line 559 of file Base.h.

References move.

Referenced by TEST().

                       {
  return Map(detail::Composer<Operator>(std::move(op)));
}

template<class Predicate , class Map = detail::Map<Predicate>>

Map folly::gen::mapped

(

Predicate

pred = Predicate()

)

Definition at line 540 of file Base.h.

References move.

Referenced by BENCHMARK_RELATIVE(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::insertInternal(), TEST(), and TEST_P().

                                         {
  return Map(std::move(pred));
}

template<class Selector , class MaxBy = detail::Min<Selector, Greater>>

MaxBy folly::gen::maxBy

(

Selector

selector = Selector()

)

Definition at line 806 of file Base.h.

References move.

Referenced by TEST().

                                            {
  return MaxBy(std::move(selector));
}

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::*)() const

member

)

Definition at line 605 of file Base.h.

References Mutable, and testing::Return().

Referenced by BENCHMARK(), TEST(), and TEST_F().

                                   {
  return Map(Mem(member));
}

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

)

Definition at line 616 of file Base.h.

                             {
  return Map(Mem(member));
}

template<class Selector = Identity, class Min = detail::Min<Selector, Less>>

Min folly::gen::minBy

(

Selector

selector = Selector()

)

Definition at line 801 of file Base.h.

References move.

Referenced by TEST().

                                          {
  return Min(std::move(selector));
}

template<class Predicate >

Negate<Predicate> folly::gen::negate

(

Predicate

pred

)

Definition at line 217 of file Base.h.

References move.

Referenced by all(), and TEST().

                                         {
  return Negate<Predicate>(std::move(pred));
}

template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>

Chain folly::gen::operator+	(	const GenImpl< LeftValue, Left > &	left,
		const GenImpl< RightValue, Right > &	right
	)

Definition at line 200 of file Core-inl.h.

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

                                             {
  static_assert(
      std::is_same<LeftValue, RightValue>::value,
      "Generators may ony be combined if Values are the exact same type.");
  return Chain(left.self(), right.self());
}

template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>

Chain folly::gen::operator+	(	const GenImpl< LeftValue, Left > &	left,
		GenImpl< RightValue, Right > &&	right
	)

Definition at line 215 of file Core-inl.h.

References move, folly::gen::FBounded< Self >::self(), and value.

                                        {
  static_assert(
      std::is_same<LeftValue, RightValue>::value,
      "Generators may ony be combined if Values are the exact same type.");
  return Chain(left.self(), std::move(right.self()));
}

template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>

Chain folly::gen::operator+	(	GenImpl< LeftValue, Left > &&	left,
		const GenImpl< RightValue, Right > &	right
	)

Definition at line 230 of file Core-inl.h.

References move, folly::gen::FBounded< Self >::self(), and value.

                                             {
  static_assert(
      std::is_same<LeftValue, RightValue>::value,
      "Generators may ony be combined if Values are the exact same type.");
  return Chain(std::move(left.self()), right.self());
}

template<class LeftValue , class Left , class RightValue , class Right , class Chain = detail::Chain<LeftValue, Left, Right>>

Chain folly::gen::operator+	(	GenImpl< LeftValue, Left > &&	left,
		GenImpl< RightValue, Right > &&	right
	)

Definition at line 245 of file Core-inl.h.

References move, type, and value.

                                        {
  static_assert(
      std::is_same<LeftValue, RightValue>::value,
      "Generators may ony be combined if Values are the exact same type.");
  return Chain(std::move(left.self()), std::move(right.self()));
}

template<class Left , class Right , class Composed = detail::Composed<Left, Right>>

Composed folly::gen::operator|	(	const Operator< Left > &	left,
		const Operator< Right > &	right
	)

operator|() - For composing two operators without binding it to a particular generator.

Definition at line 111 of file Core-inl.h.

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

                                                                             {
  return Composed(left.self(), right.self());
}

template<class Left , class Right , class Composed = detail::Composed<Left, Right>>

Composed folly::gen::operator|	(	const Operator< Left > &	left,
		Operator< Right > &&	right
	)

Definition at line 119 of file Core-inl.h.

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

                                                                        {
  return Composed(left.self(), std::move(right.self()));
}

template<class Left , class Right , class Composed = detail::Composed<Left, Right>>

Composed folly::gen::operator|	(	Operator< Left > &&	left,
		const Operator< Right > &	right
	)

Definition at line 127 of file Core-inl.h.

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

                                                                        {
  return Composed(std::move(left.self()), right.self());
}

template<class Left , class Right , class Composed = detail::Composed<Left, Right>>

Composed folly::gen::operator|	(	Operator< Left > &&	left,
		Operator< Right > &&	right
	)

Definition at line 135 of file Core-inl.h.

References move.

                                                                   {
  return Composed(std::move(left.self()), std::move(right.self()));
}

template<class Value , class Gen , class Handler >

std::enable_if< IsCompatibleSignature<Handler, void(Value)>::value>::type folly::gen::operator|	(	const GenImpl< Value, Gen > &	gen,
		Handler &&	handler
	)

operator|() which enables foreach-like usage: gen | [](Value v) -> void {...};

Definition at line 261 of file Core-inl.h.

References handler(), folly::gen::FBounded< Self >::self(), type, and value.

                                                             {
  static_assert(
      !Gen::infinite, "Cannot pull all values from an infinite sequence.");
  gen.self().foreach(std::forward<Handler>(handler));
}

template<class Value , class Gen , class Handler >

std:: enable_if<IsCompatibleSignature<Handler, bool(Value)>::value, bool>::type folly::gen::operator|	(	const GenImpl< Value, Gen > &	gen,
		Handler &&	handler
	)

operator|() which enables foreach-like usage with 'break' support: gen | [](Value v) -> bool { return shouldContinue(); };

Definition at line 274 of file Core-inl.h.

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

                                                                 {
  return gen.self().apply(std::forward<Handler>(handler));
}

template<class Value , class Gen , class Op >

auto folly::gen::operator|	(	const GenImpl< Value, Gen > &	gen,
		const Operator< Op > &	op
	)		-> decltype(op.self().compose(gen.self()))

operator|() for composing generators with operators, similar to boosts' range adaptors: gen | map(square) | sum

Definition at line 284 of file Core-inl.h.

                                               {
  return op.self().compose(gen.self());
}

template<class Value , class Gen , class Op >

auto folly::gen::operator|	(	GenImpl< Value, Gen > &&	gen,
		const Operator< Op > &	op
	)		-> decltype(op.self().compose(std::move(gen.self())))

Definition at line 290 of file Core-inl.h.

References move.

                                                        {
  return op.self().compose(std::move(gen.self()));
}

template<class Selector = Identity, class Comparer = Less, class Order = detail::Order<Selector, Comparer>>

Order folly::gen::orderBy	(	Selector	selector = Selector(),
		Comparer	comparer = Comparer()
	)

Definition at line 671 of file Base.h.

References move.

Referenced by TEST().

                                                                              {
  return Order(std::move(selector), std::move(comparer));
}

template<class Selector = Identity, class Order = detail::Order<Selector, Greater>>

Order folly::gen::orderByDescending

(

Selector

selector = Selector()

)

Definition at line 678 of file Base.h.

References move.

Referenced by TEST().

                                                        {
  return Order(std::move(selector));
}

template<class Ops , class Parallel = detail::Parallel<Ops>>

Parallel folly::gen::parallel	(	Ops	ops,
		size_t	threads = 0
	)

parallel - A parallelization operator.

'parallel(ops)' can be used with any generator to process a segment of the pipeline in parallel. Multiple threads are used to apply the operations ('ops') to the input sequence, with the resulting sequence interleaved to be processed on the client thread.

auto scoredResults = from(ids) | parallel(map(fetchObj) | filter(isValid) | map(scoreObj)) | as<vector>();

Operators specified for parallel execution must yield sequences, not just individual values. If a sink function such as 'count' is desired, it must be wrapped in 'sub' to produce a subcount, since any such aggregation must be re-aggregated.

auto matches = from(docs) | parallel(filter(expensiveTest) | sub(count)) | sum;

Here, each thread counts its portion of the result, then the sub-counts are summed up to produce the total count.

Definition at line 88 of file Parallel.h.

References move, and threads.

Referenced by TEST().

                                               {
  return Parallel(std::move(ops), threads);
}

template<class Predicate , class PMap = detail::PMap<Predicate>>

PMap folly::gen::pmap	(	Predicate	pred = Predicate(),
		size_t	nThreads = 0
	)

Run pred in parallel in nThreads. Results are returned in the same order in which they were retrieved from the source generator (similar to map).

NOTE: Only pred is run from separate threads; the source generator and the rest of the pipeline is executed in the caller thread.

Definition at line 42 of file ParallelMap.h.

References move.

Referenced by BENCHMARK_RELATIVE(), and TEST().

                                                             {
  return PMap(std::move(pred), nThreads);
}

template<class Value , class Impl = detail::RangeImpl<Value>, class Gen = detail::Sequence<Value, Impl>>

Gen folly::gen::range	(	Value	begin,
		Value	end
	)

Definition at line 467 of file Base.h.

References move, and testing::Value().

Referenced by upload.AbstractRpcServer::_Authenticate(), cpp.gmock_class::_GenerateMocks(), pump.Output::Append(), folly::gen::detail::RangeConcat::Generator< Range, Source, InnerValue >::apply(), gtest_xml_test_utils.GTestXMLTestCase::AssertEquivalentNodes(), BENCHMARK_RELATIVE(), proxygen::ZlibStreamCompressor::compress(), proxygen::ZstdStreamDecompressor::decompress(), fizz::tool::fizzServerCommand(), folly::gen::detail::RangeConcat::Generator< Range, Source, InnerValue >::foreach(), testing::internal::Random::Generate(), testing::GetDefaultFilter(), fizz::CertUtils::makePeerCert(), cpp.ast::next(), gen_gtest_pred_impl::OneTo(), random(), testing::internal::Random::Reseed(), cpp.ast::reversed(), gtest_filter_unittest.GTestFilterUnitTest::RunAndVerifyWithSharding(), pump::RunAtomicCode(), serverTest(), TEST(), TEST_F(), fizz::server::test::TEST_F(), and fizz::client::test::TEST_F().

                                  {
  return Gen{std::move(begin), Impl{std::move(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
	)

Definition at line 476 of file Base.h.

References move, and testing::Value().

                                                 {
  return Gen{std::move(begin), Impl{std::move(end), std::move(step)}};
}

template<class Reducer , class Reduce = detail::Reduce<Reducer>>

Reduce folly::gen::reduce

(

Reducer

reducer = Reducer()

)

Definition at line 796 of file Base.h.

References move.

Referenced by TEST().

                                           {
  return Reduce(std::move(reducer));
}

template<class S = detail::StringResplitter>

S folly::gen::resplit	(	char	delimiter,
		bool	keepDelimiter = false
	)

Split the output from a generator into StringPiece "lines" delimited by the given delimiter. Delimters are NOT included in the output.

resplit() behaves as if the input strings were concatenated into one long string and then split.

Equivalently, you can use StreamSplitter outside of a folly::gen setting.

Definition at line 56 of file String.h.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), folly::gen::detail::byLineImpl(), TEST(), and TEST_P().

                                                      {
  return S(delimiter, keepDelimiter);
}

template<class Random = std::default_random_engine>

detail::Sample<Random> folly::gen::sample ( size_t  count, Random  rng = Random()  )

inline

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

References count, move, and rng.

Referenced by BENCHMARK(), and TEST().

                                                                        {
  return detail::Sample<Random>(count, std::move(rng));
}

template<class Value , class Impl = detail::SeqImpl<Value>, class Gen = detail::Sequence<Value, Impl>>

Gen folly::gen::seq	(	Value	first,
		Value	last
	)

Definition at line 484 of file Base.h.

References move, and testing::Value().

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), folly::for_each_detail::for_each_tuple_impl(), run_mt_sequencer_test(), folly::ManualExecutor::ScheduledFunc::ScheduledFunc(), TEST(), fizz::server::test::TEST_F(), and TYPED_TEST().

                                 {
  return Gen{std::move(first), Impl{std::move(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
	)

Definition at line 493 of file Base.h.

References move, and testing::Value().

                                                {
  return Gen{std::move(first), Impl{std::move(last), std::move(step)}};
}

template<class Value , class Impl = detail::InfiniteImpl<Value>, class Gen = detail::Sequence<Value, Impl>>

Gen folly::gen::seq

(

Value

first

)

Definition at line 501 of file Base.h.

References move.

                     {
  return Gen{std::move(first), Impl{}};
}

detail::Skip folly::gen::skip ( size_t  count )

inline

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

Referenced by folly::compression::bmSkip(), folly::compression::bmSkipTo(), folly::basic_fbstring< E, T, A, Storage >::find(), folly::RecordIOReader::Iterator::increment(), folly::compression::BitVectorReader< Encoder, Instructions, kUnchecked >::jump(), folly::compression::detail::UpperBitsReader< Encoder, Instructions, SizeType >::jump(), folly::symbolizer::SymbolizePrinter::println(), folly::qfind(), folly::io::detail::CursorBase< Derived, BufType >::readTerminatedString(), folly::io::detail::CursorBase< Derived, BufType >::readWhile(), folly::compression::detail::UpperBitsReader< Encoder, Instructions, SizeType >::skipToNext(), TEST(), and folly::utf8ToCodePoint().

                                     {
  return detail::Skip(count);
}

template<class S = detail::SplitStringSource<char>>

S folly::gen::split	(	const StringPiece	source,
		char	delimiter
	)

Definition at line 61 of file String.h.

Referenced by upload.MercurialVCS::__init__(), BENCHMARK(), BENCHMARK_RELATIVE(), deadlock::get_stacktrace(), deadlock::get_thread_info(), upload.MercurialVCS::GetBaseFile(), gtest_shuffle_test::GetTestsForAllIterations(), gen_trace_event_constants::main(), folly::gen::detail::SplitTo< TargetContainer, Delimiter, Targets >::operator()(), and TEST().

                                                  {
  return S(source, delimiter);
}

template<class S = detail::SplitStringSource<StringPiece>>

S folly::gen::split	(	StringPiece	source,
		StringPiece	delimiter
	)

Definition at line 66 of file String.h.

                                                   {
  return S(source, delimiter);
}

template<class Callback >

StreamSplitter<Callback> folly::gen::streamSplitter	(	char	delimiter,
		Callback &&	pieceCb,
		uint64_t	capacity = 0
	)

Definition at line 239 of file String.h.

References move.

Referenced by folly::gen::detail::StringResplitter::Generator< Source >::apply(), and checkResplitMaxLength().

                                                                          {
  return StreamSplitter<Callback>(delimiter, std::move(pieceCb), capacity);
}

detail::Stride folly::gen::stride ( size_t  s )

inline

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

Referenced by folly::MPMCQueue< T, Atom, true >::blockingReadWithTicket(), folly::MPMCQueue< T, Atom, true >::blockingWrite(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::computeStride(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::dequeueWithTicketBase(), folly::MPMCQueue< T, Atom, true >::enqueueWithTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::idx(), folly::MPMCQueue< T, Atom, true >::maybeUpdateFromClosed(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::readAndGetTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::readIfNotEmpty(), TEST(), folly::MPMCQueue< T, Atom, true >::tryObtainPromisedPopTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainPromisedPopTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainPromisedPopTicketUntil(), folly::MPMCQueue< T, Atom, true >::tryObtainPromisedPushTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainPromisedPushTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainPromisedPushTicketUntil(), folly::MPMCQueue< T, Atom, true >::tryObtainReadyPopTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainReadyPopTicket(), folly::MPMCQueue< T, Atom, true >::tryObtainReadyPushTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryObtainReadyPushTicket(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryReadUntil(), folly::MPMCQueue< T, Atom, true >::trySeqlockReadSection(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::tryWriteUntil(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::write(), and folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::writeIfNotFull().

                                     {
  return detail::Stride(s);
}

template<class Sink , class Sub = detail::Sub<Sink>>

Sub folly::gen::sub

(

Sink

sink

)

sub - For sub-summarization of a sequence.

'sub' can be used to apply a sink function to a generator, but wrap the single value in another generator. Note that the sink is eagerly evaluated on the input sequence.

auto sum = from(list) | sub(count) | first;

This is primarily used with 'parallel', as noted above.

Definition at line 104 of file Parallel.h.

References move, and Sub().

Referenced by folly::hazptr_obj_linked< Atom >::downgrade_link(), folly::pushmi::detail::share_fn< TN >::impl::operator()(), folly::hazptr_obj_linked< Atom >::release_link(), folly::hazptr_obj_linked< Atom >::release_ref(), and TEST().

                   {
  return Sub(std::move(sink));
}

template<class Number >

detail::Take folly::gen::take ( Number  count )

inline

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

Referenced by BENCHMARK_RELATIVE(), folly::BlockingQueue< folly::CPUThreadPoolExecutor::CPUTask >::getNumPriorities(), Lines_Gen(), TEST(), and TEST().

                                     {
  if (count < 0) {
    throw std::invalid_argument("Negative value passed to take()");
  }
  return detail::Take(static_cast<size_t>(count));
}

template<class Predicate = Identity, class TakeWhile = detail::Until<Negate<Predicate>>>

TakeWhile folly::gen::takeWhile

(

Predicate

pred = Predicate()

)

Definition at line 663 of file Base.h.

References move.

Referenced by TEST().

                                                  {
  return TakeWhile(Negate<Predicate>(std::move(pred)));
}

folly::gen::TEST	(	IStream	,
		ByLine
	)

Definition at line 32 of file IStreamTest.cpp.

References byLine(), EXPECT_EQ, and take().

                      {
  std::stringstream in(
      "2\n" // Count applies to both below groups.
      "1\tred\n"
      "3\tblue\n"
      "3.4\t5.6\t7.8\n"
      "1.1\t2.2\t3.3\n");
  size_t n;
  in >> n;
  in.get(); // Consume trailing newline
  auto colors = byLine(in) | take(n) | eachToPair<int, std::string>('\t') |
      as<std::vector>();
  auto coords = byLine(in) | take(n) | eachToTuple<float, float, float>('\t') |
      as<std::vector>();
  EXPECT_EQ(
      colors,
      (std::vector<std::pair<int, std::string>>{
          {1, "red"},
          {3, "blue"},
      }));
  EXPECT_EQ(
      coords,
      (std::vector<std::tuple<float, float, float>>({
          std::tuple<float, float, float>{3.4f, 5.6f, 7.8f},
          std::tuple<float, float, float>{1.1f, 2.2f, 3.3f},
      })));
}

template<class S = detail::FileWriter>

S folly::gen::toFile	(	File	file,
		size_t	bufferSize = 4096
	)

Sink that writes to a file with a buffer of the given size. If bufferSize is 0, writes will be unbuffered.

Definition at line 55 of file File.h.

References folly::IOBuf::create(), and move.

Referenced by TEST(), and TEST_P().

                                              {
  return S(std::move(file), bufferSize ? nullptr : IOBuf::create(bufferSize));
}

template<class S = detail::FileWriter>

S folly::gen::toFile	(	File	file,
		std::unique_ptr< IOBuf >	buffer
	)

Sink that writes to a file using a given buffer. If the buffer is nullptr, writes will be unbuffered.

Definition at line 64 of file File.h.

References move.

                                                 {
  return S(std::move(file), std::move(buffer));
}

template<class Output = folly::fbstring, class Delimiter , class Unsplit = detail::Unsplit<Delimiter, Output>>

Unsplit folly::gen::unsplit

(

const Delimiter &

delimiter

)

Definition at line 101 of file String.h.

Referenced by BENCHMARK_RELATIVE(), StringUnsplit_Gen(), and TEST().

                                            {
  return Unsplit(delimiter);
}

template<class Output = folly::fbstring, class Unsplit = detail::Unsplit<fbstring, Output>>

Unsplit folly::gen::unsplit

(

const char *

delimiter

)

Definition at line 108 of file String.h.

References folly::Delimiter.

                                       {
  return Unsplit(delimiter);
}

template<class Delimiter , class OutputBuffer , class UnsplitBuffer = detail::UnsplitBuffer<Delimiter, OutputBuffer>>

UnsplitBuffer folly::gen::unsplit	(	Delimiter	delimiter,
		OutputBuffer *	outputBuffer
	)

Definition at line 130 of file String.h.

                                                                       {
  return UnsplitBuffer(delimiter, outputBuffer);
}

template<class OutputBuffer , class UnsplitBuffer = detail::UnsplitBuffer<fbstring, OutputBuffer>>

UnsplitBuffer folly::gen::unsplit	(	const char *	delimiter,
		OutputBuffer *	outputBuffer
	)

Definition at line 137 of file String.h.

                                                                         {
  return UnsplitBuffer(delimiter, outputBuffer);
}

template<class Predicate = Identity, class Until = detail::Until<Predicate>>

Until folly::gen::until

(

Predicate

pred = Predicate()

)

Definition at line 656 of file Base.h.

References move.

Referenced by TEST().

                                          {
  return Until(std::move(pred));
}

template<class Fallback , class UnwrapOr = detail::UnwrapOr<typename std::decay<Fallback>::type>>

UnwrapOr folly::gen::unwrapOr

(

Fallback &&

fallback

)

Definition at line 847 of file Base.h.

Referenced by TEST().

                                       {
  return UnwrapOr(std::forward<Fallback>(fallback));
}

template<class Visitor = Ignore, class Visit = detail::Visit<Visitor>>

Visit folly::gen::visit

(

Visitor

visitor = Visitor()

)

Definition at line 651 of file Base.h.

References move.

Referenced by TEST().

                                         {
  return Visit(std::move(visitor));
}

detail::Window folly::gen::window ( size_t  windowSize )

inline

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

References FOLLY_POP_WARNING.

Referenced by TEST().

                                              {
  return detail::Window(windowSize);
}

template<class Source , class Zip = detail::Zip<typename std::decay<Source>::type>>

Zip folly::gen::zip

(

Source &&

source

)

Definition at line 202 of file Combine-inl.h.

Referenced by make_docker_context::make_docker_context(), and TEST().

                         {
  return Zip(std::forward<Source>(source));
}

Variable Documentation

constexpr detail::Concat folly::gen::concat {}

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

Referenced by TEST().

constexpr detail::Count folly::gen::count {}

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

Referenced by folly::gen::detail::Cycle< forever >::Generator< Value, Source >::apply(), BENCHMARK_RELATIVE(), Lines_Gen(), sample(), and TEST().

constexpr detail::Cycle<true> folly::gen::cycle {}

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

Referenced by TEST().

constexpr detail::Dereference folly::gen::dereference {}

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

Referenced by gdb.FiberUnwinder::__call__(), gdb::fiber_activate(), gdb::fiber_manager_active_fibers(), gdb::get_fiber_manager_map(), deadlock::get_pthread_mutex_t_owner_and_address(), deadlock::get_pthread_rwlock_t_owner_and_address(), folly::ThreadLocalPtr< T, Tag, AccessMode >::Accessor::Iterator::operator*(), folly::ThreadLocalPtr< T, Tag, AccessMode >::Accessor::Iterator::operator->(), and TEST().

constexpr detail::Distinct<Identity> folly::gen::distinct {}

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

Referenced by TEST().

constexpr detail::First folly::gen::first {}

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

Referenced by testing::ACTION_TEMPLATE(), folly::fibers::addTasks(), folly::fbvector< HTTPHeaderCode >::assign(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::clear(), folly::collect(), folly::collectAllSemiFuture(), folly::collectAny(), folly::collectAnyWithoutException(), folly::fibers::collectN(), folly::collectN(), folly::hash::commutative_hash_combine_range(), testing::internal::CopyElements(), testing::internal::CreateCodePointFromUtf16SurrogatePair(), folly::BasicFixedString< Char, N >::creplace(), folly::fbvector< HTTPHeaderCode >::D_destroy_range_a(), proxygen::dumpBinToFile(), testing::ElementsAreArray(), folly::fbvector< HTTPHeaderCode >::erase(), folly::BasicFixedString< Char, N >::erase(), folly::fbvector< HTTPHeaderCode >::fbvector(), folly::AtomicUnorderedInsertMap< Key, Value, Hash, KeyEqual, SkipKeyValueDeletion, Atom, IndexType, Allocator >::find(), folly::for_each_detail::for_each_range_impl(), folly::fibers::forEach(), folly::Uri::getQueryParams(), folly::AsyncSSLSocket::getSSLClientCiphers(), testing::internal::GetThreadCount(), folly::fbvector< HTTPHeaderCode >::insert(), folly::pushmi::locked_entangled_pair< T, Dual >::locked_entangled_pair(), folly::pushmi::locked_shared_entangled_pair< T, Dual >::locked_shared_entangled_pair(), folly::fibers::SimpleLoopController::loop(), folly::futures::map(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), folly::TDigest::merge(), folly::detail::IntegralSizePolicy< SizeType, true >::moveToUninitialized(), folly::gen::Less::operator()(), folly::gen::Greater::operator()(), folly::operator<<(), folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), proxygen::GzipHeaderCodec::parseNameValues(), testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::putMessagesImpl(), folly::range(), folly::reduce(), folly::fbvector< HTTPHeaderCode >::relocate_done(), folly::fbvector< HTTPHeaderCode >::relocate_undo(), folly::BasicFixedString< Char, N >::replace(), runPingPong(), runSimultaneousAccessMapTest(), folly::fbvector< HTTPHeaderCode >::S_copy_n(), folly::fbvector< HTTPHeaderCode >::S_destroy_range(), folly::fbvector< HTTPHeaderCode >::S_destroy_range_a(), folly::fbvector< HTTPHeaderCode >::S_uninitialized_copy(), folly::fbvector< HTTPHeaderCode >::S_uninitialized_copy_a(), folly::fibers::TaskIterator< T >::TaskIterator(), folly::test::TEST(), TEST(), TEST_F(), proxygen::TEST_P(), TEST_P(), testNumHandlers(), testStackTracePrinter(), testing::UnorderedElementsAreArray(), testing::internal::UnorderedElementsAreMatcherImpl< Container >::UnorderedElementsAreMatcherImpl(), folly::unorderedReduce(), and folly::Uri::Uri().

constexpr detail::Indirect folly::gen::indirect {}

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

Referenced by TEST().

constexpr detail::IsEmpty<true> folly::gen::isEmpty {}

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

Referenced by proxygen::StructuredHeadersBuffer::parseBinaryContent(), proxygen::StructuredHeadersBuffer::parseIdentifier(), proxygen::StructuredHeadersBuffer::parseItem(), proxygen::StructuredHeadersBuffer::parseNumber(), proxygen::StructuredHeadersBuffer::parseString(), proxygen::StructuredHeadersBuffer::StructuredHeadersBuffer(), and TEST().

constexpr detail::Min<Identity, Greater> folly::gen::max {}

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

Referenced by TEST().

constexpr detail::Min<Identity, Less> folly::gen::min {}

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

Referenced by TEST().

constexpr detail::Map<Move> folly::gen::move {}

Examples:

/facebook/proxygen/proxygen/folly/folly/container/Iterator.h, and /facebook/proxygen/proxygen/folly/folly/lang/RValueReferenceWrapper.h.

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

Referenced by proxygen::ByteEventTracker::absorb(), fizz::server::FizzServer< ActionMoveVisitor, SM >::accept(), folly::acquireLocked(), folly::acquireLockedPair(), FutureDAGTest::add(), folly::UnboundedBlockingQueue< T >::add(), folly::LifoSemMPMCQueue< T, kBehavior >::add(), folly::FutureDAG::add(), ManualWaiter::add(), folly::QueuedImmediateExecutor::add(), folly::TestExecutor::add(), folly::python::GILAwareManualExecutor::add(), folly::python::AsyncioExecutor::add(), folly::FiberIOExecutor::add(), proxygen::HeaderTable::add(), folly::ManualExecutor::add(), folly::TimeoutQueue::add(), folly::PriorityLifoSemMPMCQueue< T, kBehavior >::add(), folly::HazptrSWMRSet< T, Atom >::add(), folly::ScopedEventBaseThread::add(), folly::DefaultKeepAliveExecutor::WeakRef::add(), folly::IOThreadPoolExecutor::add(), folly::TimedDrivableExecutor::add(), folly::ThreadedExecutor::add(), folly::VirtualExecutor::add(), proxygen::QPACKHeaderTable::add(), folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add(), folly::SerialExecutor::add(), folly::observer_detail::ObserverManager::CurrentQueue::add(), folly::CPUThreadPoolExecutor::add(), folly::VirtualEventBase::add(), folly::ThreadedRepeatingFunctionRunner::add(), folly::observer_detail::ObserverManager::NextQueue::add(), folly::fibers::FiberManager::add(), folly::ThreadPoolExecutor::StoppedThreadQueue::add(), DoNothingExecutor::add(), ThreadExecutor::add(), folly::futures::detail::DeferredExecutor::add(), folly::futures::detail::WaitExecutor::add(), folly::EventBase::add(), folly::gen::detail::add_to_tuple(), proxygen::ServiceWorker::addAcceptor(), folly::NestedCommandLineApp::addAlias(), wangle::PipelineBase::addBack(), folly::observer::Observer< T >::addCallback(), wangle::TLSCredProcessor::addCertCallback(), proxygen::HTTP2PriorityQueue::Node::addChild(), proxygen::HTTP2PriorityQueue::Node::addChildren(), proxygen::HTTP2PriorityQueue::Node::addChildToNewSubtreeRoot(), folly::NestedCommandLineApp::addCommand(), folly::observer_detail::Core::addDependent(), GenericFilterTest< Owned >::addFilterToChain(), proxygen::HTTPHeaders::addFromCodec(), wangle::PipelineBase::addFront(), folly::FunctionScheduler::addFunctionConsistentDelay(), folly::FunctionScheduler::addFunctionGenericDistribution(), folly::FunctionScheduler::addFunctionGenericNextRunTimeFunctor(), folly::FunctionScheduler::addFunctionOnce(), folly::FunctionScheduler::addFunctionToHeap(), folly::FunctionScheduler::addFunctionToHeapChecked(), folly::FunctionScheduler::addFunctionUniformDistribution(), folly::FutureExecutor< ExecutorImpl >::addFuture(), folly::LogCategory::addHandler(), fizz::sm::addHandshakeLogging(), proxygen::HPACKEncodeBuffer::addHeadroom(), folly::TestExecutor::addImpl(), fizz::WriteRecordLayer::addMessage(), proxygen::TraceEvent::addMeta(), wangle::SecurityProtocolContextManager::addPeeker(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::addProcessingActions(), fizz::test::TestMessages::addPsk(), folly::TimeoutQueue::addRepeating(), proxygen::ServiceWorker::addServiceAcceptor(), proxygen::Service::addServiceWorker(), wangle::SSLContextManager::addSSLContextConfig(), folly::fibers::TaskIterator< T >::addTask(), folly::fibers::FiberManager::addTaskFuture(), folly::fibers::FiberManager::addTaskRemoteFuture(), folly::fibers::addTasks(), proxygen::RequestHandlerChain::addThen(), wangle::TLSCredProcessor::addTicketCallback(), proxygen::HTTP2PriorityQueue::addTransaction(), folly::BlockingQueue< folly::CPUThreadPoolExecutor::CPUTask >::addWithPriority(), folly::PriorityLifoSemMPMCQueue< T, kBehavior >::addWithPriority(), folly::DefaultKeepAliveExecutor::WeakRef::addWithPriority(), folly::VirtualExecutor::addWithPriority(), folly::SerialExecutor::addWithPriority(), folly::CPUThreadPoolExecutor::addWithPriority(), folly::AsyncSocket::addZeroCopyBuf(), wangle::TimekeeperTester::after(), all(), folly::allocate_unique(), folly::ThreadCachedArena::allocateThreadLocalArena(), any(), folly::pushmi::any_constrained_executor_ref< E, CV >::any_constrained_executor_ref(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::any_constrained_single_sender(), folly::pushmi::any_executor_ref< E >::any_executor_ref(), folly::pushmi::any_flow_many_sender< PE, PV, E, VN >::any_flow_many_sender(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::any_flow_receiver(), folly::pushmi::any_flow_single_sender< PE, E, VN >::any_flow_single_sender(), folly::pushmi::any_many_sender< E, VN >::any_many_sender(), folly::pushmi::any_receiver< E, folly::pushmi::any_executor_ref< E > >::any_receiver(), folly::pushmi::any_single_sender< E, VN >::any_single_sender(), folly::pushmi::any_time_executor_ref< E, TP >::any_time_executor_ref(), folly::IOBufQueue::append(), folly::IOBuf::appendChain(), folly::gen::detail::IStreamByLine::apply(), folly::gen::Group< Key, Value >::apply(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::Puller::apply(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::apply(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::apply(), folly::gen::detail::ChunkedRangeSource< Iterator >::apply(), folly::gen::detail::Sample< Random >::Generator< Value, Source, Rand, StorageType >::apply(), folly::gen::detail::Order< Selector, Comparer >::Generator< Value, Source, StorageType, Result >::apply(), folly::gen::detail::GroupBy< Selector >::Generator< Value, Source, ValueDecayed, Key, KeyDecayed >::apply(), folly::gen::detail::GroupByAdjacent< Selector >::Generator< Value, Source, ValueDecayed, Key, KeyDecayed >::apply(), folly::gen::detail::Window::Generator< Value, Source, StorageType >::apply(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::appWrite(), array_dtor_full_tc_test(), array_test(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::asSharedProxy(), folly::Optional< NamedGroup >::assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign(), folly::fbvector< HTTPHeaderCode >::assign(), folly::basic_fbstring< char >::assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign_if_equal(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::assignImpl(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::asStdFunction(), folly::gen::detail::Order< Selector, Comparer >::Generator< Value, Source, StorageType, Result >::asVector(), folly::AsyncFileWriter::AsyncFileWriter(), folly::AsyncSocket::AsyncSocket(), wangle::TimekeeperTester::at(), folly::dynamic::at(), folly::test::atomic_notify_one(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr(), folly::fibers::Promise< T, BatonT >::await(), folly::coro::TimedWaitAwaitable< Awaitable >::await_resume(), folly::coro::TimedWaitAwaitable< Awaitable >::await_suspend(), folly::fibers::TaskIterator< T >::awaitNext(), folly::fibers::TaskIterator< T >::awaitNextResult(), folly::Unexpected< Error >::BadExpectedAccess::BadExpectedAccess(), folly::Expected< int, E >::base(), BENCHMARK(), BENCHMARK_RELATIVE(), proxygen::HTTPServer::bind(), folly::AsyncSSLSocket::bioRead(), proxygen::ResponseBuilder::body(), folly::python::bridgeFibers(), folly::python::bridgeFuture(), folly::detail::DigestBuilder< DigestT >::build(), proxygen::RequestHandlerChain::build(), burn(), byLine(), byLineFull(), folly::gen::detail::byLineImpl(), testing::internal::edit_distance::CalculateOptimalEdits(), folly::observer::CallbackHandle::CallbackHandle(), fizz::test::callDecrypt(), fizz::test::callEncrypt(), ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), folly::exception_wrapper_detail::catch_(), fizz::CertDecompressionManager::CertDecompressionManager(), fizz::test::TestMessages::certificateRequest(), folly::futures::detail::chainExecutor(), fizz::server::SlidingBloomReplayCache::check(), checkQError(), fizz::server::test::AeadTicketCipherTest::checkUnsetEncrypt(), fizz::test::chunkIOBuf(), clause11_21_4_2_c(), clause11_21_4_2_k(), clause11_21_4_6_3_a(), clause11_21_4_8_1_b(), clause11_21_4_8_1_c(), clause11_21_4_8_1_d(), clause11_21_4_8_1_f(), clause11_21_4_8_1_h(), clause11_21_4_8_1_j(), clause11_21_4_8_1_l(), folly::RequestContext::clearContextData(), folly::IOBufQueue::clearWritableRangeCache(), AcceptRoutingHandlerTest::clientConnectAndWrite(), fizz::test::TestMessages::clientHello(), folly::io::detail::CursorBase< Cursor, const IOBuf >::cloneAtMost(), wangle::cloneSSLSession(), cmake_minimum_required(), folly::collect(), folly::fibers::collectAll(), folly::collectAllSemiFuture(), folly::fibers::collectAny(), folly::collectAny(), folly::collectAnyWithoutException(), folly::fibers::collectN(), folly::collectN(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::commit(), HTTPUpstreamTest< SPDY3CodecPair >::commonSetUp(), HTTP2UpstreamSessionWithVirtualNodesTest::commonSetUp(), folly::Subprocess::communicate(), folly::Subprocess::communicateIOBuf(), fizz::client::test::AsyncFizzClientTest::completeEarlyHandshake(), folly::gen::detail::FileWriter::compose(), folly::gen::detail::Interleave< Container >::compose(), folly::gen::detail::Zip< Container >::compose(), folly::gen::detail::PMap< Predicate >::compose(), folly::gen::detail::StringResplitter::compose(), folly::gen::detail::Composed< First, Second >::compose(), folly::gen::detail::Parallel< Ops >::compose(), folly::gen::detail::Map< Predicate >::compose(), folly::gen::detail::Filter< Predicate >::compose(), folly::gen::detail::Until< Predicate >::compose(), folly::gen::detail::Take::compose(), folly::gen::detail::Visit< Visitor >::compose(), folly::gen::detail::Stride::compose(), folly::gen::detail::Sample< Random >::compose(), folly::gen::detail::Skip::compose(), folly::gen::detail::Order< Selector, Comparer >::compose(), folly::gen::detail::GroupBy< Selector >::compose(), folly::gen::detail::GroupByAdjacent< Selector >::compose(), folly::gen::detail::TypeAssertion< Expected >::compose(), folly::gen::detail::Distinct< Selector >::compose(), folly::gen::detail::Batch::compose(), folly::gen::detail::Window::compose(), folly::gen::detail::Concat::compose(), folly::gen::detail::RangeConcat::compose(), folly::gen::detail::GuardImpl< Exception, ErrorHandler >::compose(), folly::gen::detail::Dereference::compose(), folly::gen::detail::Indirect::compose(), folly::gen::detail::Cycle< forever >::compose(), folly::gen::detail::FoldLeft< Seed, Fold >::compose(), folly::gen::detail::Reduce< Reducer >::compose(), folly::gen::detail::Sum::compose(), folly::gen::detail::Min< Selector, Comparer >::compose(), fizz::ZlibCertificateCompressor::compress(), folly::io::test::compressSome(), compressThenDecompress(), fizz::client::FizzClient< ActionMoveVisitor, SM >::connect(), fizz::client::AsyncFizzClientT< SM >::connect(), wangle::ClientBootstrap< DefaultPipeline >::connect(), wangle::EvbHandshakeHelper::connectionError(), wangle::AcceptorHandshakeManager::connectionError(), HTTPTargetSessionAcceptor::connectionReady(), MockHandshakeHelperCallback< UseOwnedRawPtrPolicy >::connectionReady(), wangle::EvbHandshakeHelper::connectionReady(), wangle::AcceptorHandshakeManager::connectionReady(), wangle::Acceptor::connectionReady(), wangle::ClientBootstrap< Pipeline >::ConnectCallback::connectSuccess(), BogoTestServer::connectSuccess(), proxygen::HTTPConnector::connectSuccess(), fizz::client::AsyncFizzClientT< SM >::connectSuccess(), BogoTestClient::connectSuccess(), folly::constCastFunction(), folly::detail::fixedstring::constexpr_swap(), folly::pushmi::constrained_single_sender< Data, DSF, DZF, DEXF >::constrained_single_sender(), constrained_single_sender_test(), folly::NotificationQueue< MessageT >::Consumer::consumeMessages(), folly::NotificationQueue< MessageT >::SimpleConsumer::consumeUntilDrained(), wangle::ContextImpl< H >::ContextImpl(), QPACKTests::controlAck(), folly::ThreadedExecutor::controlLaunchEnqueuedTasks(), folly::futures::detail::convertFuture(), proxygen::HTTPArchive::convertToHPACK(), wangle::LRUInMemoryCache< K, V, MutexT >::convertToKeyValuePairs(), copy_and_move_test(), CopyCounter::CopyCounter(), folly::observer_detail::Core::create(), folly::DefaultKeepAliveExecutor::WeakRef::create(), folly::SerialExecutor::create(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::createAead(), folly::fibers::createAtomicBatchDispatcher(), fizz::JavaCryptoCertificateVerifier::createAuthorities(), fizz::DefaultCertificateVerifier::createAuthorities(), proxygen::SecondaryAuthManager::createAuthRequest(), createCache(), createCacheWithExecutor(), folly::LoggerDB::createCategoryLocked(), fizz::test::createCert(), folly::IOBuf::createChain(), wangle::FizzConfigUtil::createFizzContext(), wangle::FizzAcceptorHandshakeHelper::createFizzServer(), wangle::Acceptor::createFizzTicketCipher(), fizz::JavaCryptoCertificateVerifier::createFromCAFile(), fizz::DefaultCertificateVerifier::createFromCAFile(), folly::detail::SingletonHolder< T >::createInstance(), ZlibServerFilterTest::createResponseChain(), ScopedServerTest::createScopedServer(), wangle::FizzConfigUtil::createTicketCipher(), fizz::FizzUtil::createTicketCipher(), fizz::extensions::TokenBindingConstructor::createTokenBinding(), folly::SerialExecutor::createUnique(), TestPriorityMapBuilder::createVirtualStreams(), folly::FileWriterFactory::createWriter(), folly::StreamHandlerFactory::WriterFactory::createWriter(), wangle::LineBasedFrameDecoder::decode(), proxygen::compress::CompressionSimulator::decode(), proxygen::compress::HPACKScheme::decode(), proxygen::compress::QPACKScheme::decode(), fizz::decode< Finished >(), fizz::detail::decodeAuthRequest(), proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKCodec::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), proxygen::QPACKCodec::decodeEncoderStream(), proxygen::QPACKDecoder::decodeEncoderStreamInstruction(), fizz::ReadRecordLayer::decodeHandshakeMessage(), fizz::test::HandshakeTypesTest::decodeHex(), fizz::test::ZlibCertificateCompressorTest::decodeHex(), proxygen::HPACKDecoder::decodeLiteralHeader(), proxygen::QPACKDecoder::decodeLiteralHeaderQ(), proxygen::compress::CompressionSimulator::decodePacket(), proxygen::QPACKDecoder::decodeStreaming(), proxygen::QPACKCodec::decodeStreaming(), folly::bser::decodeTemplate(), fizz::ZlibCertificateDecompressor::decompress(), fizz::server::DualTicketCipher::decrypt(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::decrypt(), fizz::server::AeadCookieCipher< AeadType, HkdfType >::decrypt(), fizz::server::AeadTicketCipher< AeadType, CodecType, HkdfType >::decrypt(), fizz::Aead::decrypt(), folly::replaceable_detail::default_and_move_ctor_mixin< T, true, true >::default_and_move_ctor_mixin(), folly::replaceable_detail::default_and_move_ctor_mixin< T, false, true >::default_and_move_ctor_mixin(), folly::SemiFuture< T >::defer(), folly::SemiFuture< T >::deferError(), folly::SemiFuture< T >::deferValue(), folly::SemiFuture< T >::delayed(), folly::Future< T >::delayed(), folly::Future< T >::delayedUnsafe(), fizz::client::AsyncFizzClientT< SM >::deliverAllErrors(), fizz::AsyncFizzBase::deliverAppData(), fizz::server::AsyncFizzServerT< SM >::deliverHandshakeError(), fizz::client::AsyncFizzClientT< SM >::deliverHandshakeError(), folly::detail::SingleElementQueue< T, Atom >::dequeueImpl(), fizz::KeyScheduler::deriveAppTrafficSecrets(), fizz::KeyDerivationImpl< Hash >::deriveSecret(), folly::VirtualEventBase::destroy(), folly::IOBuf::destroy(), folly::futures::detail::WaitExecutor::detach(), proxygen::HTTP2PriorityQueue::Node::detachChild(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::Token::dispatch(), UseSharedPtrPolicy< MockHandshakeHelperCallback< P > >::dispatchConnectionReady(), UseOwnedRawPtrPolicy< MockHandshakeHelperCallback< P > >::dispatchConnectionReady(), folly::AsyncServerSocket::dispatchError(), folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::dispatchFunctionWrapper(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::AsyncServerSocket::dispatchSocket(), UseSharedPtrPolicy< MockHandshakeHelper< P > >::dispatchStart(), distinctBy(), TestAbortPost< stage >::doAbortTest(), folly::futures::detail::Core< T >::doCallback(), doubleBatchInnerDispatch(), doubleBatchOuterDispatch(), proxygen::HPACKQueue::drainQueue(), proxygen::ServiceWorker::drainServiceAcceptor(), folly::futures::detail::WaitExecutor::drive(), folly::python::GILAwareManualExecutor::driveImpl(), folly::futures::detail::WaitExecutor::driveUntil(), folly::dynamic::dynamic(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::earlyAppWrite(), folly::EventBaseLocal< T >::emplace(), proxygen::HTTP2PriorityQueue::Node::emplaceNode(), folly::emplacer(), fizz::server::test::FizzTestServer::enableClientAuthWithChain(), proxygen::compress::CompressionSimulator::encode(), proxygen::compress::HPACKScheme::encode(), proxygen::compress::QPACKScheme::encode(), fizz::encode< Finished >(), fizz::encode< message_hash >(), fizz::sm::encodeAndAddBinders(), proxygen::hpack::encodeDecode(), fizz::encodeHandshake(), proxygen::QPACKEncoder::encodeQ(), fizz::server::DualTicketCipher::encrypt(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::encrypt(), fizz::server::AeadTicketCipher< AeadType, CodecType, HkdfType >::encrypt(), fizz::OpenSSLEVPCipher< EVPImpl >::encrypt(), fizz::test::TestMessages::encryptedExt(), encryptGCM(), folly::UnboundedQueue< T, false, 6 >::enqueue(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::enqueue(), MPMC< T >::enqueue(), folly::detail::SingleElementQueue< T, Atom >::enqueue(), proxygen::HPACKQueue::enqueueHeaderBlock(), proxygen::QPACKDecoder::enqueueHeaderBlock(), folly::detail::SingleElementQueue< T, Atom >::enqueueImpl(), folly::Future< T >::ensure(), folly::pushmi::entangle(), folly::small_vector< Observer< T > *, InlineObservers >::erase(), folly::pushmi::detail::tap_::error(), folly::pushmi::operators::error(), folly::pushmi::subject< PS, TN... >::subject_shared::error(), folly::pushmi::subject< PS, TN... >::subject_receiver::error(), folly::pushmi::strand_queue< E, Executor >::error(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::error(), folly::pushmi::any_receiver< E, folly::pushmi::any_executor_ref< E > >::error(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::error(), folly::pushmi::flow_receiver< VF, EF, DF, StrtF >::error(), folly::pushmi::receiver< VF, EF, DF >::error(), folly::expected_detail::ExpectedStorage< Value, Error >::error(), folly::pushmi::receiver< Data, DVF, DEF, DDF >::error(), folly::expected_detail::ExpectedUnion< Value, Error >::error(), folly::expected_detail::ExpectedStorage< Value, Error, StorageType::ePODStruct >::error(), folly::Unexpected< Error >::error(), folly::Expected< int, E >::error(), proxygen::HTTPSession::errorOnTransactionId(), proxygen::HTTPSession::errorOnTransactionIds(), fizz::detail::evpDecrypt(), fizz::detail::evpEncrypt(), folly::Try< folly::folly::Unit >::exception(), folly::Try< void >::exception(), folly::exception_wrapper::exception_wrapper(), folly::exchange(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::exchange(), folly::detail::function::execSmall(), ZlibServerFilterTest::exercise_compression(), fizz::HkdfImpl< Hash >::expand(), fizz::KeyDerivationImpl< Hash >::expandLabel(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectAction(), fizz::server::test::AsyncFizzServerTest::expectAppClose(), fizz::client::test::AsyncFizzClientTest::expectAppClose(), fizz::server::test::ServerProtocolTest::expectCookie(), folly::Expected< int, E >::Expected(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectEncryptedWriteRecordLayerCreation(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectError(), ExpensiveCopy::ExpensiveCopy(), wangle::ExpiringFilter< Req, Resp >::ExpiringFilter(), proxygen::HTTPMessage::extractHeaders(), folly::LogStreamProcessor::extractMessageString(), folly::io::detail::CursorStringAppender::extractString(), folly::LogStreamBuffer::extractString(), proxygen::SPDYCodec::failStream(), folly::symbolizer::FastStackTracePrinter::FastStackTracePrinter(), fGen(), folly::IOBufQueue::fillWritableRangeCache(), filter(), folly::Future< T >::filter(), wangle::ContextImpl< H >::fireReadException(), wangle::InboundContextImpl< H >::fireReadException(), wangle::ContextImpl< H >::fireWriteException(), wangle::OutboundContextImpl< H >::fireWriteException(), fizz::tool::fizzClientCommand(), BogoTestServer::fizzHandshakeAttemptFallback(), wangle::FizzAcceptorHandshakeHelper::fizzHandshakeAttemptFallback(), fizz::client::test::MockHandshakeCallbackT< fizz::client::test::MockClientStateMachineInstance >::fizzHandshakeError(), wangle::FizzAcceptorHandshakeHelper::fizzHandshakeError(), fizz::server::test::MockHandshakeCallbackT< fizz::server::test::MockServerStateMachineInstance >::fizzHandshakeError(), wangle::FizzAcceptorHandshakeHelper::fizzHandshakeSuccess(), fizz::tool::fizzServerCommand(), fizz::server::test::FizzTestServer::FizzTestServer(), proxygen::HTTP2PriorityQueue::Node::flattenSubtree(), proxygen::HTTP2PriorityQueue::Node::flattenSubtreeDFS(), flow_many_sender_test(), folly::pushmi::flow_receiver< VF, EF, DF, StrtF >::flow_receiver(), folly::pushmi::flow_receiver< Data, DVF, DEF, DDF, DStrtF >::flow_receiver(), flow_single_sender_test(), proxygen::compress::CompressionSimulator::flushPacket(), proxygen::compress::CompressionSimulator::flushRequests(), foldl(), folly::fibers::forEach(), folly::gen::Group< Key, Value >::foreach(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::foreach(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::Puller::foreach(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::foreach(), folly::gen::detail::Order< Selector, Comparer >::Generator< Value, Source, StorageType, Result >::foreach(), wangle::Observable< T >::forEachObserver(), from(), folly::experimental::EnvironmentState::fromCurrentEnvironment(), fromFile(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::fulfillPromises(), fizz::server::test::AsyncFizzServerTest::fullHandshakeSuccess(), fizz::client::test::AsyncFizzClientTest::fullHandshakeSuccess(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::Function(), folly::Future< T >::Future(), folly::pushmi::future_from(), folly::FutureSplitter< T >::FutureSplitter(), proxygen::HTTP1xCodec::generateBody(), proxygen::SPDYCodec::generateBody(), proxygen::HTTP2Codec::generateBody(), proxygen::FlowControlFilter::generateBody(), proxygen::PassThroughHTTPCodecFilter::generateBody(), proxygen::HTTP2Codec::generateCertificate(), proxygen::PassThroughHTTPCodecFilter::generateCertificate(), proxygen::HTTP2Codec::generateCertificateRequest(), proxygen::PassThroughHTTPCodecFilter::generateCertificateRequest(), proxygen::HTTP2Codec::generateContinuation(), proxygen::SPDYCodec::generateDataFrame(), proxygen::HTTP2Codec::generateGoaway(), proxygen::PassThroughHTTPCodecFilter::generateGoaway(), proxygen::HTTP2Codec::generateHeaderImpl(), fizz::X25519KeyExchange::generateKeyPair(), proxygen::SPDYCodec::generateSynReply(), proxygen::SPDYCodec::generateSynStream(), fizz::sm::generateTicket(), proxygen::HTTP2Codec::generateTrailers(), proxygen::StructuredHeadersEncoder::get(), folly::SemiFuture< T >::get(), folly::Future< T >::get(), folly::get_emplace_arg(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr(), folly::detail::shared_ptr_internals::get_shared_ptr_from_counted_base(), proxygen::compress::QPACKScheme::getAck(), proxygen::compress::QMINScheme::getAck(), fizz::server::test::ServerProtocolTest::getActions(), proxygen::SecondaryAuthManager::getAuthenticator(), fizz::ExportedAuthenticator::getAuthenticator(), fizz::ExportedAuthenticator::getAuthenticatorContext(), fizz::ExportedAuthenticator::getAuthenticatorRequest(), folly::io::getAutoUncompressionCodec(), proxygen::HTTPEvent::getBody(), folly::dynamic::getBool(), wangle::getCacheDataForSession(), fizz::sm::getCertificate(), fizz::sm::getCertificateRequest(), fizz::sm::getCertificateVerify(), fizz::CertUtils::getCertMessage(), fizz::SelfCertImpl< T >::getCertMessage(), fizz::test::getCipher(), fizz::sm::getClientCert(), fizz::server::test::AeadCookieCipherTest::getClientHello(), fizz::sm::getClientHello(), proxygen::HTTPDefaultSessionCodecFactory::getCodec(), folly::LoggerDB::getConfigImpl(), fizz::server::getCookieState(), fizz::sm::getCookieState(), folly::exception_tracer::getCurrentExceptions(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), folly::dynamic::getDefault(), fizz::sm::getEarlyDataParams(), fizz::detail::getEmptyAuthenticator(), fizz::sm::getEncryptedExt(), fizz::server::test::ServerProtocolTest::getEncryptedHandshakeWrite(), proxygen::HTTPEvent::getError(), folly::exception_tracer::getExceptionStatistics(), fizz::getExtension(), fizz::extensions::TokenBindingServerExtension::getExtensions(), fizz::test::ExtensionsTest::getExtensions(), fizz::Protocol::getFinished(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::getFutureResult(), folly::getGFlags(), folly::getGlobalBenchmarkBaselineIndex(), wangle::BroadcastPool< T, R, P >::getHandler(), proxygen::HTTPEvent::getHeaders(), fizz::sm::getHelloRetryRequest(), fizz::sm::getHrrKeyExchangers(), folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::getItem(), fizz::sm::getKeyExchangers(), fizz::Protocol::getKeyUpdated(), fizz::sm::getMaxEarlyDataSize(), folly::FunctionScheduler::RepeatFunc::getNextRunTimeFunc(), folly::observer::SimpleObservable< T >::getObserver(), folly::observer::ObserverCreator< Observable, Traits >::getObserver(), folly::EventBaseLocal< T >::getOrCreate(), folly::EventBaseLocal< T >::getOrCreateFn(), proxygen::SecondaryAuthManager::getPeerCert(), folly::AsyncSSLSocket::getPeerCertificate(), fizz::sm::getPskExtension(), folly::coro::detail::TaskPromise< T >::getResult(), folly::coro::detail::TaskPromise< void >::getResult(), proxygen::compress::CompressionSimulator::getScheme(), folly::AsyncSSLSocket::getSelfCertificate(), fizz::sm::getServerHello(), wangle::SSLSessionCacheManager::getSession(), folly::observer::Observer< T >::getSnapshot(), folly::AsyncSSLSocket::getSSLClientCiphers(), FakeSessionCallbacks::getSSLSession(), fizz::server::getStatelessHelloRetryRequest(), fizz::server::AeadCookieCipher< AeadType, HkdfType >::getStatelessResponse(), fizz::client::test::getTestPsk(), fizz::server::AeadCookieCipher< AeadType, HkdfType >::getTokenOrRetry(), proxygen::HTTPEvent::getTrailers(), folly::SemiFuture< T >::getTry(), folly::Future< T >::getVia(), folly::FutureDAG::go(), groupBy(), groupByAdjacent(), GSOBuf::GSOBuf(), fizz::sm::EventHandler< SM, state, event >::handle(), fizz::server::detail::handleAppClose(), fizz::client::detail::handleAppClose(), fizz::sm::handleCertMsg(), wangle::BroadcastPool< T, R, P >::BroadcastManager::handleConnectError(), fizz::sm::handleEarlyAppWrite(), fizz::client::AsyncFizzClientT< SM >::handleEarlyReject(), fizz::server::detail::handleError(), fizz::client::detail::handleError(), fizz::server::detail::handleInvalidEvent(), folly::AsyncSocket::handleRead(), folly::AsyncPipeReader::handlerReady(), folly::AsyncServerSocket::handlerReady(), wangle::SSLAcceptorHandshakeHelper::handshakeSuc(), wangle::FizzAcceptorHandshakeHelper::handshakeSuc(), folly::hazptr_array< 3, Atom >::hazptr_array(), folly::hazptr_retire(), QPACKTests::headerAck(), fizz::test::TestMessages::helloRetryRequest(), folly::hint_emplacer(), HTTPDownstreamTest< SPDY3_1CodecPair >::HTTPDownstreamTest(), fizz::sm::ignoreEarlyAppWrite(), folly::ImmediateFileWriter::ImmediateFileWriter(), folly::pushmi::detail::tap_fn::impl(), wangle::InboundContextImpl< H >::InboundContextImpl(), wangle::Acceptor::init(), wangle::ContextImplBase< H, InboundHandlerContext< H::rout > >::initialize(), folly::InitThreadFactory::InitThreadFactory(), inline_bulk_target(), folly::StringKeyedUnorderedMap< Mapped, Hash, Eq, Alloc >::insert(), folly::StringKeyedMap< Value, Compare, Alloc >::insert(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert(), folly::AtomicHashMap< int64_t, int64_t >::insert(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::insert(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::insert(), folly::sorted_vector_set< folly::RequestData * >::insert(), folly::pushmi::time_source_shared< E, time_point >::insert(), folly::sorted_vector_map< Key, Value, Compare, Allocator, GrowthPolicy, Container >::insert(), folly::small_vector< Observer< T > *, InlineObservers >::insert(), folly::io::RWCursor< access >::insert(), folly::io::QueueAppender::insert(), folly::fbvector< HTTPHeaderCode >::insert(), folly::detail::insert_with_hint(), folly::AtomicLinkedList< T >::insertHead(), folly::LoggerDB::internalWarningImpl(), folly::IOBufQueue::IOBufQueue(), folly::IPAddressV4::IPAddressV4(), folly::IPAddressV6::IPAddressV6(), isLowercase(), fizz::JavaCryptoPeerCert::JavaCryptoPeerCert(), folly::json_pointer::json_pointer(), keepAliveTest(), folly::detail::lock(), folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase(), folly::LogConfig::LogConfig(), folly::logConfigToDynamic(), folly::LoggerDB::LoggerDB(), folly::LogHandlerConfig::LogHandlerConfig(), folly::LogMessage::LogMessage(), folly::LogStreamProcessor::LogStreamProcessor(), Application::loop(), folly::fibers::FiberManager::loopUntilNoReadyImpl(), wangle::LRUPersistentCache< K, V, MutexT >::LRUPersistentCache(), main(), folly::futures::detail::Core< T >::make(), folly::pushmi::time_source< E, TP >::make(), folly::pushmi::make_any_constrained_executor(), folly::pushmi::make_any_executor(), folly::pushmi::make_any_time_executor(), ImmediateFlowManySender::make_consumer(), ImmediateFlowSingleSender::make_consumer(), ImmediateFlowSingleSender::make_producer(), ImmediateFlowManySender::make_producer(), p1054::make_promise_contract(), folly::pushmi::detail::make_via_fn_data(), fizz::ExportedAuthenticator::makeAuthenticator(), folly::makeAutoTimer(), MoveToFbStringTest::makeBuf(), folly::futures::detail::makeCoreCallbackState(), folly::makeExpected(), folly::makeFuture(), folly::makeGuard(), fizz::LoggingFactory::makeKeyScheduler(), fizz::Factory::makeKeyScheduler(), fizz::JavaCryptoFactory::makePeerCert(), fizz::CertUtils::makePeerCert(), fizz::Factory::makePeerCert(), folly::makePromiseContract(), proxygen::makeResponse(), fizz::CertUtils::makeSelfCert(), folly::makeSemiFuture(), folly::observer::makeTLObserver(), folly::jsonschema::makeValidator(), many_sender_test(), map(), folly::futures::map(), mapOp(), mapped(), folly::observer_detail::ObserverManager::DependencyRecorder::markDependency(), maxBy(), QueueTest::maxQueueSize(), merge(), folly::TDigest::merge(), minBy(), folly::MoveWrapper< T >::move(), folly::IOBufQueue::move(), folly::padded::Adaptor< IntNodeVec >::move(), folly::exception_wrapper::ExceptionPtr::move_(), folly::exception_wrapper::InPlace< Ex >::move_(), folly::exception_wrapper::SharedPtr::move_(), move_test(), folly::expected_detail::MoveConstructible< ExpectedStorage< Value, Error, StorageType::eUnion >, StrictAllOf< std::is_move_constructible, Value, Error >::value, StrictAllOf< std::is_nothrow_move_constructible, Value, Error >::value >::MoveConstructible(), proxygen::HTTPException::moveCurrentIngressBuf(), folly::symbolizer::StringSymbolizePrinter::moveFbString(), folly::detail::moveObjectsRight(), folly::ManualExecutor::ScheduledFunc::moveOutFunc(), proxygen::HTTPException::movePartialMsg(), folly::SSLHandshakeBase::moveSocket(), folly::MoveTester::MoveTester(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::moveToErrorState(), folly::detail::IntegralSizePolicy< SizeType, true >::moveToUninitialized(), naive_executor_bulk_target(), negate(), fizz::sm::negotiateParameters(), fizz::sm::negotiatePsk(), folly::AsyncSocket::BytesWriteRequest::newRequest(), wangle::SSLSessionCallbacks::newSessionCallback(), folly::NamedThreadFactory::newThread(), folly::InitThreadFactory::newThread(), folly::PriorityThreadFactory::newThread(), fizz::server::FizzServer< ActionMoveVisitor, SM >::newTransportData(), proxygen::HTTPMessageFilter::nextOnBody(), proxygen::HTTPMessageFilter::nextOnHeadersComplete(), proxygen::MockHTTPMessageFilter::nextOnHeadersCompletePublic(), proxygen::HTTPMessageFilter::nextOnTrailers(), folly::observer_detail::ObserverManager::NextQueue::NextQueue(), folly::pushmi::__adl::noexcept(), folly::pushmi::__adl::set_error_fn::noexcept(), folly::pushmi::__adl::do_submit_fn::noexcept(), notifySubscribers(), folly::dynamic::object(), folly::dynamic::ObjectMaker::ObjectMaker(), observe(), folly::pushmi::on_done(), folly::pushmi::on_error(), folly::pushmi::on_executor(), folly::pushmi::on_now(), folly::pushmi::on_starting(), folly::pushmi::on_submit(), folly::pushmi::on_value(), EchoService::EchoHandler::onBody(), PushService::PushRequestHandler::onBody(), proxygen::ScopedHandler< HandlerType >::onBody(), proxygen::HTTPMessageFilter::onBody(), ProxyService::ProxyHandler::onBody(), proxygen::RequestHandlerAdaptor::onBody(), proxygen::Filter::onBody(), proxygen::HTTPCodecPrinter::onBody(), proxygen::PassThroughHTTPCodecFilter::onBody(), ProxyService::ProxyHandler::ServerTransactionHandler::onBody(), proxygen::FlowControlFilter::onBody(), proxygen::FakeHTTPCodecCallback::onBody(), proxygen::HTTP1xCodec::onBody(), proxygen::HTTPSession::onBody(), proxygen::HTTPSessionBase::onBodyImpl(), proxygen::PassThroughHTTPCodecFilter::onCertificate(), proxygen::FakeHTTPCodecCallback::onCertificate(), proxygen::HTTPSession::onCertificate(), proxygen::PassThroughHTTPCodecFilter::onCertificateRequest(), proxygen::FakeHTTPCodecCallback::onCertificateRequest(), proxygen::HTTPSession::onCertificateRequest(), folly::AsyncUDPServerSocket::onDataAvailable(), EchoService::EchoHandler::onEOM(), PushService::PushRequestHandler::onEOM(), proxygen::DirectResponseHandler::onEOM(), folly::Future< T >::onError(), folly::Future< folly::folly::Unit >::onError(), proxygen::Mock1867Callback::onFieldStart(), wangle::MultiFilePoller::onFileUpdated(), proxygen::PassThroughHTTPCodecFilter::onGoaway(), proxygen::HTTPCodecPrinter::onGoaway(), proxygen::FakeHTTPCodecCallback::onGoaway(), proxygen::HTTPSession::onGoaway(), proxygen::QPACKEncoder::onHeaderAck(), proxygen::HTTPChecks::onHeadersComplete(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), HTTP1xCodecCallback::onHeadersComplete(), proxygen::HTTPMessageFilter::onHeadersComplete(), proxygen::RequestHandlerAdaptor::onHeadersComplete(), proxygen::PassThroughHTTPCodecFilter::onHeadersComplete(), CurlService::CurlClient::onHeadersComplete(), proxygen::HTTPCodecPrinter::onHeadersComplete(), ProxyService::ProxyHandler::ServerTransactionHandler::onHeadersComplete(), proxygen::RFC1867Codec::onHeadersComplete(), proxygen::FakeHTTPCodecCallback::onHeadersComplete(), proxygen::HTTP1xCodec::onHeadersComplete(), proxygen::HTTPSession::onHeadersComplete(), proxygen::RFC1867Codec::onIngress(), proxygen::HTTPTransaction::onIngressBody(), proxygen::HTTPTransaction::onIngressHeadersComplete(), proxygen::HTTPTransaction::onIngressTrailers(), proxygen::HTTP2Codec::onIngressUpgradeMessage(), proxygen::HTTP1xCodec::onMessageComplete(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), proxygen::HTTPUpstreamSession::onNativeProtocolUpgrade(), proxygen::HTTPSession::onNativeProtocolUpgradeImpl(), proxygen::HTTPServerAcceptor::onNewConnection(), proxygen::HTTPSessionAcceptor::onNewConnection(), folly::detail::BufferedDigest< DigestT, ClockT >::onNewDigest(), folly::detail::BufferedSlidingWindow< DigestT, ClockT >::onNewDigest(), proxygen::HTTP1xCodec::onParserError(), proxygen::ScopedHandler< HandlerType >::onRequest(), ProxyService::ProxyHandler::onRequest(), proxygen::Filter::onRequest(), wangle::AcceptRoutingHandler< Pipeline, R >::onRoutingData(), ProxyService::ProxyHandler::onServerBody(), proxygen::HTTPSession::onSessionParseError(), proxygen::SPDYCodec::onSynCommon(), folly::Future< T >::onTimeout(), proxygen::HTTPMessageFilter::onTrailers(), proxygen::PassThroughHTTPCodecFilter::onTrailersComplete(), proxygen::FakeHTTPCodecCallback::onTrailersComplete(), proxygen::HTTPSession::onTrailersComplete(), HTTPUpstreamTest< SPDY3CodecPair >::onWriteChain(), folly::pushmi::detail::on_fn::on_value_impl< In, Out >::operator()(), wangle::CloseOnReleaseFilter< Req, Resp >::operator()(), folly::pushmi::operators::bulk_fn::operator()(), folly::pushmi::operators::defer_fn::impl< F >::operator()(), wangle::ExecutorFilter< Bonk, Xtruct >::operator()(), folly::pushmi::detail::no_fail_fn::out_impl< In >::operator()(), folly::pushmi::detail::single_error_impl< E, VN >::operator()(), folly::pushmi::operators::just_fn::impl< VN >::operator()(), folly::pushmi::detail::on_fn::out_impl< In, ExecutorFactory >::operator()(), folly::pushmi::detail::no_fail_fn::in_impl::operator()(), folly::pushmi::reduce_fn::operator()(), folly::pushmi::operators::defer_fn::operator()(), folly::pushmi::detail::filter_fn::submit_impl< In, Predicate >::operator()(), folly::pushmi::detail::switch_on_error_fn::out_impl< In, ErrorSelector >::operator()(), folly::pushmi::operators::just_fn::operator()(), folly::pushmi::detail::transform_on< F, is_single<> >::operator()(), folly::pushmi::detail::on_fn::time_on_value_impl< In, TP, Out >::operator()(), folly::pushmi::detail::filter_fn::adapt_impl< Predicate >::operator()(), folly::pushmi::detail::submit_fn::fn< AN >::operator()(), folly::pushmi::detail::switch_on_error_fn::in_impl< ErrorSelector >::operator()(), folly::pushmi::detail::via_fn::on_value_impl< Out >::impl< V >::operator()(), folly::pushmi::detail::on_fn::time_out_impl< In, ExecutorFactory >::operator()(), folly::pushmi::detail::transform_on< F, is_single<>, true >::operator()(), folly::pushmi::detail::via_fn::on_value_impl< Out >::operator()(), folly::pushmi::detail::filter_fn::operator()(), wangle::ExpiringFilter< Req, Resp >::operator()(), folly::pushmi::detail::make_tap_fn::operator()(), folly::pushmi::detail::for_each_fn::fn< AN >::operator()(), folly::pushmi::detail::switch_on_error_fn::operator()(), folly::pushmi::detail::on_fn::in_impl< ExecutorFactory >::operator()(), folly::pushmi::detail::via_fn::on_error_impl< Out >::impl< E >::operator()(), wangle::SerialClientDispatcher< wangle::Pipeline, folly::Req, Resp >::operator()(), folly::pushmi::detail::submit_at_fn::fn< TP, AN >::operator()(), folly::pushmi::detail::receiver_from_impl< Cardinality, IsFlow >::operator()(), folly::pushmi::detail::via_fn::on_error_impl< Out >::operator()(), folly::pushmi::detail::transform_on< F, is_many<> >::operator()(), folly::pushmi::detail::on_fn::operator()(), folly::pushmi::detail::submit_at_fn::operator()(), folly::pushmi::detail::tap_fn::in_impl< AN >::operator()(), folly::pushmi::make_time_single_sender_fn::operator()(), wangle::ClientServiceFactory< Pipeline, Req, Resp >::ClientService::operator()(), folly::pushmi::detail::via_fn::on_done_impl< Out >::operator()(), folly::pushmi::detail::submit_after_fn::fn< D, AN >::operator()(), folly::pushmi::detail::tap_fn::out_impl::operator()(), folly::pushmi::detail::transform_on< F, is_many<>, true >::operator()(), fizz::server::AsyncFizzServerT< SM >::ActionMoveVisitor::operator()(), wangle::PipelinedClientDispatcher< Pipeline, Req, Resp >::operator()(), folly::pushmi::detail::tap_fn::operator()(), folly::pushmi::detail::submit_after_fn::operator()(), folly::pushmi::detail::submit_transform_out_1< In, FN >::operator()(), folly::pushmi::detail::via_fn::out_impl< In, ExecutorFactory >::operator()(), folly::pushmi::detail::transform_fn::impl< F >::operator()(), folly::pushmi::detail::submit_transform_out_2< In, FN >::operator()(), wangle::FactoryToService< Pipeline, Req, Resp >::operator()(), folly::pushmi::detail::via_fn::in_impl< ExecutorFactory >::operator()(), folly::pushmi::detail::submit_transform_out_3< In, SDSF >::operator()(), folly::pushmi::operators::flow_from_fn::out_impl< I, S, Exec >::operator()(), folly::pushmi::detail::transform_fn::operator()(), folly::pushmi::detail::submit_transform_out_4< In, TSDSF >::operator()(), folly::pushmi::detail::via_fn::operator()(), folly::pushmi::passDSF::operator()(), fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()(), folly::pushmi::passDZF::operator()(), folly::gen::Field< Class, FieldType >::operator()(), folly::pushmi::make_flow_many_sender_fn::operator()(), folly::gen::Move::operator()(), folly::pushmi::make_many_sender_fn::operator()(), folly::pushmi::make_flow_single_sender_fn::operator()(), folly::pushmi::make_single_sender_fn::operator()(), folly::pushmi::detail::sender_from_fn::operator()(), folly::pushmi::make_constrained_single_sender_fn::operator()(), folly::pushmi::strand_executor_factory_fn< E, ExecutorFactory >::operator()(), folly::dynamic::ObjectMaker::operator()(), folly::pushmi::detail::blocking_submit_fn::nested_executor_impl_fn::operator()(), std::hash< TestStruct >::operator()(), folly::pushmi::detail::set_value_fn::impl< VN >::operator()(), folly::pushmi::detail::blocking_submit_fn::on_error_impl::operator()(), folly::pushmi::detail::set_error_fn::impl< E >::operator()(), folly::pushmi::detail::set_error_fn::operator()(), folly::pushmi::detail::blocking_submit_fn::receiver_impl< In >::operator()(), folly::pushmi::detail::blocking_submit_fn::submit_impl< In >::operator()(), folly::pushmi::detail::set_starting_fn::impl< Up >::operator()(), folly::pushmi::detail::set_starting_fn::operator()(), folly::pushmi::detail::blocking_submit_fn::fn< AN >::operator()(), folly::pushmi::make_receiver_fn::operator()(), folly::pushmi::make_flow_receiver_fn::operator()(), folly::pushmi::detail::do_submit_fn::impl< Out >::operator()(), folly::pushmi::detail::do_submit_fn::time_impl< TP, Out >::operator()(), folly::pushmi::detail::do_submit_fn::operator()(), folly::pushmi::detail::get_fn< T >::operator()(), folly::fibers::FiberManager::AddTaskFinallyHelper< F, G >::Finally::operator()(), folly::detail::function::FunctionTraits< ReturnType(Args...) const >::SharedProxy::operator()(), folly::fibers::FiberManager::AddTaskFinallyHelper< F, G >::Func::operator()(), folly::pushmi::time_source_executor_factory_fn< E, TP, NF, ExecutorFactory >::operator()(), hash< folly::Optional< T > >::operator()(), folly::Try< folly::folly::Unit >::operator*(), folly::Optional< NamedGroup >::operator*(), folly::Replaceable< T >::operator*(), folly::Expected< int, E >::operator*(), operator+(), folly::operator+(), folly::exception_tracer::operator<<(), wangle::Subscription< T >::operator=(), proxygen::HTTPMessage::operator=(), proxygen::WheelTimerInstance::operator=(), folly::pushmi::detail::opt< std::tuple< std::decay_t< TN >... > >::operator=(), folly::Executor::KeepAlive< folly::VirtualEventBase >::operator=(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator=(), proxygen::HTTPHeaders::operator=(), folly::test::EnvVarSaver::operator=(), folly::pushmi::any_flow_many_sender< PE, PV, E, VN >::operator=(), folly::StringKeyedMap< Value, Compare, Alloc >::operator=(), folly::StringKeyedSetBase< Compare, Alloc >::operator=(), folly::Try< T >::operator=(), folly::pushmi::any_many_sender< E, VN >::operator=(), folly::pushmi::any_flow_single_sender< PE, E, VN >::operator=(), folly::pushmi::any_single_sender< E, VN >::operator=(), folly::IOBufQueue::WritableRangeCache::operator=(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::operator=(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::operator=(), folly::Indestructible< T >::operator=(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::Entry::operator=(), folly::pushmi::any_receiver< E, folly::pushmi::any_executor_ref< E > >::operator=(), folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), folly::MoveTester::operator=(), folly::ThreadLocalPtr< SubscriberMap >::operator=(), folly::MPMCPipeline< In, Stages >::Ticket< Stage >::operator=(), folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), folly::Optional< NamedGroup >::operator=(), folly::MPMCQueue< T, Atom, true >::operator=(), folly::detail::emplace_iterator_base< Derived, EmplaceImpl, false >::operator=(), folly::replaceable_detail::move_assignment_mixin< T, true >::operator=(), folly::hazptr_array< 3, Atom >::operator=(), folly::detail::emplace_iterator_base< Derived, EmplaceImpl, true >::operator=(), folly::expected_detail::MoveAssignable< ExpectedStorage< Value, Error, StorageType::eUnion >, StrictAllOf< IsMovable, Value, Error >::value, StrictAllOf< IsNothrowMovable, Value, Error >::value >::operator=(), folly::f14::SwapTrackingAlloc< T >::operator=(), folly::padded::Adaptor< IntNodeVec >::operator=(), folly::rcu_reader_domain< Tag >::operator=(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::operator=(), folly::f14::GenericAlloc< T >::operator=(), folly::IOBufQueue::operator=(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::operator=(), folly::SemiFuture< T >::operator=(), folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::operator=(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::operator=(), folly::Unexpected< Error >::operator=(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Iterator::operator=(), folly::fbvector< HTTPHeaderCode >::operator=(), folly::Expected< int, E >::operator=(), folly::Future< T >::operator=(), folly::basic_fbstring< E, T, A, Storage >::operator=(), folly::LockedPtr< SynchronizedType, LockPolicy >::operator=(), folly::gen::VirtualGen< Value >::operator=(), folly::dynamic::operator[](), operator|(), folly::gen::detail::operator|(), folly::pushmi::detail::opt< std::tuple< std::decay_t< TN >... > >::opt(), folly::Optional< NamedGroup >::Optional(), orderBy(), orderByDescending(), wangle::OutboundContextImpl< H >::OutboundContextImpl(), folly::pushmi::overload(), folly::pushmi::overload_fn< Fn, Fns... >::overload_fn(), folly::RequestContext::overwriteContextData(), parallel(), folly::json_pointer::parse(), fizz::parse(), proxygen::RFC1867Base::parse(), fizz::parse< ServerHello >(), proxygen::HTTP2Codec::parseAllData(), proxygen::StructuredHeadersBuffer::parseBinaryContent(), proxygen::HTTP2Codec::parseCertificate(), proxygen::HTTP2Codec::parseCertificateRequest(), proxygen::HTTP2Codec::parseContinuation(), proxygen::HTTP2Codec::parseDataFrameData(), proxygen::HTTP2Codec::parseExHeaders(), proxygen::HTTP2Codec::parseGoaway(), proxygen::HTTP2Codec::parseHeaders(), proxygen::SPDYCodec::parseHeaders(), proxygen::HTTP2Codec::parseHeadersDecodeFrames(), proxygen::HTTP2Codec::parseHeadersImpl(), proxygen::SPDYCodec::parseIngress(), folly::parseLeadingNumber(), folly::parseLogConfig(), folly::parseLogConfigDynamic(), proxygen::HTTP2Codec::parsePushPromise(), NaiveRoutingDataHandler::parseRoutingData(), proxygen::parseUnidirectional(), wangle::PeekingAcceptorHandshakeHelper::peekSuccess(), fizz::PeerCertImpl< T >::PeerCertImpl(), AsyncSocketGSOIntegrationTest::performPingPongTest(), AsyncSocketIntegrationTest::performPingPongTest(), folly::AsyncSocket::performRead(), folly::AsyncSocket::BytesWriteRequest::performWrite(), wangle::Acceptor::plaintextConnectionReady(), pmap(), folly::futures::detail::FutureBase< T >::poll(), folly::poly_cast(), folly::poly_move(), poolGetIOBuf(), poolPutIOBuf(), folly::IOBufQueue::pop_front(), folly::hazptr_obj_base< Node, Atom >::pre_retire(), folly::IOBufQueue::preallocateSlow(), folly::gen::detail::PMap< Predicate >::Generator< Value, Source, Input, Output >::ExecutionPipeline::predApplier(), folly::detail::SingletonHolder< T >::preDestroyInstance(), folly::recordio_helpers::prependHeader(), fizz::server::ServerStateMachine::processAccept(), fizz::server::test::MockServerStateMachine::processAccept(), fizz::client::ClientStateMachine::processAppWrite(), fizz::server::ServerStateMachine::processAppWrite(), fizz::client::ClientStateMachine::processConnect(), fizz::client::ClientStateMachine::processEarlyAppWrite(), fizz::server::ServerStateMachine::processEarlyAppWrite(), wangle::Acceptor::processEstablishedConnection(), fizz::server::detail::processEvent(), fizz::client::detail::processEvent(), proxygen::HTTPTransaction::processIngressBody(), proxygen::HTTPTransaction::processIngressHeadersComplete(), proxygen::HTTPTransaction::processIngressTrailers(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::processPendingEvents(), AtomicBatchDispatcherTesting::processSingleInput(), fizz::client::ClientStateMachine::processSocketData(), fizz::server::ServerStateMachine::processSocketData(), fizz::client::ClientStateMachine::processWriteNewSessionTicket(), fizz::server::ServerStateMachine::processWriteNewSessionTicket(), folly::futures::detail::Core< T >::proxyCallback(), folly::EvictingCacheMap< std::string, SSL_SESSION * >::pruneWithFailSafeOption(), folly::padded::Adaptor< IntNodeVec >::push_back(), folly::dynamic::push_back(), folly::small_vector< Observer< T > *, InlineObservers >::push_back(), folly::fbvector< HTTPHeaderCode >::push_back(), proxygen::HTTP1xCodec::pushHeaderNameAndValue(), folly::pushmi::many_sender< SF, EXF >::PUSHMI_EXP(), folly::pushmi::single_sender< SF, EXF >::PUSHMI_EXP(), folly::pushmi::flow_many_sender< Data, DSF, DEXF >::PUSHMI_EXP(), folly::pushmi::many_sender< Data, DSF, DEXF >::PUSHMI_EXP(), folly::pushmi::flow_single_sender< Data, DSF, DEXF >::PUSHMI_EXP(), folly::pushmi::single_sender< Data, DSF, DEXF >::PUSHMI_EXP(), folly::pushmi::make_receiver_fn::PUSHMI_EXP(), folly::pushmi::make_flow_receiver_fn::PUSHMI_EXP(), wangle::LRUPersistentCache< K, V, MutexT >::put(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::putMessagesImpl(), fizz::client::SynchronizedLruPskCache::putPsk(), fizz::client::BasicPskCache::putPsk(), fizz::client::FizzClientContext::putPsk(), folly::futures::detail::FutureBase< T >::raise(), folly::futures::detail::Core< T >::raise(), range(), folly::rcu_retire(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::reacquireLock(), fizz::PlaintextReadRecordLayer::read(), fizz::EncryptedReadRecordLayer::read(), wangle::test::FrameTester::read(), wangle::SerialServerDispatcher< Req, Resp >::read(), wangle::AcceptRoutingHandler< Pipeline, R >::read(), wangle::PipelinedServerDispatcher< Req, Resp >::read(), BonkMultiplexClientDispatcher::read(), wangle::ByteToMessageDecoder< T >::read(), wangle::SerialClientDispatcher< wangle::Pipeline, folly::Req, Resp >::read(), folly::ProducerConsumerQueue< T >::read(), wangle::MultiplexServerDispatcher< Req, Resp >::read(), wangle::PipelinedClientDispatcher< Pipeline, Req, Resp >::read(), wangle::ServerAcceptor< Pipeline >::read(), BogoTestServer::readBufferAvailable(), fizz::AsyncFizzBase::readBufferAvailable(), BogoTestClient::readBufferAvailable(), proxygen::HTTPSession::readBufferAvailable(), folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), fizz::server::readClientCertificate(), wangle::SocketPeeker::readDataAvailable(), folly::test::FileUtilTest::reader(), fizz::ReadRecordLayer::readEvent(), wangle::Handler< Resp, Resp, folly::Req, folly::Req >::readException(), wangle::InboundHandler< folly::IOBufQueue &, M >::readException(), wangle::Pipeline< R, W >::readException(), wangle::ContextImpl< H >::readException(), wangle::InboundContextImpl< H >::readException(), StaticService::StaticHandler::readFile(), proxygen::compress::CompressionSimulator::readInputFromFileAndSchedule(), folly::ReadMostlyMainPtr< T >::ReadMostlyMainPtr(), folly::ReadMostlySharedPtr< T >::ReadMostlySharedPtr(), readSelfCert(), proxygen::RFC1867Codec::readToBoundary(), fizz::test::LocalTransport::receiveData(), folly::pushmi::receiver< VF, EF, DF >::receiver(), folly::pushmi::receiver< Data, DVF, DEF, DDF >::receiver(), receiver_0_test(), receiver_1_test(), folly::AtomicHashMap< int64_t, int64_t >::recToIdx(), proxygen::compress::CompressionSimulator::recvAck(), proxygen::compress::QPACKScheme::recvAck(), reduce(), folly::reduce(), folly::Future< T >::reduce(), folly::observer_detail::Core::refresh(), wangle::MultiFilePoller::registerFile(), wangle::MultiFilePoller::registerFiles(), folly::detail::AtFork::registerHandler(), folly::LoggerDB::registerHandlerFactory(), folly::settings::detail::registerSetting(), folly::detail::SingletonHolder< T >::registerSingleton(), folly::detail::SingletonHolder< T >::registerSingletonMock(), folly::fibers::TimeoutController::registerTimeout(), folly::observer_detail::ObserverManager::DependencyRecorder::release(), folly::DynamicParser::ParserStack::releaseErrorsImpl(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::releaseLock(), proxygen::HTTP2PriorityQueue::Node::removeFromTree(), removeThreadTest(), proxygen::HTTP2PriorityQueue::Node::reparent(), folly::Replaceable< T >::Replaceable(), folly::pushmi::__adl::requires(), folly::fibers::TaskIterator< T >::reserve(), folly::AsyncIOOp::reset(), folly::ReadMostlyMainPtr< T >::reset(), folly::LoggerDB::resetConfig(), wangle::Acceptor::resetSSLContextConfigs(), fizz::test::HandshakeTest::resetTransports(), fizz::test::HandshakeTest::resetTransportsAndStartCookieHandshake(), folly::AsyncFileWriter::restartThread(), folly::coro::detail::InlineTaskPromise< T >::result(), folly::futures::detail::FutureBase< T >::result(), proxygen::HTTPTransaction::resumeIngress(), folly::hazptr_domain< DeterministicAtomic >::retire(), folly::hazptr_obj_base< Node, Atom >::retire(), folly::rcu_domain< Tag >::retire(), folly::rcu_obj_base< T, D, Tag >::retire(), folly::futures::detail::retrying(), folly::futures::detail::retryingImpl(), folly::futures::detail::retryingPolicyCappedJitteredExponentialBackoff(), folly::futures::retryingPolicyCappedJitteredExponentialBackoff(), folly::AtomicLinkedList< T >::reverseSweep(), folly::rref(), folly::ManualExecutor::run(), folly::TimedDrivableExecutor::run(), folly::SSLAcceptEvbRunner::run(), folly::SSLAcceptErrorRunner::run(), folly::SSLAcceptCloseRunner::run(), folly::SSLAcceptDestroyRunner::run(), run_queue_moving(), folly::TimeoutManager::runAfterDelay(), runBasicHoldersTest(), runBenchmark(), runContended(), runElementTypeTest(), runFairness(), folly::EventBase::runImmediatelyOrRunInEventBaseThreadAndWait(), folly::EventBase::runInEventBaseThread(), folly::EventBase::runInEventBaseThreadAndWait(), folly::EventBase::runInLoop(), folly::fibers::FiberManager::runInMainContext(), folly::TimeoutQueue::runInternal(), wangle::OutputBufferingHandler::runLoopCallback(), folly::EventBase::StackFunctionLoopCallback::runLoopCallback(), proxygen::HTTPSession::runLoopCallback(), folly::EventBase::runLoopCallbacks(), runMultiScopeTest(), folly::FunctionScheduler::runOneFunction(), runPerfectForwardingTest(), folly::fibers::FiberManager::runReadyFiber(), runRemoteUnlock(), folly::io::test::CompressionVarintTest::runSimpleTest(), folly::io::test::AutomaticCodecTest::runSimpleTest(), runUncontended(), sample(), folly::ScheduledExecutor::schedule(), folly::ManualExecutor::scheduleAt(), folly::EventBase::scheduleAt(), folly::observer_detail::ObserverManager::scheduleCurrent(), proxygen::compress::CompressionSimulator::scheduleEvent(), folly::observer_detail::ObserverManager::scheduleNext(), folly::observer_detail::ObserverManager::scheduleRefresh(), folly::observer_detail::ObserverManager::scheduleRefreshNewVersion(), folly::HHWheelTimer::scheduleTimeoutFn(), proxygen::ScopedHTTPServer::start< std::unique_ptr< RequestHandlerFactory > >(), proxygen::SecondaryAuthManager::SecondaryAuthManager(), proxygen::QPACKContext::seedHeaderTable(), proxygen::HPACKContext::seedHeaderTable(), fizz::SelfCertImpl< T >::SelfCertImpl(), folly::Future< folly::folly::Unit >::semi(), proxygen::ResponseBuilder::send(), proxygen::compress::CompressionSimulator::sendAck(), proxygen::RequestHandlerAdaptor::sendBody(), proxygen::ZlibServerFilter::sendBody(), proxygen::Filter::sendBody(), proxygen::HTTPSession::sendBody(), proxygen::HTTPTransaction::sendBody(), proxygen::HTTPTransaction::sendBodyNow(), proxygen::HTTPSession::sendCertificateRequest(), proxygen::HTTPTransaction::sendDeferredBody(), proxygen::ZlibServerFilter::sendEOM(), proxygen::HTTPSession::sendHeaders(), CurlService::CurlClient::sendRequest(), wangle::PipelinedServerDispatcher< Req, Resp >::sendResponses(), seq(), fizz::test::TestMessages::serverHello(), fizz::test::TestMessages::serverHelloPsk(), serverTest(), folly::detail::SlidingWindow< BucketT >::set(), folly::EvictingCacheMap< std::string, SSL_SESSION * >::set(), folly::hazptr_deleter< Node, D >::set_deleter(), folly::pushmi::__adl::set_error(), folly::pushmi::__adl::set_value(), fizz::Protocol::setAead(), fizz::EncryptedReadRecordLayer::setAead(), fizz::EncryptedWriteRecordLayer::setAead(), folly::AsyncSSLSocket::setAsyncOperationFinishCallback(), proxygen::HTTPSession::setByteEventTracker(), folly::futures::detail::Core< T >::setCallback(), fizz::server::test::FizzTestServer::setCertificate(), fizz::server::FizzServerContext::setCertManager(), wangle::TLSCredProcessor::setCertPathsToWatch(), proxygen::HTTPMessage::setClientAddress(), fizz::client::FizzClientContext::setClientCertificate(), fizz::server::FizzServerContext::setClientCertVerifier(), wangle::SSLContextManager::setClientVerifyCallback(), wangle::DefaultToFizzPeekingCallback::setContext(), folly::RequestContext::setContextData(), folly::RequestContext::setContextDataIfAbsent(), fizz::server::FizzServerContext::setCookieCipher(), folly::observer::detail::ObserverCreatorContext< Observable, Traits >::setCore(), folly::setCPUExecutor(), proxygen::HTTPException::setCurrentIngressBuf(), folly::dynamic::setDefault(), proxygen::HTTPSessionAcceptor::setDefaultErrorPage(), fizz::server::test::MockTicketCipher::setDefaults(), fizz::client::FizzClientContext::setDefaultShares(), proxygen::HTTPSessionAcceptor::setDiagnosticErrorPage(), proxygen::HTTPMessage::setDstAddress(), folly::AsyncSocket::setEvbChangedCallback(), folly::SharedPromise< T >::setException(), folly::futures::detail::CoreCallbackState< T, F >::setException(), folly::coro::TimedWaitAwaitable< Awaitable >::SharedState::setException(), folly::Promise< T >::setException(), folly::fibers::FiberManager::setExceptionCallback(), folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExceptionWrapper(), folly::futures::detail::FutureBase< T >::setExecutor(), folly::futures::detail::Core< T >::setExecutor(), folly::futures::detail::DeferredExecutor::setExecutor(), folly::IOObjectCache< T >::setFactory(), fizz::client::FizzClientContext::setFactory(), fizz::server::FizzServerContext::setFactory(), proxygen::HTTPConnector::setHTTPCodecFactory(), folly::futures::detail::Core< T >::setInterruptHandlerNoLock(), folly::setIOExecutor(), fizz::OpenSSLEVPCipher< EVPImpl >::setKey(), fizz::OpenSSLSignature< T >::setKey(), folly::ssl::setLockTypes(), folly::ssl::setLockTypesAndInit(), folly::EventBase::setMaxLatency(), fizz::client::test::ClientProtocolTest::setMockContextAndScheduler(), folly::futures::detail::DeferredExecutor::setNestedExecutors(), folly::AsyncIOOp::setNotificationCallback(), proxygen::HTTPException::setPartialMsg(), folly::AsyncSocket::setPeerCertificate(), wangle::LRUPersistentCache< K, V, MutexT >::setPersistence(), wangle::LRUPersistentCache< K, V, MutexT >::setPersistenceHelper(), folly::AsyncSocket::setPreReceivedData(), fizz::detail::OpenSSLECKeyExchange< T >::setPrivateKey(), fizz::client::FizzClientContext::setPskCache(), folly::futures::detail::Core< T >::setResult(), proxygen::HTTPSession::setSecondAuthManager(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::setSecrets(), folly::AsyncSocket::setSelfCertificate(), folly::AsyncSSLSocket::setSessionKey(), folly::AsyncSSLSocket::setSSLCertVerificationAlert(), FakeSessionCallbacks::setSSLSession(), wangle::ThreadSafeSSLSessionCache::setSSLSession(), fizz::client::FizzClientContext::setSupportedAlpns(), fizz::server::FizzServerContext::setSupportedAlpns(), fizz::client::FizzClientContext::setSupportedCiphers(), fizz::server::FizzServerContext::setSupportedCiphers(), fizz::client::FizzClientContext::setSupportedGroups(), fizz::server::FizzServerContext::setSupportedGroups(), fizz::extensions::TokenBindingContext::setSupportedKeyParameters(), fizz::client::FizzClientContext::setSupportedPskModes(), fizz::server::FizzServerContext::setSupportedPskModes(), fizz::client::FizzClientContext::setSupportedSigSchemes(), fizz::server::FizzServerContext::setSupportedSigSchemes(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::client::FizzClientContext::setSupportedVersions(), fizz::server::FizzServerContext::setSupportedVersions(), folly::ThreadPoolExecutor::setThreadFactory(), fizz::server::FizzServerContext::setTicketCipher(), fizz::server::test::AeadTicketCipherTest::setTicketSecrets(), folly::fibers::SimpleLoopController::setTimeFunc(), wangle::SSLSessionPersistentCacheBase< std::string >::setTimeUtil(), wangle::DefaultToFizzPeekingCallback::setTokenBindingContext(), proxygen::HTTPMessage::setTrailers(), fizz::test::LocalTransport::setTrickle(), folly::fibers::Promise< T, BatonT >::setTry(), folly::futures::detail::CoreCallbackState< T, F >::setTry(), folly::SharedPromise< T >::setTry(), folly::Promise< T >::setTry(), fizz::test::DefaultCertificateVerifierTest::SetUp(), fizz::test::KeySchedulerTest::SetUp(), fizz::test::EncryptedRecordTest::SetUp(), fizz::client::test::ClientProtocolTest::SetUp(), fizz::server::test::ServerProtocolTest::SetUp(), fizz::server::test::AeadCookieCipherTest::SetUp(), fizz::server::test::AsyncFizzServerTest::SetUp(), fizz::client::test::AsyncFizzClientTest::SetUp(), fizz::test::HandshakeTest::SetUp(), fizz::test::AuthenticatorTest::SetUp(), HTTP2UpstreamSessionWithVirtualNodesTest::SetUp(), MockHTTPUpstreamTest::SetUp(), fizz::client::test::ClientProtocolTest::setupExpectingCertificateVerify(), fizz::server::test::ServerProtocolTest::setUpExpectingCertificateVerify(), fizz::client::test::ClientProtocolTest::setupExpectingServerHello(), fizz::client::test::ClientProtocolTest::setupExpectingServerHelloAfterHrr(), proxygen::HTTPMessage::setUpgradeProtocol(), fizz::sm::setupSchedulerAndContext(), setupServer(), fizz::extensions::test::TokenBindingServerExtensionTest::setUpTokenBindingWithParameters(), fizz::extensions::test::ValidatorTest::setUpWithKeyParameters(), folly::observer::SimpleObservable< T >::setValue(), folly::detail::EventBaseLocalBase::setVoid(), fizz::setWriteDefaults(), fizz::JavaCryptoCertificateVerifier::setX509Store(), fizz::DefaultCertificateVerifier::setX509Store(), folly::AsyncSocket::setZeroCopyBuf(), folly::ShallowCopyRequestContextScopeGuard::ShallowCopyRequestContextScopeGuard(), folly::pushmi::shared_entangle(), folly::SharedPromise< T >::SharedPromise(), folly::observer::SimpleObservable< T >::SimpleObservable(), single_sender_test(), singleBatchDispatch(), folly::Singleton< folly::observer_detail::ObserverManager >::Singleton(), SlowMover::SlowMover(), folly::Subprocess::spawn(), folly::IOBufQueue::split(), folly::splitFuture(), proxygen::HTTPMessage::splitNameValue(), folly::AsyncSSLSocket::sslAccept(), folly::SSLContext::sslAcceptRunner(), wangle::Acceptor::sslConnectionReady(), wangle::BaseClientBootstrap< DefaultPipeline >::sslSessionEstablishedCallback(), folly::StandardLogHandler::StandardLogHandler(), wangle::UnencryptedAcceptorHandshakeHelper::start(), wangle::SSLAcceptorHandshakeHelper::start(), wangle::EvbHandshakeHelper::start(), wangle::SocketPeeker::start(), wangle::FizzAcceptorHandshakeHelper::start(), wangle::PeekingAcceptorHandshakeHelper::start(), MockHandshakeHelper< UseSharedPtrPolicy >::start(), wangle::AcceptorHandshakeManager::start(), proxygen::ScopedHTTPServer::start(), proxygen::HTTPServer::start(), UDPServer::start(), folly::coro::TaskWithExecutor< T >::start(), fizz::server::FizzServer< ActionMoveVisitor, SM >::startActions(), fizz::client::FizzClient< ActionMoveVisitor, SM >::startActions(), fizz::test::TestFizzBase::startActions(), folly::LoggerDB::startConfigUpdate(), wangle::Acceptor::startHandshakeManager(), wangle::PeekingAcceptorHandshakeManager::startHelper(), wangle::ExpiringFilter< Req, Resp >::startIdleTimer(), folly::pushmi::detail::for_each_fn::Pull< In, Out >::starting(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::starting(), proxygen::StaticHeaderTable::StaticHeaderTable(), folly::detail::partial::Partial< F, Tuple >::std::declval(), folly::futures::detail::stealDeferredExecutors(), folly::futures::detail::stealDeferredExecutorsVariadic(), folly::futures::detail::CoreCallbackState< T, F >::stealPromise(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::store(), folly::pushmi::strands(), folly::io::StreamCodec::StreamCodec(), streamSplitter(), sub(), folly::pushmi::new_thread_executor::submit(), folly::pushmi::subject< PS, TN... >::subject_shared::submit(), folly::pushmi::pool_executor< Executor >::submit(), folly::pushmi::any_flow_many_sender< PE, PV, E, VN >::submit(), folly::pushmi::any_many_sender< E, VN >::submit(), folly::pushmi::any_flow_single_sender< PE, E, VN >::submit(), folly::pushmi::subject< PS, TN... >::submit(), folly::pushmi::any_single_sender< E, VN >::submit(), inline_executor_flow_single< CancellationFactory >::submit(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::submit(), folly::pushmi::detail::trampoline< E >::submit(), folly::pushmi::flow_many_sender< SF, EXF >::submit(), folly::pushmi::flow_single_sender< SF, EXF >::submit(), folly::pushmi::constrained_single_sender< SF, ZF, EXF >::submit(), folly::pushmi::detail::blocking_submit_fn::nested_executor_impl::submit(), folly::pushmi::strand_executor< E, Executor >::submit(), folly::pushmi::constrained_single_sender< Data, DSF, DZF, DEXF >::submit(), inline_executor_flow_many::submit(), folly::pushmi::time_source_executor< E, TP, NF, Executor >::submit(), folly::pushmi::detail::submit_transform_out(), subscribeImpl(), wangle::Observable< T >::subscribeImpl(), folly::ThreadPoolExecutor::subscribeToTaskStats(), wangle::Subscription< T >::Subscription(), folly::basic_fbstring< char >::substr(), folly::Optional< NamedGroup >::swap(), folly::exception_wrapper::swap(), folly::small_vector< Observer< T > *, InlineObservers >::swap(), folly::Expected< int, E >::swap(), folly::AtomicLinkedList< T >::sweep(), folly::rcu_domain< Tag >::synchronize(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::Synchronized(), wangle::LRUPersistentCache< K, V, MutexT >::syncNow(), folly::ThreadPoolExecutor::StoppedThreadQueue::take(), folly::IOBuf::takeOwnershipIov(), folly::Subprocess::takeOwnershipOfPipes(), takeWhile(), folly::TDigest::TDigest(), fizz::server::test::TEST(), folly::TEST(), folly::test::TEST(), fizz::test::TEST(), TEST(), wangle::TEST(), folly::io::test::TEST(), folly::detail::TEST_F(), fizz::extensions::test::TEST_F(), fizz::server::test::TEST_F(), folly::TEST_F(), fizz::test::TEST_F(), proxygen::TEST_F(), TEST_F(), fizz::client::test::TEST_F(), test_iteratorInsertionRV3(), test_moveAssignment3(), test_moveConstruction3(), test_moveConstructionWithAllocatorSupplied3(), fizz::testing::TEST_P(), fizz::test::TEST_P(), proxygen::TEST_P(), TEST_P(), folly::io::test::TEST_P(), test_pushBackRV3(), MockCodecDownstreamTest::testConnFlowControlBlocked(), folly::sync_tests::testExchange(), folly::TestExecutor::TestExecutor(), testExpectHandling(), MockCodecDownstreamTest::testGoaway(), testIsRelocatable(), folly::TestLogHandler::TestLogHandler(), HTTPDownstreamTest< C >::testPriorities(), testRandom(), testRangeFunc(), folly::sync_tests::testUnlock(), folly::Future< folly::folly::Unit >::then(), folly::Future< T >::then(), folly::Expected< int, E >::then(), folly::Future< T >::thenError(), folly::Future< folly::folly::Unit >::thenError(), folly::futures::detail::FutureBase< T >::thenImplementation(), folly::Future< folly::folly::Unit >::thenMulti(), folly::Future< folly::folly::Unit >::thenMultiWithExecutor(), folly::Expected< int, E >::thenOrThrow(), folly::Future< T >::thenTry(), folly::Future< folly::folly::Unit >::thenTry(), folly::Future< T >::thenValue(), folly::Future< folly::folly::Unit >::thenValue(), folly::CPUThreadPoolExecutor::threadRun(), wangle::ServerWorkerPool::threadStopped(), time_single_sender_test(), folly::fibers::SimpleLoopController::timedSchedule(), DelayedWrite::timeoutExpired(), folly::to(), folly::to_shared_ptr(), folly::toAppend(), folly::bser::toBserIOBuf(), toFile(), folly::toStdString(), folly::SemiFuture< T >::toUnsafeFuture(), folly::Try< T >::Try(), folly::UnboundedQueue< T, false, 6 >::try_dequeue(), folly::UnboundedQueue< T, false, 6 >::try_dequeue_for(), folly::UnboundedQueue< T, false, 6 >::try_dequeue_until(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue(), MPMC< T >::try_enqueue(), PCQ< T >::try_enqueue(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_for(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_until(), folly::json_pointer::try_parse(), folly::json_patch::try_parse(), folly::UnboundedBlockingQueue< T >::try_take_for(), folly::LifoSemMPMCQueue< T, kBehavior >::try_take_for(), folly::PriorityLifoSemMPMCQueue< T, kBehavior >::try_take_for(), folly::ThreadPoolExecutor::StoppedThreadQueue::try_take_for(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::tryConsume(), fizz::OpenSSLEVPCipher< EVPImpl >::tryDecrypt(), folly::IPAddressV4::tryFromBinary(), folly::IPAddressV6::tryFromBinary(), folly::TimeoutManager::tryRunAfterDelay(), folly::tryTo(), fizz::test::TYPED_TEST(), TYPED_TEST(), TYPED_TEST_P(), folly::io::test::uncompressSome(), unique_ptr_test(), folly::Future< folly::folly::Unit >::unit(), folly::rcu_reader_domain< Tag >::unlock(), folly::unorderedReduce(), folly::detail::emplace_iterator_base< Derived, EmplaceImpl, false >::unpackAndEmplace(), until(), folly::Future< T >::unwrap(), testing::internal::ReferenceOrValueWrapper< T >::Unwrap(), folly::detail::unwrap_emplace_arg(), folly::LogConfig::update(), folly::LoggerDB::updateConfig(), wangle::Acceptor::updateFizzContext(), proxygen::HTTPServerOptions::useExistingSocket(), proxygen::HTTPServerOptions::useExistingSockets(), AtomicBatchDispatcherTesting::userDispatchFunc(), fizz::ExportedAuthenticator::validate(), fizz::sm::validateAcceptedEarly(), proxygen::SecondaryAuthManager::validateAuthenticator(), fizz::ExportedAuthenticator::validateAuthenticator(), AtomicBatchDispatcherTesting::validateResults(), fizz::extensions::Validator::validateTokenBinding(), folly::pushmi::strand_queue< E, Executor >::value(), folly::pushmi::any_flow_receiver< PE, PV, E, VN >::value(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::value(), folly::Try< T >::value(), folly::futures::detail::FutureBase< T >::value(), folly::expected_detail::ExpectedStorage< Value, Error >::value(), folly::Optional< NamedGroup >::value(), folly::expected_detail::ExpectedUnion< Value, Error >::value(), folly::expected_detail::ExpectedStorage< Value, Error, StorageType::ePODStruct >::value(), folly::Expected< int, E >::value(), folly::Optional< NamedGroup >::value_or(), folly::Expected< int, E >::value_or(), fizz::JavaCryptoPeerCert::verify(), proxygen::SecondaryAuthManager::verifyContext(), folly::SemiFuture< T >::via(), folly::Future< T >::via(), folly::via(), virtualExecutorTest(), visit(), folly::SemiFuture< T >::wait(), folly::Future< T >::wait(), folly::futures::detail::waitImpl(), folly::Future< T >::waitVia(), folly::futures::detail::waitViaImpl(), WeakRefTest(), folly::whileDo(), folly::AsyncSSLSocket::willBlock(), folly::window(), folly::exception_wrapper::with_exception(), folly::exception_wrapper::with_exception_(), folly::Try< folly::folly::Unit >::withException(), folly::Try< void >::withException(), folly::SemiFuture< T >::within(), folly::Future< T >::within(), folly::futures::detail::FutureBase< T >::withinImplementation(), folly::pushmi::time_source_shared< E, time_point >::worker(), folly::VirtualExecutor::wrapFunc(), folly::IOBuf::wrapIov(), wangle::EventBaseHandler::write(), folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >::write(), wangle::MessageToByteEncoder< T >::write(), wangle::OutputBufferingHandler::write(), wangle::StringCodec::write(), fizz::PlaintextWriteRecordLayer::write(), wangle::test::BytesReflector::write(), folly::PriorityMPMCQueue< T, Atom, Dynamic >::write(), wangle::LengthFieldPrepender::write(), fizz::EncryptedWriteRecordLayer::write(), wangle::AsyncSocketHandler::write(), folly::AsyncPipeWriter::write(), folly::detail::RingBufferSlot< T, Atom >::write(), fizz::WriteRecordLayer::writeAlert(), fizz::WriteRecordLayer::writeAppData(), fizz::server::AsyncFizzServerT< SM >::writeAppData(), fizz::client::AsyncFizzClientT< SM >::writeAppData(), folly::ZeroCopyTestAsyncSocket::writeBuffer(), proxygen::http2::writeCertificate(), proxygen::http2::writeCertificateRequest(), folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::writeChain(), fizz::AsyncFizzBase::writeChain(), fizz::test::LocalTransport::writeChain(), proxygen::PassThroughTransportFilter::writeChain(), folly::AsyncPipeWriter::writeChain(), folly::AsyncSocket::writeChain(), folly::AsyncSocket::writeChainImpl(), proxygen::http2::writeContinuation(), proxygen::http2::writeData(), proxygen::HTTPSession::WriteSegment::writeErr(), wangle::Handler< Resp, Resp, folly::Req, folly::Req >::writeException(), wangle::OutboundHandler< std::string, std::unique_ptr< folly::IOBuf > >::writeException(), wangle::Pipeline< R, W >::writeException(), wangle::ContextImpl< H >::writeException(), wangle::OutboundContextImpl< H >::writeException(), proxygen::http2::writeExHeaders(), proxygen::http2::writeGoaway(), fizz::WriteRecordLayer::writeHandshake(), proxygen::http2::writeHeaders(), folly::AsyncSocket::writeImpl(), fizz::PlaintextWriteRecordLayer::writeInitialClientHello(), folly::AsyncFileWriter::writeMessage(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::writeNewSessionTicket(), fizz::sm::writeNewSessionTicket(), UDPClient::writePing(), proxygen::http2::writePushPromise(), folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >::writev(), folly::PriorityMPMCQueue< T, Atom, Dynamic >::writeWithPriority(), folly::ThreadCachedArena::zombify(), wangle::AsyncSocketHandler::~AsyncSocketHandler(), folly::FunctionScheduler::~FunctionScheduler(), folly::rcu_reader_domain< Tag >::~rcu_reader_domain(), folly::RequestContextScopeGuard::~RequestContextScopeGuard(), folly::ScopedBoundPort::~ScopedBoundPort(), folly::ScopedUnlocker< SynchronizedType, LockPolicy >::~ScopedUnlocker(), folly::ShallowCopyRequestContextScopeGuard::~ShallowCopyRequestContextScopeGuard(), and folly::fibers::StackCacheEntry::~StackCacheEntry().

constexpr detail::IsEmpty<false> folly::gen::notEmpty {}

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

Referenced by TEST().

constexpr detail::Order<Identity> folly::gen::order {}

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

Referenced by TEST().

constexpr detail::RangeConcat folly::gen::rconcat {}

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

Referenced by BENCHMARK_RELATIVE(), and TEST().

constexpr detail::Sum folly::gen::sum {}

non-template operators, statically defined to avoid the need for anything but the header.

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

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), and TEST().

constexpr detail::Unwrap folly::gen::unwrap {}

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

Referenced by folly::Future< folly::folly::Unit >::Future(), folly::f14::TransparentTrackedEqual< Tag >::operator()(), and TEST().