folly::detail Namespace Reference

Namespaces
	apply_tuple
	atomic_notification
	concurrenthashmap
	distributed_mutex
	fixedstring
	function
	impl
	member
	partial
	propagate_const_adl

Classes
struct	AllocatorCustomizesConstruct_
struct	AllocatorCustomizesConstruct_< void_t< typename Alloc::folly_has_default_object_construct >, Alloc, Args... >
struct	AllocatorCustomizesDestroy_
struct	AllocatorCustomizesDestroy_< void_t< typename Alloc::folly_has_default_object_destroy >, Alloc, Args... >
struct	AmplificationProduct
struct	AmplificationProduct< std::tuple< T, Ts... > >
struct	AmplificationProduct< std::tuple<> >
struct	ArgumentTypesByKind
struct	ArgumentTypesByKind< IdentifyCallable::Kind::Function, Fn >
struct	ArgumentTypesByKind< IdentifyCallable::Kind::MemberFunction, Fn >
struct	async_timeout_wrapper
struct	AtFork
struct	AtomicStructRaw
struct	AtomicStructRaw< 0 >
struct	AtomicStructRaw< 1 >
struct	AtomicStructRaw< 2 >
struct	AtomicStructRaw< 3 >
struct	BenchmarkRegistration
struct	BenchmarkResult
struct	BitsTraits
struct	Bucket
class	BufferedDigest
class	BufferedSlidingWindow
class	BufferedStat
struct	Bytes
struct	CheckOverflowToDuration
struct	CheckOverflowToDuration< true >
struct	CheckTrailingSpace
struct	cmp_pred
struct	ComparableAsStringPiece
class	CompressionCounter
	Wrapper around the makeCompressionCounterHandler() extension point. More...
class	ConcurrentHashMapSegment
struct	constexpr_abs_helper
struct	constexpr_abs_helper< T, typename std::enable_if< std::is_floating_point< T >::value >::type >
struct	constexpr_abs_helper< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value &&std::is_signed< T >::value >::type >
struct	constexpr_abs_helper< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value &&std::is_unsigned< T >::value >::type >
class	csl_iterator
struct	DefaultMake
struct	DefaultTag
struct	DefaultType
struct	DefaultType< Default >
struct	DefaultType< Key, KeysDefault... >
struct	DefaultValueWrapper
struct	Destroy
class	DigestBuilder
struct	DoNotOptimizeAwayNeedsIndirect
struct	DynamicHasher
struct	DynamicKeyEqual
struct	Emplace
class	emplace_iterator_base
class	emplace_iterator_base< Derived, EmplaceImpl, false >
class	emplace_iterator_base< Derived, EmplaceImpl, true >
class	emplace_iterator_impl
struct	EmplaceBack
struct	EmplaceFront
struct	EmplaceHint
struct	Empty
struct	EmulatedFutexAtomic
struct	EndianInt
class	Enumerator
class	EventBaseLocalBase
class	EventBaseLocalBaseBase
class	FingerprintPolynomial
struct	FingerprintTable
struct	float_hasher
struct	format_table_align_make_item
struct	format_table_conv_make_item
struct	format_table_sign_make_item
class	FormatterTag
struct	FormatTraitsBase
struct	free_invoke_proxy
struct	GivesZeroFilledMemory
struct	GivesZeroFilledMemory< MMapAlloc >
class	GroupVarintBase
struct	GroupVarintTraits
struct	GroupVarintTraits< uint32_t >
struct	GroupVarintTraits< uint64_t >
struct	growth_policy_wrapper
struct	growth_policy_wrapper< void >
struct	HasArgumentTypes
class	HasLess
class	HistogramBuckets
class	IdentifyCallable
struct	IndexableTraits
struct	IndexableTraits< fbvector< T, A > >
struct	IndexableTraits< small_vector< T, M, A, B, C > >
struct	IndexableTraitsAssoc
struct	IndexableTraitsSeq
struct	IndexedMemPoolRecycler
struct	integral_hasher
struct	IntegralSizePolicy
struct	IntegralSizePolicy< SizeType, false >
struct	IntegralSizePolicy< SizeType, true >
struct	IntegralSizePolicyBase
struct	IntermediateTimeRep
struct	IntermediateTimeRep< T, false, false >
struct	IntermediateTimeRep< T, false, true >
struct	IntermediateTimeRep< T, true, IsSigned >
struct	is_chrono_conversion
struct	is_duration
struct	is_duration< std::chrono::duration< Rep, Period > >
struct	is_negative_impl
struct	is_negative_impl< T, false >
struct	is_posix_time_type
struct	is_propagate_const
struct	is_propagate_const< propagate_const< Pointer > >
struct	is_std_chrono_type
struct	is_time_point
struct	is_time_point< std::chrono::time_point< Clock, Duration > >
struct	IsAvalanchingHasherFromMemberType
struct	IsAvalanchingHasherFromMemberType< Hasher, void_t< typename Hasher::folly_is_avalanching > >
struct	IsCharPointer
struct	IsCharPointer< char * >
struct	IsCharPointer< const char * >
struct	IsConvertible
struct	IsConvertible< void, decltype(std::ignore)>
struct	IsFormatter
struct	IsFormatter< T, typename std::enable_if< std::is_same< typename T::IsFormatter, detail::FormatterTag >::value >::type >
struct	IsSizableString
struct	IsSizableStringContainerIterator
struct	IsUniquePtrToSL
struct	IsUniquePtrToSL< std::unique_ptr< T, D > >
class	IteratorAdaptor
class	IteratorFacade
struct	LastElement
struct	LastElementImpl
struct	LastElementImpl< Head, Ts... >
struct	Lazy
struct	LifoSemBase
class	LifoSemHead
struct	LifoSemNode
struct	LifoSemNodeRecycler
struct	LifoSemRawNode
struct	lift_void_to_char
struct	lift_void_to_char< void >
struct	like_
struct	like_< Src & >
struct	like_< Src && >
struct	like_< Src const >
struct	like_< Src const volatile >
struct	like_< Src volatile >
class	LockInterfaceDispatcher
struct	LockTraitsImpl
struct	LockTraitsImpl< Mutex, MutexLevel::SHARED, false >
struct	LockTraitsImpl< Mutex, MutexLevel::SHARED, true >
struct	LockTraitsImpl< Mutex, MutexLevel::UNIQUE, false >
struct	LockTraitsImpl< Mutex, MutexLevel::UNIQUE, true >
struct	LockTraitsImpl< Mutex, MutexLevel::UPGRADE, false >
struct	LockTraitsImpl< Mutex, MutexLevel::UPGRADE, true >
struct	MakeConst
struct	MakeConst< T & >
struct	MakeConst< T * >
struct	max_align_t_
struct	member_invoke_proxy
struct	MemoryIdler
struct	MetaBindBack
struct	MetaBindFront
struct	MetaCompose
class	MetaDefer
struct	MetaFlip
struct	MetaIdentity
struct	MetaQuote
class	MMapAlloc
class	MPMCPipelineStageImpl
class	MPMCQueueBase
	MPMCQueue base CRTP template. More...
class	MPMCQueueBase< Derived< T, Atom, Dynamic > >
	CRTP specialization of MPMCQueueBase. More...
struct	MutexLevelValueImpl
struct	MutexLevelValueImpl< true, false, false >
struct	MutexLevelValueImpl< true, true, false >
struct	MutexLevelValueImpl< true, true, true >
struct	NestedMapType
struct	NestedMapType< T, 1 >
class	NodeRecycler
class	NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >
class	NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >
struct	notification_queue_consumer_wrapper
struct	OptionalPromiseReturn
struct	OutputType
struct	Overload
struct	Overload< Case >
struct	Overload< Case, Cases... >
struct	PipelineStageInfo
struct	PipelineStageInfo< MPMCPipelineStage< T, Amp > >
class	RangeEnumerator
class	ReadMostlySharedPtrCore
struct	ReturnUnit
class	RingBufferSlot
class	ScopeGuardImpl
class	ScopeGuardImplBase
struct	SeedData
class	shared_ptr_internals
struct	ShellCmdFormat
class	SignedValueHandler
class	SignedValueHandler< T, false >
class	SignedValueHandler< T, true >
struct	SingleElementQueue
struct	SingletonHolder
class	SingletonHolderBase
struct	SingletonVaultState
class	SkipListNode
class	SkipListRandomHeight
class	Sleeper
class	SlidingWindow
class	SlowFingerprint
struct	small_vector_base
struct	sorted_vector_enable_if_is_transparent
struct	sorted_vector_enable_if_is_transparent< void_t< typename Compare::is_transparent >, Compare, Key, T >
struct	StateSize
struct	StateSize< RNG, void_t< decltype(RNG::state_size)> >
struct	StateSize< std::linear_congruential_engine< UIntType, a, c, m > >
struct	StateSize< std::subtract_with_carry_engine< UIntType, w, s, r > >
class	StaticSingletonManager
struct	StaticSingletonManagerTest
struct	string_table_c_escape_make_item
struct	string_table_c_unescape_make_item
struct	string_table_hex_make_item
struct	string_table_uri_escape_make_item
class	StringPieceLite
class	SynchronizedLocker
struct	Tag
class	ThreadCachedInts
class	ThreadCachedLists
class	ThreadCachedListsBase
struct	TransparentRangeEqualTo
struct	TransparentRangeHash
struct	TupleSelect
struct	TupleSelect< TemplateSeq< std::size_t, Ns... > >
struct	TurnSequencer
struct	Type
struct	type
struct	type
struct	type
class	TypeDescriptor
class	TypeDescriptorHasher
struct	TypeList
struct	uint_types_by_size
struct	uint_types_by_size< 16/8 >
struct	uint_types_by_size< 32/8 >
struct	uint_types_by_size< 64/8 >
struct	uint_types_by_size< 8/8 >
struct	UnlockPolicyExclusive
struct	UnlockPolicyShared
struct	UnlockPolicyUpgrade
struct	ValueTypeForTransparentConversionToRange
struct	ValueTypeForTransparentConversionToRange< T, void_t< decltype(std::declval< hasher< Range< typename T::value_type const * >>>()(std::declval< Range< typename T::value_type const * >>()))>

Typedefs
using	TimeIterPair = std::pair< std::chrono::high_resolution_clock::duration, unsigned int >
using	BenchmarkFun = std::function< detail::TimeIterPair(unsigned int)>
template<typename Rep , typename Period >
using	IntermediateDuration = std::chrono::duration< typename IntermediateTimeRep< Rep, std::is_floating_point< Rep >::value, std::is_signed< Rep >::value >::type, std::ratio< 1, Period::den >>
template<typename T >
using	TransparentlyConvertibleToRange = std::is_convertible< T, Range< typename ValueTypeForTransparentConversionToRange< T >::type const * >>
template<typename Tgt , typename Src >
using	IsArithToArith = bool_constant< !std::is_same< Tgt, Src >::value &&!std::is_same< Tgt, bool >::value &&std::is_arithmetic< Src >::value &&std::is_arithmetic< Tgt >::value >
template<typename Tgt >
using	ParseToResult = decltype(parseTo(StringPiece{}, std::declval< Tgt & >()))
template<typename Tgt >
using	ParseToError = ExpectedErrorType< decltype(detail::parseToWrap(StringPiece{}, std::declval< Tgt & >()))>
template<template< typename > class Atom = std::atomic>
using	Futex = Atom< std::uint32_t >
template<bool B>
using	Bool = bool_constant< B >
using	True = std::true_type
using	False = std::false_type
template<class Fn , class... Ts>
using	MetaApply = typename Fn::template apply< Ts... >
template<bool If_, class Then , class Else >
using	If = MetaApply< impl::If_< If_ >, Then, Else >
template<template< class... > class C>
using	MetaQuoteTrait = MetaCompose< MetaQuote< _t >, MetaQuote< C >>
template<class Fn >
using	MetaCurry = MetaCompose< Fn, MetaQuote< TypeList >>
template<class Fn >
using	MetaUncurry = MetaBindBack< MetaQuote< MetaApply >, Fn >
template<class List , class... Ts>
using	TypePushBack = MetaApply< List, MetaBindBack< MetaQuote< TypeList >, Ts... >>
template<class List , class... Ts>
using	TypePushFront = MetaApply< List, MetaBindFront< MetaQuote< TypeList >, Ts... >>
template<class Fn , class List >
using	MetaUnpack = MetaApply< List, Fn >
template<class List , class Fn >
using	TypeTransform = MetaApply< List, impl::TypeTransform_< Fn >>
template<class List , class State , class Fn >
using	TypeFold = MetaApply< MetaApply< List, impl::FoldR_< Fn >>, State >
template<class List , class State , class Fn >
using	TypeReverseFold = MetaApply< MetaApply< List, impl::FoldL_< Fn >>, State >
template<class List >
using	Inherit = impl::Inherit_< List >
template<class List >
using	TypeUnique = TypeFold< List, TypeList<>, impl::Unique_ >
template<class List >
using	TypeReverseUnique = TypeReverseFold< List, TypeList<>, MetaFlip< impl::Unique_ >>
template<class T >
using	AsTypeList = _t< impl::AsTypeList_< T >>
template<class List >
using	TypeJoin = MetaApply< TypeFold< List, MetaQuote< TypeList >, impl::Join_ >>
template<class... Ts>
using	TypeConcat = TypeJoin< TypeList< Ts... >>
template<typename Fn >
using	ArgumentTypes = typename ArgumentTypesByKind< IdentifyCallable::getKind< Fn >(), Fn >::type
template<typename... Args>
using	EnableForArgTypes = typename std::enable_if< HasArgumentTypes< Args... >::value, void >::type
template<size_t Deg>
using	poly_table = std::array< std::array< std::array< uint64_t, poly_size(Deg)>, 256 >, 8 >
using	max_align_v_ = max_align_t_< long double, double, float, long long int, long int, int, short int, bool, char, char16_t, char32_t, wchar_t, void *, std::max_align_t >
template<typename T >
using	is_decay_propagate_const = is_propagate_const< _t< std::decay< T >>>
template<typename N , typename D >
using	IdivResultType = typename std::enable_if< std::is_integral< N >::value &&std::is_integral< D >::value &&!std::is_same< N, bool >::value &&!std::is_same< D, bool >::value, decltype(N{1}/D{1})>::type
template<typename RNG >
using	StateSizeT = _t< StateSize< RNG >>
template<typename F , bool INE>
using	ScopeGuardImplDecay = ScopeGuardImpl< typename std::decay< F >::type, INE >
template<class SynchronizedType >
using	SynchronizedDataType = typename std::conditional< std::is_const< SynchronizedType >::value, typename SynchronizedType::DataType const, typename SynchronizedType::DataType >::type
template<class SynchronizedType >
using	LockedPtrType = typename std::conditional< std::is_const< SynchronizedType >::value, typename SynchronizedType::ConstLockedPtr, typename SynchronizedType::LockedPtr >::type

Enumerations
enum	FutexResult { FutexResult::VALUE_CHANGED, FutexResult::AWOKEN, FutexResult::INTERRUPTED, FutexResult::TIMEDOUT }
enum	MutexLevel { MutexLevel::UNIQUE, MutexLevel::SHARED, MutexLevel::UPGRADE }
enum	ScopeGuardOnExit
enum	spin_result { spin_result::success, spin_result::timeout, spin_result::advance }

Functions
template<typename NotKeyT , typename KeyT >
void	checkLegalKeyIfKeyTImpl (NotKeyT, KeyT, KeyT, KeyT)
template<typename KeyT >
void	checkLegalKeyIfKeyTImpl (KeyT key_in, KeyT emptyKey, KeyT lockedKey, KeyT erasedKey)
void	addBenchmarkImpl (const char *file, const char *name, std::function< TimeIterPair(unsigned int)>)
template<typename Src >
Expected< time_t, ConversionCode >	chronoRangeCheck (Src value)
template<typename SubsecondRatio , typename Rep >
static Expected< std::pair< time_t, long >, ConversionCode >	durationToPosixTime (const std::chrono::duration< Rep, std::ratio< 1, 1 >> &duration)
template<typename SubsecondRatio , typename Rep , std::intmax_t Denominator>
static Expected< std::pair< time_t, long >, ConversionCode >	durationToPosixTime (const std::chrono::duration< Rep, std::ratio< 1, Denominator >> &duration)
template<typename SubsecondRatio , typename Rep , std::intmax_t Numerator>
static Expected< std::pair< time_t, long >, ConversionCode >	durationToPosixTime (const std::chrono::duration< Rep, std::ratio< Numerator, 1 >> &duration)
template<typename SubsecondRatio , typename Rep , typename Period >
Expected< std::pair< time_t, long >, ConversionCode >	durationToPosixTime (const std::chrono::duration< Rep, Period > &duration)
template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep >
auto	posixTimeToDuration (Seconds seconds, Subseconds subseconds, std::chrono::duration< Rep, std::ratio< 1, 1 >> dummy) -> Expected< decltype(dummy), ConversionCode >
template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Denominator>
auto	posixTimeToDuration (Seconds seconds, Subseconds subseconds, std::chrono::duration< Rep, std::ratio< 1, Denominator >> dummy) -> Expected< decltype(dummy), ConversionCode >
template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Numerator>
auto	posixTimeToDuration (Seconds seconds, Subseconds subseconds, std::chrono::duration< Rep, std::ratio< Numerator, 1 >> dummy) -> Expected< decltype(dummy), ConversionCode >
template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Denominator, std::intmax_t Numerator>
auto	posixTimeToDuration (Seconds seconds, Subseconds subseconds, std::chrono::duration< Rep, std::ratio< Numerator, Denominator >> dummy) -> Expected< decltype(dummy), ConversionCode >
template<typename Tgt , typename SubsecondRatio , typename Seconds , typename Subseconds >
Expected< Tgt, ConversionCode >	tryPosixTimeToDuration (Seconds seconds, Subseconds subseconds)
template<typename T >
constexpr T	constexpr_log2_ (T a, T e)
template<typename T >
constexpr T	constexpr_log2_ceil_ (T l2, T t)
template<typename T >
constexpr T	constexpr_square_ (T t)
template<typename U >
constexpr std::size_t	constexpr_find_first_set_ (std::size_t s, std::size_t a, U const u)
template<typename D , typename S >
constexpr D	constexpr_clamp_cast_helper (S src, S sl, S su, D dl, D du)
template<class Iterator >
FOLLY_ALWAYS_INLINE auto	getPointer (const Iterator &it, long) -> decltype(std::addressof(*it))
template<class Iterator >
FOLLY_ALWAYS_INLINE auto	getPointer (const Iterator &it, int) -> decltype(it.operator->())
template<class T , class U >
std::enable_if< (std::is_arithmetic< T >::value &&std::is_arithmetic< U >::value)||(std::is_pointer< T >::value &&std::is_pointer< U >::value), bool >::type	notThereYet (T &iter, const U &end)
template<class T , class U >
std::enable_if< !((std::is_arithmetic< T >::value &&std::is_arithmetic< U >::value)||(std::is_pointer< T >::value &&std::is_pointer< U >::value)), bool >::type	notThereYet (T &iter, const U &end)
template<class T , class U >
std::enable_if< HasLess< U, T >::value, bool >::type	downTo (T &iter, const U &begin)
template<class T , class U >
std::enable_if<!HasLess< U, T >::value, bool >::type	downTo (T &iter, const U &begin)
template<typename Arg >
decltype(auto)	unwrap_emplace_arg (Arg &&arg) noexcept
template<typename Arg >
decltype(auto)	unwrap_emplace_arg (std::reference_wrapper< Arg > arg) noexcept
template<typename Arg >
decltype(auto)	unwrap_emplace_arg (folly::rvalue_reference_wrapper< Arg > arg) noexcept
Expected< bool, ConversionCode >	str_to_bool (StringPiece *src) noexcept
template<class Tgt >
Expected< Tgt, ConversionCode >	str_to_floating (StringPiece *src) noexcept
template Expected< float, ConversionCode >	str_to_floating< float > (StringPiece *src) noexcept
template Expected< double, ConversionCode >	str_to_floating< double > (StringPiece *src) noexcept
template<class Tgt >
Expected< Tgt, ConversionCode >	digits_to (const char *b, const char *const e) noexcept
template Expected< char, ConversionCode >	digits_to< char > (const char *, const char *) noexcept
template Expected< signed char, ConversionCode >	digits_to< signed char > (const char *, const char *) noexcept
template Expected< unsigned char, ConversionCode >	digits_to< unsigned char > (const char *, const char *) noexcept
template Expected< short, ConversionCode >	digits_to< short > (const char *, const char *) noexcept
template Expected< unsigned short, ConversionCode >	digits_to< unsigned short > (const char *, const char *) noexcept
template Expected< int, ConversionCode >	digits_to< int > (const char *, const char *) noexcept
template Expected< unsigned int, ConversionCode >	digits_to< unsigned int > (const char *, const char *) noexcept
template Expected< long, ConversionCode >	digits_to< long > (const char *, const char *) noexcept
template Expected< unsigned long, ConversionCode >	digits_to< unsigned long > (const char *, const char *) noexcept
template Expected< long long, ConversionCode >	digits_to< long long > (const char *, const char *) noexcept
template Expected< unsigned long long, ConversionCode >	digits_to< unsigned long long > (const char *, const char *) noexcept
template<class Tgt >
Expected< Tgt, ConversionCode >	str_to_integral (StringPiece *src) noexcept
template Expected< char, ConversionCode >	str_to_integral< char > (StringPiece *src) noexcept
template Expected< signed char, ConversionCode >	str_to_integral< signed char > (StringPiece *src) noexcept
template Expected< unsigned char, ConversionCode >	str_to_integral< unsigned char > (StringPiece *src) noexcept
template Expected< short, ConversionCode >	str_to_integral< short > (StringPiece *src) noexcept
template Expected< unsigned short, ConversionCode >	str_to_integral< unsigned short > (StringPiece *src) noexcept
template Expected< int, ConversionCode >	str_to_integral< int > (StringPiece *src) noexcept
template Expected< unsigned int, ConversionCode >	str_to_integral< unsigned int > (StringPiece *src) noexcept
template Expected< long, ConversionCode >	str_to_integral< long > (StringPiece *src) noexcept
template Expected< unsigned long, ConversionCode >	str_to_integral< unsigned long > (StringPiece *src) noexcept
template Expected< long long, ConversionCode >	str_to_integral< long long > (StringPiece *src) noexcept
template Expected< unsigned long long, ConversionCode >	str_to_integral< unsigned long long > (StringPiece *src) noexcept
ConversionCode	enforceWhitespaceErr (StringPiece sp)
void	enforceWhitespace (StringPiece sp)
template<typename... Ts>
auto	getLastElement (const Ts &...ts) -> decltype(LastElementImpl< Ts... >::call(ts...))
template<class Tgt >
std::enable_if< !std::is_same< Tgt, bool >::value &&(std::is_integral< Tgt >::value||std::is_floating_point< Tgt >::value), Expected< Tgt, ConversionCode > >::type	convertTo (const bool &value) noexcept
template<class Tgt , class Src >
std::enable_if< std::is_integral< Src >::value &&!std::is_same< Tgt, Src >::value &&!std::is_same< Tgt, bool >::value &&std::is_integral< Tgt >::value, Expected< Tgt, ConversionCode > >::type	convertTo (const Src &value) noexcept
template<class Tgt , class Src >
std::enable_if< std::is_floating_point< Tgt >::value &&std::is_floating_point< Src >::value &&!std::is_same< Tgt, Src >::value, Expected< Tgt, ConversionCode > >::type	convertTo (const Src &value) noexcept
template<typename Tgt , typename Src >
std::enable_if< std::is_floating_point< Src >::value &&std::is_integral< Tgt >::value &&!std::is_same< Tgt, bool >::value, bool >::type	checkConversion (const Src &value)
template<typename Tgt , typename Src >
constexpr std::enable_if< std::is_integral< Src >::value &&std::is_floating_point< Tgt >::value, bool >::type	checkConversion (const Src &)
template<typename Tgt , typename Src >
constexpr std::enable_if< std::is_floating_point< Src >::value &&std::is_same< Tgt, bool >::value, bool >::type	checkConversion (const Src &)
template<typename Tgt , typename Src >
std::enable_if< (std::is_integral< Src >::value &&std::is_floating_point< Tgt >::value)||(std::is_floating_point< Src >::value &&std::is_integral< Tgt >::value), Expected< Tgt, ConversionCode > >::type	convertTo (const Src &value) noexcept
template<typename Tgt , typename Src >
std::string	errorValue (const Src &value)
template<class Tgt >
std::enable_if< std::is_void< ParseToResult< Tgt > >::value, Expected< StringPiece, ConversionCode > >::type	parseToWrap (StringPiece sp, Tgt &out)
template<class Tgt >
std::enable_if< !std::is_void< ParseToResult< Tgt > >::value, ParseToResult< Tgt > >::type	parseToWrap (StringPiece sp, Tgt &out)
template<typename Cond >
void	atomic_hash_spin_wait (Cond condition)
int	cplus_demangle_v3_callback_wrapper (char const *const mangled, void(*const cbref)(char const *, std::size_t, void *), void *const opaque)
template<typename TargetClock , typename Clock , typename Duration >
TargetClock::time_point	time_point_conv (std::chrono::time_point< Clock, Duration > const &time)
int	futexWakeImpl (const Futex< std::atomic > *futex, int count, uint32_t wakeMask)
FutexResult	futexWaitImpl (const Futex< std::atomic > *futex, uint32_t expected, std::chrono::system_clock::time_point const *absSystemTime, std::chrono::steady_clock::time_point const *absSteadyTime, uint32_t waitMask)
int	futexWakeImpl (const Futex< EmulatedFutexAtomic > *futex, int count, uint32_t wakeMask)
FutexResult	futexWaitImpl (const Futex< EmulatedFutexAtomic > *futex, uint32_t expected, std::chrono::system_clock::time_point const *absSystemTime, std::chrono::steady_clock::time_point const *absSteadyTime, uint32_t waitMask)
template<typename Futex , typename Deadline >
std::enable_if< Deadline::clock::is_steady, FutexResult >::type	futexWaitImpl (Futex *futex, uint32_t expected, Deadline const &deadline, uint32_t waitMask)
template<typename Futex , typename Deadline >
std::enable_if<!Deadline::clock::is_steady, FutexResult >::type	futexWaitImpl (Futex *futex, uint32_t expected, Deadline const &deadline, uint32_t waitMask)
template<typename Futex >
FutexResult	futexWait (const Futex *futex, uint32_t expected, uint32_t waitMask)
template<typename Futex >
int	futexWake (const Futex *futex, int count, uint32_t wakeMask)
template<typename Futex , class Clock , class Duration >
FutexResult	futexWaitUntil (const Futex *futex, uint32_t expected, std::chrono::time_point< Clock, Duration > const &deadline, uint32_t waitMask)
FutexResult	futexWaitImpl (const Futex< std::atomic > *futex, uint32_t expected, system_clock::time_point const *absSystemTime, steady_clock::time_point const *absSteadyTime, uint32_t waitMask)
FutexResult	futexWaitImpl (const Futex< EmulatedFutexAtomic > *futex, uint32_t expected, system_clock::time_point const *absSystemTime, steady_clock::time_point const *absSteadyTime, uint32_t waitMask)
std::string	familyNameStrDefault (sa_family_t family)
void	getNthMSBitImplThrow (size_t bitCount, sa_family_t family)
std::string	familyNameStr (sa_family_t family)
template<typename IPAddrType >
bool	getNthMSBitImpl (const IPAddrType &ip, size_t bitIndex, sa_family_t family)
template<class IntegralType , IntegralType DigitCount, IntegralType Base = IntegralType(10), bool PrintAllDigits = false, class = typename std::enable_if< std::is_integral<IntegralType>::value && std::is_unsigned<IntegralType>::value, bool>::type>
void	writeIntegerString (IntegralType val, char **buffer)
size_t	fastIpV4ToBufferUnsafe (const in_addr &inAddr, char *str)
std::string	fastIpv4ToString (const in_addr &inAddr)
void	fastIpv4AppendToString (const in_addr &inAddr, std::string &out)
size_t	fastIpv6ToBufferUnsafe (const in6_addr &in6Addr, char *str)
std::string	fastIpv6ToString (const in6_addr &in6Addr)
void	fastIpv6AppendToString (const in6_addr &in6Addr, std::string &out)
size_t	qfind_first_byte_of_bitset (const StringPieceLite haystack, const StringPieceLite needles)
size_t	qfind_first_byte_of_byteset (const StringPieceLite haystack, const StringPieceLite needles)
size_t	qfind_first_byte_of_std (const StringPieceLite haystack, const StringPieceLite needles)
size_t	qfind_first_byte_of_nosse (const StringPieceLite haystack, const StringPieceLite needles)
size_t	qfind_first_byte_of_sse42 (const StringPieceLite haystack, const StringPieceLite needles)
ssize_t	tfo_sendmsg (int, const struct msghdr *, int)
int	tfo_enable (int, size_t)
bool	tfo_succeeded (int)
template<typename T , typename Tag , typename F >
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T *	createGlobal (F &&creator)
template<typename T , typename Tag >
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T *	createGlobal ()
	TEST_F (StaticSingletonManagerTest, example)
template<template< class > class Op>
dynamic	numericOp (dynamic const &a, dynamic const &b)
template<typename F >
exception_wrapper	try_and_catch_ (F &&f)
template<typename F , typename Ex , typename... Exs>
exception_wrapper	try_and_catch_ (F &&f)
template<typename Fn >
EnableForArgTypes< Fn >	invokeForKeyValue (Fn f, const folly::dynamic &, const folly::dynamic &)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic >	invokeForKeyValue (Fn fn, const folly::dynamic &, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t >	invokeForKeyValue (Fn fn, const folly::dynamic &, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, bool >	invokeForKeyValue (Fn fn, const folly::dynamic &, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, double >	invokeForKeyValue (Fn fn, const folly::dynamic &, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string >	invokeForKeyValue (Fn fn, const folly::dynamic &, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic, folly::dynamic >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic, int64_t >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic, bool >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic, double >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, folly::dynamic, std::string >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string, folly::dynamic >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string, int64_t >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string, bool >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string, double >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, std::string, std::string >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t, folly::dynamic >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t, int64_t >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t, bool >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t, double >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
template<typename Fn >
EnableForArgTypes< Fn, int64_t, std::string >	invokeForKeyValue (Fn fn, const folly::dynamic &k, const folly::dynamic &v)
std::string	toPseudoJson (const folly::dynamic &d)
constexpr size_t	poly_size (size_t bits)
void	insertThousandsGroupingUnsafe (char *start_buffer, char **end_buffer)
template<class Uint >
size_t	uintToHex (char *buffer, size_t bufLen, Uint v, std::array< std::array< char, 2 >, 256 > const &repr)
template<class Uint >
size_t	uintToHexLower (char *buffer, size_t bufLen, Uint v)
template<class Uint >
size_t	uintToHexUpper (char *buffer, size_t bufLen, Uint v)
template<class Uint >
size_t	uintToOctal (char *buffer, size_t bufLen, Uint v)
template<class Uint >
size_t	uintToBinary (char *buffer, size_t bufLen, Uint v)
std::shared_ptr< Timekeeper >	getTimekeeperSingleton ()
uint32_t	crc32c_sw (const uint8_t *data, size_t nbytes, uint32_t startingChecksum)
uint32_t	crc32_hw (const uint8_t *, size_t, uint32_t)
bool	crc32c_hw_supported ()
bool	crc32_hw_supported ()
template<uint32_t CRC_POLYNOMIAL>
uint32_t	crc_sw (const uint8_t *data, size_t nbytes, uint32_t startingChecksum)
uint32_t	crc32_sw (const uint8_t *data, size_t nbytes, uint32_t startingChecksum)
uint32_t	crc32c_hw (const uint8_t *data, size_t nbytes, uint32_t startingChecksum=~0U)
uint32_t	crc32_combine_sw (uint32_t crc1, uint32_t crc2, size_t crc2len)
uint32_t	crc32_combine_hw (uint32_t crc1, uint32_t crc2, size_t crc2len)
uint32_t	crc32c_combine_sw (uint32_t crc1, uint32_t crc2, size_t crc2len)
uint32_t	crc32c_combine_hw (uint32_t crc1, uint32_t crc2, size_t crc2len)
constexpr size_t	max_align_ (std::size_t a)
template<typename... Es>
constexpr std::size_t	max_align_ (std::size_t a, std::size_t e, Es...es)
void	assume_check (bool cond)
template<typename Dst , typename Src >
constexpr std::make_signed_t< Dst >	bits_to_signed (Src const s)
template<typename Dst , typename Src >
constexpr std::make_unsigned_t< Dst >	bits_to_unsigned (Src const s)
static uint8_t	byteswap_gen (uint8_t v)
static uint64_t	byteswap_gen (uint64_t v)
static uint32_t	byteswap_gen (uint32_t v)
static uint16_t	byteswap_gen (uint16_t v)
template<typename T >
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T &&	to_exception_arg_ (T &&t)
template<std::size_t N>
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN char const *	to_exception_arg_ (char const (&array)[N])
template<typename Ex , typename... Args>
FOLLY_NOINLINE FOLLY_COLD void	throw_exception_ (Args &&...args)
template<typename Ex , typename... Args>
FOLLY_NOINLINE FOLLY_COLD void	terminate_with_ (Args &&...args) noexcept
void	assertionFailure (const char *expr, const char *msg, const char *file, unsigned int line, const char *function)
template<typename Arg >
auto	fallbackFormatOneArg (std::string *str, const Arg *arg, int) -> decltype(toAppend(std::declval< Arg >(), std::declval< std::string * >()), std::declval< void >())
template<typename Arg >
void	fallbackFormatOneArg (std::string *str, const Arg *arg, long)
constexpr const char *	xlogStripFilenameRecursive (const char *filename, const char *prefixes, size_t prefixIdx, size_t filenameIdx, bool match)
constexpr const char *	xlogStripFilenameMatchFound (const char *filename, const char *prefixes, size_t prefixIdx, size_t filenameIdx)
template<class... KeysDefault>
auto	extract_default (const KeysDefault &...keysDefault) -> typename DefaultType< KeysDefault... >::type const &
template<typename T >
constexpr T	divFloorBranchless (T num, T denom)
template<typename T >
constexpr T	divFloorBranchful (T num, T denom)
template<typename T >
constexpr T	divCeilBranchless (T num, T denom)
template<typename T >
constexpr T	divCeilBranchful (T num, T denom)
template<typename T >
constexpr T	divRoundAwayBranchless (T num, T denom)
template<typename T >
constexpr T	divRoundAwayBranchful (T num, T denom)
void	handleMallctlError (const char *cmd, int err)
template<typename T >
void	mallctlHelper (const char *cmd, T *out, T *in)
void	unsafeStringSetLargerSize (std::string &s, std::size_t n)
template<typename T >
void	unsafeVectorSetLargerSize (std::vector< T > &v, std::size_t n)
template<typename Alloc , size_t kAlign, bool kAllocate>
void	rawOverAlignedImpl (Alloc const &alloc, size_t n, void *&raw)
	FOLLY_CREATE_MEMBER_INVOKE_TRAITS (AllocatorConstruct_, construct)
	FOLLY_CREATE_MEMBER_INVOKE_TRAITS (AllocatorDestroy_, destroy)
template<typename Char >
constexpr size_t	constexpr_strlen_internal (const Char *s, size_t len)
template<typename Char >
constexpr int	constexpr_strcmp_internal (const Char *s1, const Char *s2)
bool	sysMembarrierAvailable ()
int	sysMembarrier ()
template<class Iter >
std::enable_if< std::is_same< typename std::iterator_traits< Iter >::iterator_category, std::random_access_iterator_tag >::value, typename std::iterator_traits< Iter >::reference >::type	value_before (Iter i)
template<class Iter >
std::enable_if< !std::is_same< typename std::iterator_traits< Iter >::iterator_category, std::random_access_iterator_tag >::value, typename std::iterator_traits< Iter >::reference >::type	value_before (Iter i)
size_t	qfind_first_byte_of (const StringPiece haystack, const StringPiece needles)
template<typename FunctionType >
ScopeGuardImpl< typename std::decay< FunctionType >::type, true >	operator+ (detail::ScopeGuardOnExit, FunctionType &&fn)
std::unique_lock< std::mutex >	sharedMutexAnnotationGuard (void *ptr)
void	singletonWarnDoubleRegistrationAndAbort (const TypeDescriptor &type)
static void	singleton_hs_init_weak (int *argc, char **argv[]) __attribute__((__weakref__("hs_init")))
void	singletonWarnLeakyDoubleRegistrationAndAbort (const TypeDescriptor &type)
void	singletonWarnLeakyInstantiatingNotRegisteredAndAbort (const TypeDescriptor &type)
void	singletonWarnRegisterMockEarlyAndAbort (const TypeDescriptor &type)
void	singletonWarnDestroyInstanceLeak (const TypeDescriptor &type, const void *ptr)
void	singletonWarnCreateCircularDependencyAndAbort (const TypeDescriptor &type)
void	singletonWarnCreateUnregisteredAndAbort (const TypeDescriptor &type)
void	singletonWarnCreateBeforeRegistrationCompleteAndAbort (const TypeDescriptor &type)
void	singletonPrintDestructionStackTrace (const TypeDescriptor &type)
void	singletonThrowNullCreator (const std::type_info &type)
void	singletonThrowGetInvokedAfterDestruction (const TypeDescriptor &type)
template<class T >
std::enable_if< std::is_default_constructible< T >::value &&!folly::is_trivially_copyable< T >::value >::type	moveObjectsRight (T *first, T *lastConstructed, T *realLast)
template<class T >
std::enable_if< !std::is_default_constructible< T >::value||folly::is_trivially_copyable< T >::value >::type	moveObjectsRight (T *first, T *lastConstructed, T *realLast)
template<class T , class Function >
void	populateMemForward (T *mem, std::size_t n, Function const &op)
template<class T >
T *	pointerFlagSet (T *p)
template<class T >
bool	pointerFlagGet (T *p)
template<class T >
T *	pointerFlagClear (T *p)
void *	shiftPointer (void *p, size_t sizeBytes)
template<class Iterator >
int	distance_if_multipass (Iterator first, Iterator last)
template<class OurContainer , class Vector , class GrowthPolicy >
OurContainer::iterator	insert_with_hint (OurContainer &sorted, Vector &cont, typename OurContainer::iterator hint, typename OurContainer::value_type &&value, GrowthPolicy &po)
template<class OurContainer , class Vector , class InputIterator >
void	bulk_insert (OurContainer &sorted, Vector &cont, InputIterator first, InputIterator last)
template<typename Container , typename Compare >
Container &&	as_sorted (Container &&container, Compare const &comp)
template<typename ReturnType >
ReturnType	avgHelper (long double sum, uint64_t count)
template<typename ReturnType , typename ValueType >
std::enable_if< !std::is_same< typename std::remove_cv< ValueType >::type, long double >::value, ReturnType >::type	avgHelper (ValueType sum, uint64_t count)
template<typename ReturnType = double, typename Duration = std::chrono::seconds, typename Interval = Duration>
ReturnType	rateHelper (ReturnType count, Duration elapsed)
static uint8_t	getRadixBucket (double *f, uint8_t shift)
static void	double_radix_sort_rec (uint64_t n, uint64_t *buckets, uint8_t shift, bool inout, double *in, double *out)
void	double_radix_sort (uint64_t n, uint64_t *buckets, double *in, double *tmp)
QuantileEstimates	estimatesFromDigest (const TDigest &digest, Range< const double * > quantiles)
size_t	delimSize (char)
size_t	delimSize (StringPiece s)
bool	atDelim (const char *s, char c)
bool	atDelim (const char *s, StringPiece sp)
char	delimFront (char c)
char	delimFront (StringPiece s)
template<class OutStringT , class DelimT , class OutputIterator >
void	internalSplit (DelimT delim, StringPiece sp, OutputIterator out, bool ignoreEmpty)
template<class String >
StringPiece	prepareDelim (const String &s)
char	prepareDelim (char c)
template<class OutputType >
void	toOrIgnore (StringPiece input, OutputType &output)
void	toOrIgnore (StringPiece, decltype(std::ignore)&)
template<bool exact, class Delim , class OutputType >
bool	splitFixed (const Delim &delimiter, StringPiece input, OutputType &output)
template<bool exact, class Delim , class OutputType , class... OutputTypes>
bool	splitFixed (const Delim &delimiter, StringPiece input, OutputType &outHead, OutputTypes &...outTail)
template<class Delim , class Iterator , class String >
void	internalJoinAppend (Delim delimiter, Iterator begin, Iterator end, String &output)
template<class Delim , class Iterator , class String >
std::enable_if< IsSizableStringContainerIterator< Iterator >::value >::type	internalJoin (Delim delimiter, Iterator begin, Iterator end, String &output)
template<class Delim , class Iterator , class String >
std::enable_if< !IsSizableStringContainerIterator< Iterator >::value >::type	internalJoin (Delim delimiter, Iterator begin, Iterator end, String &output)
size_t	hexDumpLine (const void *ptr, size_t offset, size_t size, std::string &line)
template<typename Atomic >
bool	atomic_fetch_set_default (Atomic &atomic, std::size_t bit, std::memory_order order)
template<typename Atomic >
bool	atomic_fetch_reset_default (Atomic &atomic, std::size_t bit, std::memory_order order)
template<typename Atomic >
bool	atomic_fetch_set_x86 (Atomic &, std::size_t, std::memory_order) noexcept
template<typename Atomic >
bool	atomic_fetch_reset_x86 (Atomic &, std::size_t, std::memory_order) noexcept
std::memory_order	default_failure_memory_order (std::memory_order successMode)
template<typename Clock , typename Duration , typename F >
spin_result	spin_pause_until (std::chrono::time_point< Clock, Duration > const &deadline, WaitOptions const &opt, F f)
template<typename Clock , typename Duration , typename F >
spin_result	spin_yield_until (std::chrono::time_point< Clock, Duration > const &deadline, F f)
constexpr int	hazptr_domain_rcount_threshold ()
void	annotate_rwlock_create_impl (void const volatile *const addr, char const *const f, int const l)
void	annotate_rwlock_create_static_impl (void const volatile *const addr, char const *const f, int const l)
void	annotate_rwlock_destroy_impl (void const volatile *const addr, char const *const f, int const l)
void	annotate_rwlock_acquired_impl (void const volatile *const addr, annotate_rwlock_level const w, char const *const f, int const l)
void	annotate_rwlock_try_acquired_impl (void const volatile *const addr, annotate_rwlock_level const w, bool const result, char const *const f, int const l)
void	annotate_rwlock_released_impl (void const volatile *const addr, annotate_rwlock_level const w, char const *const f, int const l)
void	annotate_benign_race_sized_impl (const volatile void *addr, long size, const char *desc, const char *f, int l)
template<typename Synchronized , typename LockFunc , typename TryLockFunc , typename... Args>
auto	makeSynchronizedLocker (Synchronized &synchronized, LockFunc &&lockFunc, TryLockFunc &&tryLockFunc, Args &&...args)
template<typename... SynchronizedLocker>
auto	lock (SynchronizedLocker...lockersIn) -> std::tuple< typename SynchronizedLocker::LockedPtr... >
template<typename Synchronized , typename... Args>
auto	wlock (Synchronized &synchronized, Args &&...args)
template<typename Synchronized , typename... Args>
auto	rlock (Synchronized &synchronized, Args &&...args)
template<typename Synchronized , typename... Args>
auto	ulock (Synchronized &synchronized, Args &&...args)
template<typename Synchronized , typename... Args>
auto	lock (Synchronized &synchronized, Args &&...args)
template<typename... Arguments>
std::vector< std::string >	shellify (StringPiece format, Arguments &&...arguments)
FOLLY_PUSH_WARNING	FOLLY_MSVC_DISABLE_WARNING (4388) FOLLY_MSVC_DISABLE_WARNING(4804) template< typename RHS
FOLLY_PUSH_WARNING RHS LHS bool	less_than_impl (LHS const lhs)
template<typename RHS , RHS rhs, typename LHS >
bool	greater_than_impl (LHS const lhs)

Variables
constexpr double	kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0
constexpr double	kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0
constexpr double	kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0
constexpr float	kClampCastLowerBoundFloatToInt32F = -2147483520.0f
constexpr float	kClampCastUpperBoundFloatToInt32F = 2147483520.0f
constexpr float	kClampCastUpperBoundFloatToUInt32F = 4294967040.0f
struct folly::detail::LastElementImpl	sizeof
FOLLY_STORAGE_CONSTEXPR std::array< std::array< std::uint8_t, 256 >, 8 > const	kSelectInByte
const std::array< std::array< char, 2 >, 256 >	formatHexUpper
const std::array< std::array< char, 2 >, 256 >	formatHexLower
const std::array< std::array< char, 3 >, 512 >	formatOctal
const std::array< std::array< char, 8 >, 256 >	formatBinary
const size_t	kMaxHexLength = 2 * sizeof(uintmax_t)
const size_t	kMaxOctalLength = 3 * sizeof(uintmax_t)
const size_t	kMaxBinaryLength = 8 * sizeof(uintmax_t)
FOLLY_STORAGE_CONSTEXPR auto	formatAlignTable
FOLLY_STORAGE_CONSTEXPR auto	formatSignTable
static FOLLY_TLS uint32_t	tls_lastCpuBufferSlot = 0
const std::array< char, 256 >	cEscapeTable
const std::array< char, 256 >	cUnescapeTable
const std::array< unsigned char, 256 >	hexTable
const std::array< unsigned char, 256 >	uriEscapeTable
template<typename T >
constexpr auto	is_atomic = false
FOLLY_PUSH_WARNING RHS	rhs

Detailed Description

Call doNotOptimizeAway(var) to ensure that var will be computed even post-optimization. Use it for variables that are computed during benchmarking but otherwise are useless. The compiler tends to do a good job at eliminating unused variables, and this function fools it into thinking var is in fact needed.

Call makeUnpredictable(var) when you don't want the optimizer to use its knowledge of var to shape the following code. This is useful when constant propagation or power reduction is possible during your benchmark but not in real use cases.

DynamicParser provides a tiny DSL for easily, correctly, and losslessly parsing a folly::dynamic into any other representation.

To make this concrete, this lets you take a JSON config that potentially contains user errors, and parse all of its valid parts, while automatically and reversibly recording any parts that cause errors:

{"my values": { "an int": "THIS WILL BE RECORDED AS AN ERROR, BUT WE'LL PARSE THE REST", "a double": 3.1415, "keys & values": { "the sky is blue": true, "THIS WILL ALSO BE RECORDED AS AN ERROR": "cheese", "2+2=5": false, } }}

To parse this JSON, you need no exception handling, it is as easy as:

folly::dynamic d = ...; // Input int64_t integer; // Three outputs double real; std::map<std::string, bool> enabled_widgets; DynamicParser p(DynamicParser::OnError::RECORD, &d); p.required("my values", [&]() { p.optional("an int", [&](int64_t v) { integer = v; }); p.required("a double", [&](double v) { real = v; }); p.optional("keys & values", [&]() { p.objectItems([&](std::string widget, bool enabled) { enabled_widgets.emplace(widget, enabled); }); }); });

Your code in the lambdas can throw, and this will be reported just like missing key and type conversion errors, with precise context on what part of the folly::dynamic caused the error. No need to throw: std::runtime_error("Value X at key Y caused a flux capacitor overload") This will do: std::runtime_error("Flux capacitor overload")

== Keys and values are auto-converted to match your callback ==

DynamicParser's optional(), required(), objectItems(), and arrayItems() automatically convert the current key and value to match the signature of the provided callback. parser.key() and parser.value() can be used to access the same data without conversion.

The following types are supported – you should generally take arguments by-value, or by-const-reference for dynamics & strings you do not copy.

Key: folly::dynamic (no conversion), std::string, int64_t Value: folly::dynamic (no conversion), int64_t, bool, double, std::string

There are 21 supported callback signatures, of three kinds:

1: No arguments – useful if you will just call more parser methods.

5: The value alone – the common case for optional() and required(). [&](whatever_t value) {}

15: Both the key and the value converted according to the rules above: [&](whatever_t key, whatever_t) {}

NB: The key alone should be rarely needed, but these callback styles provide it with no conversion overhead, and only minimal verbosity: [&](const std::string& k, const folly::dynamic&) {} [&]() { auto k = p.key().asString(); }

== How releaseErrors() can make your parse lossless ==

If you write parsing code by hand, you usually end up with error-handling resembling that of OnError::THROW – the first error you hit aborts the whole parse, and you report it.

OnError::RECORD offers a more user-friendly alternative for "parse, serialize, re-parse" pipelines, akin to what web-forms do. All exception-causing parts are losslessly recorded in a parallel folly::dynamic, available via releaseErrors() at the end of the parse.

Suppose we fail to look up "key1" at the root, and hit a value error in "key2": {"subkey2": ...}. The error report will have the form:

{"nested": { "key_errors": {"key1": "explanatory message"}, "value": <whole input>="">, "nested": { "key2": { "nested": { "subkey2": {"value": <original value>="">, "error": "message"} } } } }}

Errors in array items are handled just the same, but using integer keys.

The advantage of this approach is that your parsing can throw wherever, and DynamicParser isolates it, allowing the good parts to parse.

Put another way, this makes it easy to implement a transformation that splits a folly::dynamic into a "parsed" part (which might be your struct meant for runtime use), and a matching "errors" part. As long as your successful parses are lossless, you can always reconstruct the original input from the parse output and the recorded "errors".

== Limitations ==

• The input dynamic should be an object or array. wrapError() could be exposed to allow parsing single scalars, but this would not be a significant usability improvement over try-catch.
• Do NOT try to parse the same part of the input dynamic twice. You might report multiple value errors, which is currently unsupported.
• optional() does not support defaulting. This is unavoidable, since DynamicParser does not dictate how you record parsed data. If your parse writes into an output struct, then it ought to be initialized at construction time. If your output is initialized to default values, then you need no "default" feature. If it is not initialized, you are in trouble anyway. Suppose your optional() parse hits an error. What does your output contain?
  • Uninitialized data :(
  • You rely on an optional() feature to fall back to parsing some default dynamic. Sadly, the default hits a parse error. Now what? Since there is no good way to default, DynamicParser leaves it out.

== Future: un-parsed items ==

DynamicParser could support erroring on un-parsed items – the parts of the folly::dynamic, which were never asked for. Here is an ok design:

(i) At the start of parsing any value, the user may call: parser.recursivelyForbidUnparsed(); parser.recursivelyAllowUnparsed(); parser.locallyForbidUnparsed(); parser.locallyAllowUnparsed();

(ii) At the end of the parse, any unparsed items are dumped to "errors". For example, failing to parse index 1 out of ["v1", "v2", "v3"] yields: "nested": {1: {"unparsed": "v2"}} or perhaps more verbosely: "nested": {1: {"error": "unparsed value", "value": "v2"}}

By default, unparsed items are allowed. Calling a "forbid" function after some keys have already been parsed is allowed to fail (this permits a lazy implementation, which has minimal overhead when "forbid" is not requested).

== Future: multiple value errors ==

The present contract is that exactly one value error is reported per location in the input (multiple key lookup errors are, of course, supported). If the need arises, multiple value errors could easily be supported by replacing the "error" string with an "errors" array.

Wrap a sequence or associative container so that out-of-range lookups return a default value rather than throwing an exception.

Usage: format("[no_such_key"], defaulted(map, 42)) -> 42

Creates a NotificationQueue::Consumer wrapping a function object Modeled after AsyncTimeout::make

An IOBuf is a pointer to a buffer of data.

IOBuf objects are intended to be used primarily for networking code, and are modelled somewhat after FreeBSD's mbuf data structure, and Linux's sk_buff structure.

IOBuf objects facilitate zero-copy network programming, by allowing multiple IOBuf objects to point to the same underlying buffer of data, using a reference count to track when the buffer is no longer needed and can be freed.

Data Layout

The IOBuf itself is a small object containing a pointer to the buffer and information about which segment of the buffer contains valid data.

The data layout looks like this:

+----—+ | IOBuf | +----—+ / | v +---------—+-----------------—+--------—+ | headroom | data | tailroom | +---------—+-----------------—+--------—+ ^ ^ ^ ^ buffer() data() tail() bufferEnd()

The length() method returns the length of the valid data; capacity() returns the entire capacity of the buffer (from buffer() to bufferEnd()). The headroom() and tailroom() methods return the amount of unused capacity available before and after the data.

Buffer Sharing

The buffer itself is reference counted, and multiple IOBuf objects may point to the same buffer. Each IOBuf may point to a different section of valid data within the underlying buffer. For example, if multiple protocol requests are read from the network into a single buffer, a separate IOBuf may be created for each request, all sharing the same underlying buffer.

In other words, when multiple IOBufs share the same underlying buffer, the data() and tail() methods on each IOBuf may point to a different segment of the data. However, the buffer() and bufferEnd() methods will point to the same location for all IOBufs sharing the same underlying buffer.

  +-----------+     +---------+
  |  IOBuf 1  |     | IOBuf 2 |
  +-----------+     +---------+
   |         | _____/        |

data | tail |/ data | tail v v v +----------------------------------—+ | | | | | +----------------------------------—+

If you only read data from an IOBuf, you don't need to worry about other IOBuf objects possibly sharing the same underlying buffer. However, if you ever write to the buffer you need to first ensure that no other IOBufs point to the same buffer. The unshare() method may be used to ensure that you have an unshared buffer.

IOBuf Chains

IOBuf objects also contain pointers to next and previous IOBuf objects. This can be used to represent a single logical piece of data that its stored in non-contiguous chunks in separate buffers.

A single IOBuf object can only belong to one chain at a time.

IOBuf chains are always circular. The "prev" pointer in the head of the chain points to the tail of the chain. However, it is up to the user to decide which IOBuf is the head. Internally the IOBuf code does not care which element is the head.

The lifetime of all IOBufs in the chain are linked: when one element in the chain is deleted, all other chained elements are also deleted. Conceptually it is simplest to treat this as if the head of the chain owns all other IOBufs in the chain. When you delete the head of the chain, it will delete the other elements as well. For this reason, prependChain() and appendChain() take ownership of of the new elements being added to this chain.

When the coalesce() method is used to coalesce an entire IOBuf chain into a single IOBuf, all other IOBufs in the chain are eliminated and automatically deleted. The unshare() method may coalesce the chain; if it does it will similarly delete all IOBufs eliminated from the chain.

As discussed in the following section, it is up to the user to maintain a lock around the entire IOBuf chain if multiple threads need to access the chain. IOBuf does not provide any internal locking.

Synchronization

When used in multithread programs, a single IOBuf object should only be used in a single thread at a time. If a caller uses a single IOBuf across multiple threads the caller is responsible for using an external lock to synchronize access to the IOBuf.

Two separate IOBuf objects may be accessed concurrently in separate threads without locking, even if they point to the same underlying buffer. The buffer reference count is always accessed atomically, and no other operations should affect other IOBufs that point to the same data segment. The caller is responsible for using unshare() to ensure that the data buffer is not shared by other IOBufs before writing to it, and this ensures that the data itself is not modified in one thread while also being accessed from another thread.

For IOBuf chains, no two IOBufs in the same chain should be accessed simultaneously in separate threads. The caller must maintain a lock around the entire chain if the chain, or individual IOBufs in the chain, may be accessed by multiple threads.

IOBuf Object Allocation

IOBuf objects themselves exist separately from the data buffer they point to. Therefore one must also consider how to allocate and manage the IOBuf objects.

It is more common to allocate IOBuf objects on the heap, using the create(), takeOwnership(), or wrapBuffer() factory functions. The clone()/cloneOne() functions also return new heap-allocated IOBufs. The createCombined() function allocates the IOBuf object and data storage space together, in a single memory allocation. This can improve performance, particularly if you know that the data buffer and the IOBuf itself will have similar lifetimes.

That said, it is also possible to allocate IOBufs on the stack or inline inside another object as well. This is useful for cases where the IOBuf is short-lived, or when the overhead of allocating the IOBuf on the heap is undesirable.

However, note that stack-allocated IOBufs may only be used as the head of a chain (or standalone as the only IOBuf in a chain). All non-head members of an IOBuf chain must be heap allocated. (All functions to add nodes to a chain require a std::unique_ptr<IOBuf>, which enforces this requrement.)

Copying IOBufs is only meaningful for the head of a chain. The entire chain is cloned; the IOBufs will become shared, and the old and new IOBufs will refer to the same underlying memory.

IOBuf Sharing

The IOBuf class manages sharing of the underlying buffer that it points to, maintaining a reference count if multiple IOBufs are pointing at the same buffer.

However, it is the callers responsibility to manage sharing and ownership of IOBuf objects themselves. The IOBuf structure does not provide room for an intrusive refcount on the IOBuf object itself, only the underlying data buffer is reference counted. If users want to share the same IOBuf object between multiple parts of the code, they are responsible for managing this sharing on their own. (For example, by using a shared_ptr. Alternatively, users always have the option of using clone() to create a second IOBuf that points to the same underlying buffer.)

Endianness detection and manipulation primitives.

Small internal helper - returns the value just before an iterator.

Specializations of comparison operators for StringPiece

Typedef Documentation

template<typename Fn >

using folly::detail::ArgumentTypes = typedef typename ArgumentTypesByKind<IdentifyCallable::getKind<Fn>(), Fn>::type

Definition at line 80 of file DynamicParser-inl.h.

template<class T >

using folly::detail::AsTypeList = typedef _t<impl::AsTypeList_<T>>

Convert a type to a list of types. Given a type T:

• If T is of the form C<Ts...>, where C is a class template and Ts... is a list of types, the result is TypeList<Ts...>.
• Else, if T is of the form std::integer_sequence<T, Is...>, then the result is TypeList<std::integral_constant<T, Is>...>.
• Otherwise, asTypeList<T> is ill-formed.

Definition at line 514 of file TypeList.h.

using folly::detail::BenchmarkFun = typedef std::function<detail::TimeIterPair(unsigned int)>

Definition at line 59 of file Benchmark.h.

template<bool B>

using folly::detail::Bool = typedef bool_constant<B>

Handy shortcuts for some standard facilities

Definition at line 81 of file TypeList.h.

template<typename... Args>

using folly::detail::EnableForArgTypes = typedef typename std::enable_if<HasArgumentTypes<Args...>::value, void>::type

Definition at line 97 of file DynamicParser-inl.h.

using folly::detail::False = typedef std::false_type

Definition at line 83 of file TypeList.h.

template<template< typename > class Atom = std::atomic>

using folly::detail::Futex = typedef Atom<std::uint32_t>

Futex is an atomic 32 bit unsigned integer that provides access to the futex() syscall on that value. It is templated in such a way that it can interact properly with DeterministicSchedule testing.

If you don't know how to use futex(), you probably shouldn't be using this class. Even if you do know how, you should have a good reason (and benchmarks to back you up).

Because of the semantics of the futex syscall, the futex family of functions are available as free functions rather than member functions

Definition at line 51 of file Futex.h.

template<typename N , typename D >

using folly::detail::IdivResultType = typedef typename std::enable_if< std::is_integral<N>::value && std::is_integral<D>::value && !std::is_same<N, bool>::value && !std::is_same<D, bool>::value, decltype(N{1} / D{1})>::type

Definition at line 105 of file Math.h.

template<bool If_, class Then , class Else >

using folly::detail::If = typedef MetaApply<impl::If_<If_>, Then, Else>

Like std::conditional, but with fewer template instantiations

Definition at line 159 of file TypeList.h.

template<class List >

using folly::detail::Inherit = typedef impl::Inherit_<List>

Given a TypeList, create a type that inherits from all the types in the list.

Requires: all of the types in the list are non-final class types, and the types are all unique.

Definition at line 438 of file TypeList.h.

template<typename Rep , typename Period >

using folly::detail::IntermediateDuration = typedef std::chrono::duration< typename IntermediateTimeRep< Rep, std::is_floating_point<Rep>::value, std::is_signed<Rep>::value>::type, std::ratio<1, Period::den>>

Definition at line 220 of file Conv.h.

template<typename T >

using folly::detail::is_decay_propagate_const = typedef is_propagate_const<_t<std::decay<T>>>

Definition at line 47 of file PropagateConst.h.

template<typename Tgt , typename Src >

using folly::detail::IsArithToArith = typedef bool_constant< !std::is_same<Tgt, Src>::value && !std::is_same<Tgt, bool>::value && std::is_arithmetic<Src>::value && std::is_arithmetic<Tgt>::value>

Definition at line 1348 of file Conv.h.

template<class SynchronizedType >

using folly::detail::LockedPtrType = typedef typename std::conditional< std::is_const<SynchronizedType>::value, typename SynchronizedType::ConstLockedPtr, typename SynchronizedType::LockedPtr>::type

Definition at line 795 of file Synchronized.h.

using folly::detail::max_align_v_ = typedef max_align_t_< long double, double, float, long long int, long int, int, short int, bool, char, char16_t, char32_t, wchar_t, void*, std::max_align_t>

Definition at line 54 of file Align.h.

template<class Fn , class... Ts>

using folly::detail::MetaApply = typedef typename Fn::template apply<Ts...>

Given a metafunction class Fn and arguments Ts..., invoke Fn with Ts....

Definition at line 90 of file TypeList.h.

template<class Fn >

using folly::detail::MetaCurry = typedef MetaCompose<Fn, MetaQuote<TypeList>>

Given a metafunction class Fn that expects a single TypeList argument, turn it into a metafunction class that takes N arguments, wraps them in a TypeList, and calls Fn with it.

MetaApply<MetaCurry<Fn>, Ts...> is equivalent to MetaApply<Fn, TypeList<Ts...>>.

Definition at line 269 of file TypeList.h.

template<template< class... > class C>

using folly::detail::MetaQuoteTrait = typedef MetaCompose<MetaQuote<_t>, MetaQuote<C>>

Lifts a trait class template to be a metafunction class.

MetaApply<MetaQuoteTrait<C>, Ts...> is equivalent to typename C<Ts...>type.

Definition at line 232 of file TypeList.h.

template<class Fn >

using folly::detail::MetaUncurry = typedef MetaBindBack<MetaQuote<MetaApply>, Fn>

Given a metafunction class Fn that expects N arguments, turn it into a metafunction class that takes a single TypeList arguments and calls Fn with the types in the TypeList.

MetaApply<MetaUncurry<Fn>, TypeList<Ts...>> is equivalent to MetaApply<Fn, Ts...>.

Definition at line 280 of file TypeList.h.

template<class Fn , class List >

using folly::detail::MetaUnpack = typedef MetaApply<List, Fn>

Given a metafunction class Fn and a TypeList, call Fn with the types in the TypeList.

Definition at line 308 of file TypeList.h.

template<typename Tgt >

using folly::detail::ParseToError = typedef ExpectedErrorType<decltype( detail::parseToWrap(StringPiece{}, std::declval<Tgt&>()))>

Definition at line 1462 of file Conv.h.

template<typename Tgt >

using folly::detail::ParseToResult = typedef decltype(parseTo(StringPiece{}, std::declval<Tgt&>()))

Definition at line 1421 of file Conv.h.

template<size_t Deg>

using folly::detail::poly_table = typedef std::array<std::array<std::array<uint64_t, poly_size(Deg)>, 256>, 8>

Definition at line 61 of file Fingerprint.h.

template<typename F , bool INE>

using folly::detail::ScopeGuardImplDecay = typedef ScopeGuardImpl<typename std::decay<F>::type, INE>

Definition at line 138 of file ScopeGuard.h.

template<typename RNG >

using folly::detail::StateSizeT = typedef _t<StateSize<RNG>>

Definition at line 58 of file Random-inl.h.

template<class SynchronizedType >

using folly::detail::SynchronizedDataType = typedef typename std::conditional< std::is_const<SynchronizedType>::value, typename SynchronizedType::DataType const, typename SynchronizedType::DataType>::type

Definition at line 786 of file Synchronized.h.

using folly::detail::TimeIterPair = typedef std::pair<std::chrono::high_resolution_clock::duration, unsigned int>

Definition at line 58 of file Benchmark.h.

template<typename T >

using folly::detail::TransparentlyConvertibleToRange = typedef std::is_convertible< T, Range<typename ValueTypeForTransparentConversionToRange<T>::type const*>>

Definition at line 82 of file HeterogeneousAccess.h.

using folly::detail::True = typedef std::true_type

Definition at line 82 of file TypeList.h.

template<class... Ts>

using folly::detail::TypeConcat = typedef TypeJoin<TypeList<Ts...>>

Given several TypeLists, flatten the lists into a single list.

Note

This is just the curried form of TypeJoin. (See MetaCurry.)

TypeConcat<TypeList<As...>, TypeList<Bs...>> is equivalent to TypeList<As..., Bs...>

Definition at line 549 of file TypeList.h.

template<class List , class State , class Fn >

using folly::detail::TypeFold = typedef MetaApply<MetaApply<List, impl::FoldR_<Fn>>, State>

Given a TypeList, an initial state, and a binary function, reduce the TypeList by applying the function to each element and the current state, producing a new state to be used with the next element. This is a "right" fold in functional parlance.

TypeFold<TypeList<A, B, C>, X, Fn> is equivalent to MetaApply<Fn, A, MetaApply<Fn, B, MetaApply<Fn, C, X>>>.

Definition at line 380 of file TypeList.h.

template<class List >

using folly::detail::TypeJoin = typedef MetaApply<TypeFold<List, MetaQuote<TypeList>, impl::Join_>>

Given a TypeList of TypeLists, flatten the lists into a single list.

TypeJoin<TypeList<TypeList<As...>, TypeList<Bs...>>> is equivalent to TypeList<As..., Bs...>

Definition at line 538 of file TypeList.h.

template<class List , class... Ts>

using folly::detail::TypePushBack = typedef MetaApply<List, MetaBindBack<MetaQuote<TypeList>, Ts...>>

Given a TypeList and some arguments, append those arguments to the end of the TypeList.

TypePushBack<TypeList<Ts...>, Us...> is equivalent to TypeList<Ts..., Us...>.

Definition at line 290 of file TypeList.h.

template<class List , class... Ts>

using folly::detail::TypePushFront = typedef MetaApply<List, MetaBindFront<MetaQuote<TypeList>, Ts...>>

Given a TypeList and some arguments, prepend those arguments to the start of the TypeList.

TypePushFront<TypeList<Ts...>, Us...> is equivalent to TypeList<Us..., Ts...>.

Definition at line 301 of file TypeList.h.

template<class List , class State , class Fn >

using folly::detail::TypeReverseFold = typedef MetaApply<MetaApply<List, impl::FoldL_<Fn>>, State>

Given a TypeList, an initial state, and a binary function, reduce the TypeList by applying the function to each element and the current state, producing a new state to be used with the next element. This is a "left" fold, in functional parlance.

TypeReverseFold<TypeList<A, B, C>, X, Fn> is equivalent to MetaApply<Fn, MetaApply<Fn, MetaApply<Fn, X, C>, B, A>.

Definition at line 419 of file TypeList.h.

template<class List >

using folly::detail::TypeReverseUnique = typedef TypeReverseFold<List, TypeList<>, MetaFlip<impl::Unique_>>

Given a TypeList, produce a new list of types removing duplicates, keeping the last seen element.

TypeUnique<TypeList<int, short, int>> is equivalent to TypeList<short, int>.

Note

This algorithm is O(N^2).

Definition at line 488 of file TypeList.h.

template<class List , class Fn >

using folly::detail::TypeTransform = typedef MetaApply<List, impl::TypeTransform_<Fn>>

Transform all the elements in a TypeList with the metafunction class Fn.

TypeTransform<TypeList<Ts..>, Fn> is equivalent to TypeList<MetaApply<Fn, Ts>...>.

Definition at line 327 of file TypeList.h.

template<class List >

using folly::detail::TypeUnique = typedef TypeFold<List, TypeList<>, impl::Unique_>

Given a TypeList, produce a new list of types removing duplicates, keeping the first seen element.

TypeUnique<TypeList<int, short, int>> is equivalent to TypeList<int, short>.

Note

This algorithm is O(N^2).

Definition at line 475 of file TypeList.h.

Enumeration Type Documentation

enum folly::detail::FutexResult

strong

Enumerator
VALUE_CHANGED
AWOKEN
INTERRUPTED
TIMEDOUT

Definition at line 31 of file Futex.h.

                       {
  VALUE_CHANGED, /* futex value didn't match expected */
  AWOKEN, /* wakeup by matching futex wake, or spurious wakeup */
  INTERRUPTED, /* wakeup by interrupting signal */
  TIMEDOUT, /* wakeup by expiring deadline */
};

enum folly::detail::MutexLevel

strong

An enum to describe the "level" of a mutex. The supported levels are Unique - a normal mutex that supports only exclusive locking Shared - a shared mutex which has shared locking and unlocking functions; Upgrade - a mutex that has all the methods of the two above along with support for upgradable locking

Enumerator
UNIQUE
SHARED
UPGRADE

Definition at line 57 of file LockTraits.h.

{ UNIQUE, SHARED, UPGRADE };

enum folly::detail::ScopeGuardOnExit

strong

Internal use for the macro SCOPE_EXIT below

Definition at line 261 of file ScopeGuard.h.

{};

enum folly::detail::spin_result

strong

Enumerator
success
timeout
advance

Definition at line 29 of file Spin.h.

                       {
  success, // condition passed
  timeout, // exceeded deadline
  advance, // exceeded current wait-options component timeout
};

Function Documentation

void folly::detail::addBenchmarkImpl	(	const char *	file,
		const char *	name,
		std::function< TimeIterPair(unsigned int)>
	)

Adds a benchmark wrapped in a std::function. Only used internally. Pass by value is intentional.

Referenced by folly::addBenchmark(), and folly::getGlobalBenchmarkBaselineIndex().

void folly::detail::annotate_benign_race_sized_impl	(	const volatile void *	addr,
		long	size,
		const char *	desc,
		const char *	f,
		int	l
	)

Definition at line 118 of file SanitizeThread.cpp.

References AnnotateBenignRaceSized(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_benign_race_sized().

           {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(
        AnnotateBenignRaceSized, f, l, addr, size, desc);
  }
}

void folly::detail::annotate_rwlock_acquired_impl	(	void const volatile *const	addr,
		annotate_rwlock_level const	w,
		char const *const	f,
		int const	l
	)

Definition at line 85 of file SanitizeThread.cpp.

References AnnotateRWLockAcquired(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_rwlock_acquired().

                 {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(
        AnnotateRWLockAcquired, f, l, addr, static_cast<long>(w));
  }
}

void folly::detail::annotate_rwlock_create_impl	(	void const volatile *const	addr,
		char const *const	f,
		int const	l
	)

Definition at line 58 of file SanitizeThread.cpp.

References AnnotateRWLockCreate(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_rwlock_create().

                 {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(AnnotateRWLockCreate, f, l, addr);
  }
}

void folly::detail::annotate_rwlock_create_static_impl	(	void const volatile *const	addr,
		char const *const	f,
		int const	l
	)

Definition at line 67 of file SanitizeThread.cpp.

References AnnotateRWLockCreateStatic(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_rwlock_create_static().

                 {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(AnnotateRWLockCreateStatic, f, l, addr);
  }
}

void folly::detail::annotate_rwlock_destroy_impl	(	void const volatile *const	addr,
		char const *const	f,
		int const	l
	)

Definition at line 76 of file SanitizeThread.cpp.

References AnnotateRWLockDestroy(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_rwlock_destroy().

                 {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(AnnotateRWLockDestroy, f, l, addr);
  }
}

void folly::detail::annotate_rwlock_released_impl	(	void const volatile *const	addr,
		annotate_rwlock_level const	w,
		char const *const	f,
		int const	l
	)

Definition at line 107 of file SanitizeThread.cpp.

References AnnotateRWLockReleased(), FOLLY_SANITIZE_THREAD_CALL_HOOK, and folly::kIsSanitizeThread.

Referenced by folly::annotate_rwlock_released().

                 {
  if (kIsSanitizeThread) {
    FOLLY_SANITIZE_THREAD_CALL_HOOK(
        AnnotateRWLockReleased, f, l, addr, static_cast<long>(w));
  }
}

void folly::detail::annotate_rwlock_try_acquired_impl	(	void const volatile *const	addr,
		annotate_rwlock_level const	w,
		bool const	result,
		char const *const	f,
		int const	l
	)

Definition at line 96 of file SanitizeThread.cpp.

References folly::annotate_rwlock_acquired().

                 {
  if (result) {
    annotate_rwlock_acquired(addr, w, f, l);
  }
}

template<typename Container , typename Compare >

Container&& folly::detail::as_sorted	(	Container &&	container,
		Compare const &	comp
	)

Definition at line 199 of file sorted_vector_types.h.

References folly::test::begin(), folly::test::end(), and folly::T.

                                                                  {
  using namespace std;
  std::sort(begin(container), end(container), comp);
  return static_cast<Container&&>(container);
}

void folly::detail::assertionFailure	(	const char *	expr,
		const char *	msg,
		const char *	file,
		unsigned int	line,
		const char *	function
	)

Definition at line 34 of file SafeAssert.cpp.

References folly::fsyncNoInt(), uint32_t, folly::uint64ToBufferUnsafe(), and folly::writeFull().

                          {
  writeStderr("\n\nAssertion failure: ");
  writeStderr(expr + 1, strlen(expr) - 2);
  writeStderr("\nMessage: ");
  writeStderr(msg);
  writeStderr("\nFile: ");
  writeStderr(file);
  writeStderr("\nLine: ");
  char buf[20];
  uint32_t n = uint64ToBufferUnsafe(line, buf);
  writeFull(STDERR_FILENO, buf, n);
  writeStderr("\nFunction: ");
  writeStderr(function);
  writeStderr("\n");
  fsyncNoInt(STDERR_FILENO);
  abort();
}

void folly::detail::assume_check

(

bool

cond

)

Definition at line 25 of file Assume.cpp.

Referenced by folly::assume().

                             {
  CHECK(cond) << "compiler-hint assumption fails at runtime";
}

bool folly::detail::atDelim ( const char *  s, char  c  )

inline

Definition at line 255 of file String-inl.h.

References c.

Referenced by internalSplit().

                                           {
  return *s == c;
}

bool folly::detail::atDelim ( const char *  s, StringPiece  sp  )

inline

Definition at line 258 of file String-inl.h.

References folly::Range< Iter >::size(), and folly::Range< Iter >::start().

                                                   {
  return !std::memcmp(s, sp.start(), sp.size());
}

template<typename Atomic >

bool folly::detail::atomic_fetch_reset_default	(	Atomic &	atomic,
		std::size_t	bit,
		std::memory_order	order
	)

Definition at line 53 of file AtomicUtil-inl.h.

Referenced by folly::atomic_fetch_reset(), and folly::TEST_F().

                           {
  using Integer = decltype(atomic.load());
  auto mask = Integer{0b1} << static_cast<Integer>(bit);
  return (atomic.fetch_and(~mask, order) & mask);
}

template<typename Atomic >

bool folly::detail::atomic_fetch_reset_x86 ( Atomic &  , std::size_t  , std::memory_order    )

noexcept

Definition at line 228 of file AtomicUtil-inl.h.

Referenced by folly::atomic_fetch_reset(), and folly::TEST_F().

                                                                          {
  throw std::logic_error{"Incorrect function called"};
}

template<typename Atomic >

bool folly::detail::atomic_fetch_set_default	(	Atomic &	atomic,
		std::size_t	bit,
		std::memory_order	order
	)

Definition at line 43 of file AtomicUtil-inl.h.

Referenced by folly::atomic_fetch_set(), and folly::TEST_F().

                           {
  using Integer = decltype(atomic.load());
  auto mask = Integer{0b1} << static_cast<Integer>(bit);
  return (atomic.fetch_or(mask, order) & mask);
}

template<typename Atomic >

bool folly::detail::atomic_fetch_set_x86 ( Atomic &  , std::size_t  , std::memory_order    )

noexcept

Definition at line 224 of file AtomicUtil-inl.h.

Referenced by folly::atomic_fetch_set(), and folly::TEST_F().

                                                                        {
  throw std::logic_error{"Incorrect function called"};
}

template<typename Cond >

void folly::detail::atomic_hash_spin_wait

(

Cond

condition

)

Definition at line 30 of file AtomicHashUtils.h.

References folly::asm_volatile_pause(), i, and folly::fibers::yield().

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

                                           {
  constexpr size_t kPauseLimit = 10000;
  for (size_t i = 0; condition(); ++i) {
    if (i < kPauseLimit) {
      folly::asm_volatile_pause();
    } else {
      std::this_thread::yield();
    }
  }
}

template<typename ReturnType >

ReturnType folly::detail::avgHelper	(	long double	sum,
		uint64_t	count
	)

Definition at line 34 of file Bucket.h.

References count, type, and folly::value().

                                                      {
  if (count == 0) {
    return ReturnType(0);
  }
  const long double countf = count;
  return static_cast<ReturnType>(sum / countf);
}

template<typename ReturnType , typename ValueType >

std::enable_if< !std::is_same<typename std::remove_cv<ValueType>::type, long double>::value, ReturnType>::type folly::detail::avgHelper	(	ValueType	sum,
		uint64_t	count
	)

Definition at line 48 of file Bucket.h.

                                         {
  if (count == 0) {
    return ReturnType(0);
  }
  const double sumf = double(sum);
  const double countf = double(count);
  return static_cast<ReturnType>(sumf / countf);
}

template<typename Dst , typename Src >

constexpr std::make_signed_t<Dst> folly::detail::bits_to_signed

(

Src const

s

)

Definition at line 66 of file Bits.h.

References folly::to_signed(), folly::to_unsigned(), and value.

Referenced by folly::findFirstSet().

                                                            {
  static_assert(std::is_signed<Dst>::value, "unsigned type");
  return to_signed(static_cast<std::make_unsigned_t<Dst>>(to_unsigned(s)));
}

template<typename Dst , typename Src >

constexpr std::make_unsigned_t<Dst> folly::detail::bits_to_unsigned

(

Src const

s

)

Definition at line 71 of file Bits.h.

References folly::to_unsigned(), and value.

Referenced by folly::findLastSet(), and folly::popcount().

                                                                {
  static_assert(std::is_unsigned<Dst>::value, "signed type");
  return static_cast<Dst>(to_unsigned(s));
}

template<class OurContainer , class Vector , class InputIterator >

void folly::detail::bulk_insert	(	OurContainer &	sorted,
		Vector &	cont,
		InputIterator	first,
		InputIterator	last
	)

Definition at line 161 of file sorted_vector_types.h.

References a, b, folly::copy(), and distance_if_multipass().

Referenced by folly::sorted_vector_set< folly::RequestData * >::insert(), and folly::sorted_vector_map< Key, Value, Compare, Allocator, GrowthPolicy, Container >::insert().

                        {
  // prevent deref of middle where middle == cont.end()
  if (first == last) {
    return;
  }

  auto const& cmp(sorted.value_comp());

  int const d = distance_if_multipass(first, last);
  if (d != -1) {
    cont.reserve(cont.size() + d);
  }
  auto const prev_size = cont.size();

  std::copy(first, last, std::back_inserter(cont));
  auto const middle = cont.begin() + prev_size;
  if (!std::is_sorted(middle, cont.end(), cmp)) {
    std::sort(middle, cont.end(), cmp);
  }
  if (middle != cont.begin() && !cmp(*(middle - 1), *middle)) {
    std::inplace_merge(cont.begin(), middle, cont.end(), cmp);
  }
  cont.erase(
      std::unique(
          cont.begin(),
          cont.end(),
          [&](typename OurContainer::value_type const& a,
              typename OurContainer::value_type const& b) {
            return !cmp(a, b) && !cmp(b, a);
          }),
      cont.end());
}

static uint8_t folly::detail::byteswap_gen ( uint8_t  v )

inlinestatic

Definition at line 185 of file Bits.h.

Referenced by folly::detail::EndianInt< T >::swap().

{

static uint64_t folly::detail::byteswap_gen ( uint64_t  v )

inlinestatic

Definition at line 191 of file Bits.h.

{

static uint32_t folly::detail::byteswap_gen ( uint32_t  v )

inlinestatic

Definition at line 192 of file Bits.h.

{

static uint16_t folly::detail::byteswap_gen ( uint16_t  v )

inlinestatic

Definition at line 193 of file Bits.h.

{

template<typename Tgt , typename Src >

std::enable_if< std::is_floating_point<Src>::value && std::is_integral<Tgt>::value && !std::is_same<Tgt, bool>::value, bool>::type folly::detail::checkConversion ( const Src &  value )

inline

Check if a floating point value can safely be converted to an integer value without triggering undefined behaviour.

Definition at line 1267 of file Conv.h.

References max, min, type, and value.

                                  {
  constexpr Src tgtMaxAsSrc = static_cast<Src>(std::numeric_limits<Tgt>::max());
  constexpr Src tgtMinAsSrc = static_cast<Src>(std::numeric_limits<Tgt>::min());
  if (value >= tgtMaxAsSrc) {
    if (value > tgtMaxAsSrc) {
      return false;
    }
    const Src mmax = folly::nextafter(tgtMaxAsSrc, Src());
    if (static_cast<Tgt>(value - mmax) >
        std::numeric_limits<Tgt>::max() - static_cast<Tgt>(mmax)) {
      return false;
    }
  } else if (std::is_signed<Tgt>::value && value <= tgtMinAsSrc) {
    if (value < tgtMinAsSrc) {
      return false;
    }
    const Src mmin = folly::nextafter(tgtMinAsSrc, Src());
    if (static_cast<Tgt>(value - mmin) <
        std::numeric_limits<Tgt>::min() - static_cast<Tgt>(mmin)) {
      return false;
    }
  }
  return true;
}

template<typename Tgt , typename Src >

constexpr std::enable_if< std::is_integral<Src>::value && std::is_floating_point<Tgt>::value, bool>::type folly::detail::checkConversion

(

const Src &

)

Definition at line 1297 of file Conv.h.

References type.

                            {
  return true;
}

template<typename Tgt , typename Src >

constexpr std::enable_if< std::is_floating_point<Src>::value && std::is_same<Tgt, bool>::value, bool>::type folly::detail::checkConversion

(

const Src &

)

Definition at line 1307 of file Conv.h.

References type, and value.

                            {
  return true;
}

template<typename NotKeyT , typename KeyT >

void folly::detail::checkLegalKeyIfKeyTImpl ( NotKeyT  , KeyT  , KeyT  , KeyT    )

inline

Definition at line 69 of file AtomicHashArray.h.

Referenced by folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::checkLegalKeyIfKey().

            {}

template<typename KeyT >

void folly::detail::checkLegalKeyIfKeyTImpl ( KeyT  key_in, KeyT  emptyKey, KeyT  lockedKey, KeyT  erasedKey  )

inline

Definition at line 76 of file AtomicHashArray.h.

                    {
  DCHECK_NE(key_in, emptyKey);
  DCHECK_NE(key_in, lockedKey);
  DCHECK_NE(key_in, erasedKey);
}

template<typename Src >

Expected<time_t, ConversionCode> folly::detail::chronoRangeCheck

(

Src

value

)

This converts a number in some input type to time_t while ensuring that it fits in the range of numbers representable by time_t.

This is similar to the normal folly::tryTo() behavior when converting arthmetic types to an integer type, except that it does not complain about floating point conversions losing precision.

Definition at line 75 of file Conv.h.

References folly::makeUnexpected(), max, folly::NEGATIVE_OVERFLOW, folly::POSITIVE_OVERFLOW, value, and folly::value().

Referenced by durationToPosixTime().

                                                             {
  if (value > std::numeric_limits<time_t>::max()) {
    return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
  }
  if (std::is_signed<Src>::value) {
    if (value < std::numeric_limits<time_t>::lowest()) {
      return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
    }
  }

  return static_cast<time_t>(value);
}

template<typename D , typename S >

constexpr D folly::detail::constexpr_clamp_cast_helper	(	S	src,
		S	sl,
		S	su,
		D	dl,
		D	du
	)

Definition at line 356 of file ConstexprMath.h.

References D, type, and value.

Referenced by folly::constexpr_clamp_cast().

                                                                       {
  return src < sl ? dl : (src > su ? du : D(src));
}

template<typename U >

constexpr std::size_t folly::detail::constexpr_find_first_set_	(	std::size_t	s,
		std::size_t	a,
		U const	u
	)

Definition at line 196 of file ConstexprMath.h.

Referenced by folly::constexpr_find_first_set().

                                                               {
  return s == 0 ? a
                : constexpr_find_first_set_(
                      s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
}

template<typename T >

constexpr T folly::detail::constexpr_log2_	(	T	a,
		T	e
	)

Definition at line 142 of file ConstexprMath.h.

References folly::T.

Referenced by folly::constexpr_log2().

                                      {
  return e == T(1) ? a : constexpr_log2_(a + T(1), e / T(2));
}

template<typename T >

constexpr T folly::detail::constexpr_log2_ceil_	(	T	l2,
		T	t
	)

Definition at line 147 of file ConstexprMath.h.

References folly::T.

Referenced by folly::constexpr_log2_ceil().

                                            {
  return l2 + T(T(1) << l2 < t ? 1 : 0);
}

template<typename T >

constexpr T folly::detail::constexpr_square_

(

T

t

)

Definition at line 152 of file ConstexprMath.h.

References folly::pushmi::detail::t.

Referenced by folly::constexpr_pow().

                                   {
  return t * t;
}

template<typename Char >

constexpr int folly::detail::constexpr_strcmp_internal	(	const Char *	s1,
		const Char *	s2
	)

Definition at line 49 of file Constexpr.h.

Referenced by folly::constexpr_strcmp().

                                                                        {
  return (*s1 == '\0' || *s1 != *s2)
      ? (static_cast<int>(*s1 - *s2))
      : constexpr_strcmp_internal(s1 + 1, s2 + 1);
}

template<typename Char >

constexpr size_t folly::detail::constexpr_strlen_internal	(	const Char *	s,
		size_t	len
	)

Definition at line 30 of file Constexpr.h.

References testing::gmock_generated_actions_test::Char().

Referenced by folly::detail::fixedstring::checkNullTerminated(), and folly::constexpr_strlen().

                                                                      {
  // clang-format off
  return
      *(s + 0) == Char(0) ? len + 0 :
      *(s + 1) == Char(0) ? len + 1 :
      *(s + 2) == Char(0) ? len + 2 :
      *(s + 3) == Char(0) ? len + 3 :
      *(s + 4) == Char(0) ? len + 4 :
      *(s + 5) == Char(0) ? len + 5 :
      *(s + 6) == Char(0) ? len + 6 :
      *(s + 7) == Char(0) ? len + 7 :
      constexpr_strlen_internal(s + 8, len + 8);
  // clang-format on
}

template<class Tgt >

std::enable_if< !std::is_same<Tgt, bool>::value && (std::is_integral<Tgt>::value || std::is_floating_point<Tgt>::value), Expected<Tgt, ConversionCode> >::type folly::detail::convertTo ( const bool &  value )

noexcept

Bool to integral/float doesn't need any special checks, and this overload means we aren't trying to see if a bool is less than an integer.

Definition at line 1203 of file Conv.h.

References type, and value.

                                      {
  return static_cast<Tgt>(value ? 1 : 0);
}

template<class Tgt , class Src >

std::enable_if< std::is_integral<Src>::value && !std::is_same<Tgt, Src>::value && !std::is_same<Tgt, bool>::value && std::is_integral<Tgt>::value, Expected<Tgt, ConversionCode> >::type folly::detail::convertTo ( const Src &  value )

noexcept

Checked conversion from integral to integral. The checks are only performed when meaningful, e.g. conversion from int to long goes unchecked.

Definition at line 1217 of file Conv.h.

References folly::ARITH_NEGATIVE_OVERFLOW, folly::ARITH_POSITIVE_OVERFLOW, folly::greater_than(), folly::less_than(), folly::makeUnexpected(), max, min, type, value, and folly::value().

                                     {
  if /* constexpr */ (
      folly::_t<std::make_unsigned<Tgt>>(std::numeric_limits<Tgt>::max()) <
      folly::_t<std::make_unsigned<Src>>(std::numeric_limits<Src>::max())) {
    if (greater_than<Tgt, std::numeric_limits<Tgt>::max()>(value)) {
      return makeUnexpected(ConversionCode::ARITH_POSITIVE_OVERFLOW);
    }
  }
  if /* constexpr */ (
      std::is_signed<Src>::value &&
      (!std::is_signed<Tgt>::value || sizeof(Src) > sizeof(Tgt))) {
    if (less_than<Tgt, std::numeric_limits<Tgt>::min()>(value)) {
      return makeUnexpected(ConversionCode::ARITH_NEGATIVE_OVERFLOW);
    }
  }
  return static_cast<Tgt>(value);
}

template<class Tgt , class Src >

std::enable_if< std::is_floating_point<Tgt>::value && std::is_floating_point<Src>::value && !std::is_same<Tgt, Src>::value, Expected<Tgt, ConversionCode> >::type folly::detail::convertTo ( const Src &  value )

noexcept

Checked conversion from floating to floating. The checks are only performed when meaningful, e.g. conversion from float to double goes unchecked.

Definition at line 1245 of file Conv.h.

References folly::ARITH_NEGATIVE_OVERFLOW, folly::ARITH_POSITIVE_OVERFLOW, folly::makeUnexpected(), max, type, and folly::value().

                                     {
  if /* constexpr */ (
      std::numeric_limits<Tgt>::max() < std::numeric_limits<Src>::max()) {
    if (value > std::numeric_limits<Tgt>::max()) {
      return makeUnexpected(ConversionCode::ARITH_POSITIVE_OVERFLOW);
    }
    if (value < std::numeric_limits<Tgt>::lowest()) {
      return makeUnexpected(ConversionCode::ARITH_NEGATIVE_OVERFLOW);
    }
  }
  return static_cast<Tgt>(value);
}

template<typename Tgt , typename Src >

std::enable_if< (std::is_integral<Src>::value && std::is_floating_point<Tgt>::value) || (std::is_floating_point<Src>::value && std::is_integral<Tgt>::value), Expected<Tgt, ConversionCode> >::type folly::detail::convertTo ( const Src &  value )

noexcept

Checked conversion from integral to floating point and back. The result must be convertible back to the source type without loss of precision. This seems Draconian but sometimes is what's needed, and complements existing routines nicely. For various rounding routines, see <math>.

Definition at line 1323 of file Conv.h.

References folly::ARITH_LOSS_OF_PRECISION, LIKELY, folly::makeUnexpected(), and folly::value().

                                     {
  if (LIKELY(checkConversion<Tgt>(value))) {
    Tgt result = static_cast<Tgt>(value);
    if (LIKELY(checkConversion<Src>(result))) {
      Src witness = static_cast<Src>(result);
      if (LIKELY(value == witness)) {
        return result;
      }
    }
  }
  return makeUnexpected(ConversionCode::ARITH_LOSS_OF_PRECISION);
}

int folly::detail::cplus_demangle_v3_callback_wrapper	(	char const *const	mangled,
		void(*)(char const *, std::size_t, void *)	cbref,
		void *const	opaque
	)

Definition at line 32 of file Demangle.cpp.

                        {
#if FOLLY_DETAIL_HAVE_DEMANGLE_H
  auto const options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
  return cplus_demangle_v3_callback(mangled, options, cbref, opaque);
#else
  return 0;
#endif
}

uint32_t folly::detail::crc32_combine_hw	(	uint32_t	crc1,
		uint32_t	crc2,
		size_t	crc2len
	)

Definition at line 166 of file Crc32CombineDetail.cpp.

References folly::crc32_append_zeroes(), and folly::gf_multiply_crc32_hw().

Referenced by folly::crc32_combine().

                                                                        {
  return crc2 ^
      crc32_append_zeroes(
             gf_multiply_crc32_hw, crc1, crc2len, crc32_m, crc32_powers);
}

uint32_t folly::detail::crc32_combine_sw	(	uint32_t	crc1,
		uint32_t	crc2,
		size_t	crc2len
	)

Definition at line 161 of file Crc32CombineDetail.cpp.

References folly::crc32_append_zeroes(), and folly::gf_multiply_sw().

Referenced by folly::crc32_combine().

                                                                        {
  return crc2 ^
      crc32_append_zeroes(gf_multiply_sw, crc1, crc2len, crc32_m, crc32_powers);
}

uint32_t folly::detail::crc32_hw	(	const uint8_t *	data,
		size_t	nbytes,
		uint32_t	startingChecksum = ~0U
	)

Compute a CRC-32 checksum of a buffer using a hardware-accelerated implementation.

Note

This function is exposed to support special cases where the calling code is absolutely certain it ought to invoke a hardware- accelerated CRC-32 implementation - unit tests, for example. For all other scenarios, please call crc32() and let it pick an implementation based on the capabilities of the underlying CPU.

Definition at line 76 of file Checksum.cpp.

Referenced by benchmarkHardwareCRC32(), folly::crc32(), and TEST().

                {
  throw std::runtime_error("crc32_hw is not implemented on this platform");
}

bool folly::detail::crc32_hw_supported

(

)

Check whether a hardware-accelerated CRC-32 implementation is supported on the current CPU.

Definition at line 87 of file Checksum.cpp.

Referenced by benchmarkHardwareCRC32(), folly::crc32(), folly::crc32_combine(), and folly::crc32c_combine().

                          {
  return false;
}

uint32_t folly::detail::crc32_sw	(	const uint8_t *	data,
		size_t	nbytes,
		uint32_t	startingChecksum = ~0U
	)

Compute a CRC-32 checksum of a buffer using a portable, software-only implementation.

Note

This function is exposed to support special cases where the calling code is absolutely certain it wants to use the software implementation instead of the hardware-accelerated code - unit tests, for example. For all other scenarios, please call crc32() and let it pick an implementation based on the capabilities of the underlying CPU.

Definition at line 121 of file Checksum.cpp.

References folly::data(), and uint32_t.

Referenced by benchmarkSoftwareCRC32(), folly::crc32(), and TEST().

                                                                        {
  constexpr uint32_t CRC32_POLYNOMIAL = 0x04C11DB7;
  return crc_sw<CRC32_POLYNOMIAL>(data, nbytes, startingChecksum);
}

uint32_t folly::detail::crc32c_combine_hw	(	uint32_t	crc1,
		uint32_t	crc2,
		size_t	crc2len
	)

Definition at line 178 of file Crc32CombineDetail.cpp.

References folly::crc32_append_zeroes(), and folly::gf_multiply_crc32c_hw().

Referenced by folly::crc32c_combine().

                                                                         {
  return crc2 ^
      crc32_append_zeroes(
             gf_multiply_crc32c_hw, crc1, crc2len, crc32c_m, crc32c_powers);
}

uint32_t folly::detail::crc32c_combine_sw	(	uint32_t	crc1,
		uint32_t	crc2,
		size_t	crc2len
	)

Definition at line 172 of file Crc32CombineDetail.cpp.

References folly::crc32_append_zeroes(), and folly::gf_multiply_sw().

Referenced by folly::crc32c_combine().

                                                                         {
  return crc2 ^
      crc32_append_zeroes(
             gf_multiply_sw, crc1, crc2len, crc32c_m, crc32c_powers);
}

uint32_t folly::detail::crc32c_hw	(	const uint8_t *	data,
		size_t	nbytes,
		uint32_t	startingChecksum = ~0U
	)

Compute a CRC-32C checksum of a buffer using a hardware-accelerated implementation.

Note

This function is exposed to support special cases where the calling code is absolutely certain it ought to invoke a hardware- accelerated CRC-32C implementation - unit tests, for example. For all other scenarios, please call crc32c() and let it pick an implementation based on the capabilities of the underlying CPU.

Definition at line 292 of file Crc32cDetail.cpp.

Referenced by benchmarkHardwareCRC32C(), folly::crc32c(), and TEST().

                                                  {
  throw std::runtime_error("crc32_hw is not implemented on this platform");
}

bool folly::detail::crc32c_hw_supported

(

)

Check whether a hardware-accelerated CRC-32C implementation is supported on the current CPU.

Definition at line 83 of file Checksum.cpp.

Referenced by benchmarkHardwareCRC32C(), folly::crc32c(), and TEST().

                           {
  return false;
}

uint32_t folly::detail::crc32c_sw	(	const uint8_t *	data,
		size_t	nbytes,
		uint32_t	startingChecksum = ~0U
	)

Compute a CRC-32C checksum of a buffer using a portable, software-only implementation.

Note

This function is exposed to support special cases where the calling code is absolutely certain it wants to use the software implementation instead of the hardware-accelerated code - unit tests, for example. For all other scenarios, please call crc32c() and let it pick an implementation based on the capabilities of the underlying CPU.

Definition at line 115 of file Checksum.cpp.

References folly::data(), and uint32_t.

Referenced by benchmarkSoftwareCRC32C(), folly::crc32c(), and TEST().

                                                                         {
  constexpr uint32_t CRC32C_POLYNOMIAL = 0x1EDC6F41;
  return crc_sw<CRC32C_POLYNOMIAL>(data, nbytes, startingChecksum);
}

template<uint32_t CRC_POLYNOMIAL>

uint32_t folly::detail::crc_sw	(	const uint8_t *	data,
		size_t	nbytes,
		uint32_t	startingChecksum
	)

Definition at line 93 of file Checksum.cpp.

References sum(), and uint32_t.

                                                                               {
  // Reverse the bits in the starting checksum so they'll be in the
  // right internal format for Boost's CRC engine.
  //     O(1)-time, branchless bit reversal algorithm from
  //     http://graphics.stanford.edu/~seander/bithacks.html
  startingChecksum = ((startingChecksum >> 1) & 0x55555555) |
      ((startingChecksum & 0x55555555) << 1);
  startingChecksum = ((startingChecksum >> 2) & 0x33333333) |
      ((startingChecksum & 0x33333333) << 2);
  startingChecksum = ((startingChecksum >> 4) & 0x0f0f0f0f) |
      ((startingChecksum & 0x0f0f0f0f) << 4);
  startingChecksum = ((startingChecksum >> 8) & 0x00ff00ff) |
      ((startingChecksum & 0x00ff00ff) << 8);
  startingChecksum = (startingChecksum >> 16) | (startingChecksum << 16);

  boost::crc_optimal<32, CRC_POLYNOMIAL, ~0U, 0, true, true> sum(
      startingChecksum);
  sum.process_bytes(data, nbytes);
  return sum.checksum();
}

template<typename T , typename Tag , typename F >

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T* folly::detail::createGlobal

(

F &&

creator

)

Definition at line 70 of file StaticSingletonManager.h.

                                                                              {
  return StaticSingletonManager::create<T, Tag>(static_cast<F&&>(creator));
}

template<typename T , typename Tag >

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T* folly::detail::createGlobal

(

)

Definition at line 75 of file StaticSingletonManager.h.

References folly::T.

                                                                   {
  return StaticSingletonManager::create<T, Tag>([]() { return new T(); });
}

std::memory_order folly::detail::default_failure_memory_order ( std::memory_order  successMode )

inline

Definition at line 24 of file AtomicUtils.h.

Referenced by folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_strong(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong(), folly::test::DeterministicAtomicImpl< T, Schedule, Atom >::compare_exchange_strong(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), and folly::test::DeterministicAtomicImpl< T, Schedule, Atom >::compare_exchange_weak().

                                 {
  switch (successMode) {
    case std::memory_order_acq_rel:
      return std::memory_order_acquire;
    case std::memory_order_release:
      return std::memory_order_relaxed;
    default:
      return successMode;
  }
}

char folly::detail::delimFront ( char  c )

inline

Definition at line 264 of file String-inl.h.

References c.

Referenced by internalJoinAppend(), and internalSplit().

                               {
  // This one exists only for compile-time; it should never be called.
  std::abort();
  return c;
}

char folly::detail::delimFront ( StringPiece  s )

inline

Definition at line 269 of file String-inl.h.

References folly::Range< Iter >::empty(), and folly::Range< Iter >::start().

                                      {
  assert(!s.empty() && s.start() != nullptr);
  return *s.start();
}

size_t folly::detail::delimSize ( char  )

inline

Definition at line 249 of file String-inl.h.

Referenced by internalJoin(), internalJoinAppend(), internalSplit(), and splitFixed().

                              {
  return 1;
}

size_t folly::detail::delimSize ( StringPiece  s )

inline

Definition at line 252 of file String-inl.h.

References folly::Range< Iter >::size().

                                       {
  return s.size();
}

template<class Tgt >

Expected<Tgt, ConversionCode> folly::detail::digits_to ( const char *  b, const char *const  e  )

inlinenoexcept

String represented as a pair of pointers to char to signed/unsigned integrals. Assumes NO whitespace before or after, and also that the string is composed entirely of digits (and an optional sign only for signed types). String may be empty, in which case digits_to returns an appropriate error.

Definition at line 533 of file Conv.cpp.

References b, folly::digits10(), digits_to< char >(), digits_to< int >(), digits_to< long >(), digits_to< long long >(), digits_to< short >(), digits_to< signed char >(), digits_to< unsigned char >(), digits_to< unsigned int >(), digits_to< unsigned long >(), digits_to< unsigned long long >(), digits_to< unsigned short >(), int32_t, folly::makeUnexpected(), folly::NO_DIGITS, folly::pushmi::__adl::noexcept(), folly::NON_DIGIT_CHAR, folly::size(), folly::SUCCESS, sum(), type, UNLIKELY, and value.

Referenced by folly::toAppendStrImpl().

                                  {
  using UT = typename std::make_unsigned<Tgt>::type;
  assert(b <= e);

  SignedValueHandler<Tgt> sgn;

  auto err = sgn.init(b);
  if (UNLIKELY(err != ConversionCode::SUCCESS)) {
    return makeUnexpected(err);
  }

  size_t size = size_t(e - b);

  /* Although the string is entirely made of digits, we still need to
   * check for overflow.
   */
  if (size > std::numeric_limits<UT>::digits10) {
    // Leading zeros?
    if (b < e && *b == '0') {
      for (++b;; ++b) {
        if (b == e) {
          return Tgt(0); // just zeros, e.g. "0000"
        }
        if (*b != '0') {
          size = size_t(e - b);
          break;
        }
      }
    }
    if (size > std::numeric_limits<UT>::digits10 &&
        (size != std::numeric_limits<UT>::digits10 + 1 ||
         strncmp(b, MaxString<UT>::value, size) > 0)) {
      return makeUnexpected(sgn.overflow());
    }
  }

  // Here we know that the number won't overflow when
  // converted. Proceed without checks.

  UT result = 0;

  for (; e - b >= 4; b += 4) {
    result *= static_cast<UT>(10000);
    const int32_t r0 = shift1000[static_cast<size_t>(b[0])];
    const int32_t r1 = shift100[static_cast<size_t>(b[1])];
    const int32_t r2 = shift10[static_cast<size_t>(b[2])];
    const int32_t r3 = shift1[static_cast<size_t>(b[3])];
    const auto sum = r0 + r1 + r2 + r3;
    if (sum >= OOR) {
      goto outOfRange;
    }
    result += UT(sum);
  }

  switch (e - b) {
    case 3: {
      const int32_t r0 = shift100[static_cast<size_t>(b[0])];
      const int32_t r1 = shift10[static_cast<size_t>(b[1])];
      const int32_t r2 = shift1[static_cast<size_t>(b[2])];
      const auto sum = r0 + r1 + r2;
      if (sum >= OOR) {
        goto outOfRange;
      }
      result = UT(1000 * result + sum);
      break;
    }
    case 2: {
      const int32_t r0 = shift10[static_cast<size_t>(b[0])];
      const int32_t r1 = shift1[static_cast<size_t>(b[1])];
      const auto sum = r0 + r1;
      if (sum >= OOR) {
        goto outOfRange;
      }
      result = UT(100 * result + sum);
      break;
    }
    case 1: {
      const int32_t sum = shift1[static_cast<size_t>(b[0])];
      if (sum >= OOR) {
        goto outOfRange;
      }
      result = UT(10 * result + sum);
      break;
    }
    default:
      assert(b == e);
      if (size == 0) {
        return makeUnexpected(ConversionCode::NO_DIGITS);
      }
      break;
  }

  return sgn.finalize(result);

outOfRange:
  return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
}

template Expected<char, ConversionCode> folly::detail::digits_to< char > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<int, ConversionCode> folly::detail::digits_to< int > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<long, ConversionCode> folly::detail::digits_to< long > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<long long, ConversionCode> folly::detail::digits_to< long long > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<short, ConversionCode> folly::detail::digits_to< short > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<signed char, ConversionCode> folly::detail::digits_to< signed char > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<unsigned char, ConversionCode> folly::detail::digits_to< unsigned char > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<unsigned int, ConversionCode> folly::detail::digits_to< unsigned int > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<unsigned long, ConversionCode> folly::detail::digits_to< unsigned long > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<unsigned long long, ConversionCode> folly::detail::digits_to< unsigned long long > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template Expected<unsigned short, ConversionCode> folly::detail::digits_to< unsigned short > ( const char *  , const char *    )

noexcept

Referenced by digits_to(), and folly::toAppendStrImpl().

template<class Iterator >

int folly::detail::distance_if_multipass	(	Iterator	first,
		Iterator	last
	)

Definition at line 122 of file sorted_vector_types.h.

References value.

Referenced by bulk_insert().

                                                         {
  typedef typename std::iterator_traits<Iterator>::iterator_category categ;
  if (std::is_same<categ, std::input_iterator_tag>::value) {
    return -1;
  }
  return std::distance(first, last);
}

template<typename T >

constexpr T folly::detail::divCeilBranchful ( T  num, T  denom  )

inline

Definition at line 68 of file Math.h.

References value.

                                                    {
  // First case handles negative or zero rational result, where trunc and ceil
  // are the same.
  // Second case handles positive result by preconditioning numerator.
  // Preconditioning decreases the magnitude of the numerator, which is
  // itself sign-dependent.
  return (std::is_signed<T>::value && (num ^ denom) < 0) || num == 0
      ? num / denom
      : (num + (num > 0 ? -1 : 1)) / denom + 1;
}

template<typename T >

constexpr T folly::detail::divCeilBranchless ( T  num, T  denom  )

inline

Definition at line 57 of file Math.h.

References value.

                                                     {
  // ceil != trunc when the answer isn't exact (truncation occurred)
  // and truncation went away from positive infinity.  That happens when
  // the true answer is positive, which happens when num and denom have
  // the same sign.
  return (num / denom) +
      ((num % denom) != 0 ? 1 : 0) *
      (std::is_signed<T>::value && (num ^ denom) < 0 ? 0 : 1);
}

template<typename T >

constexpr T folly::detail::divFloorBranchful ( T  num, T  denom  )

inline

Definition at line 46 of file Math.h.

References value.

                                                     {
  // First case handles negative result by preconditioning numerator.
  // Preconditioning decreases the magnitude of the numerator, which is
  // itself sign-dependent.  Second case handles zero or positive rational
  // result, where trunc and floor are the same.
  return std::is_signed<T>::value && (num ^ denom) < 0 && num != 0
      ? (num + (num > 0 ? -1 : 1)) / denom - 1
      : num / denom;
}

template<typename T >

constexpr T folly::detail::divFloorBranchless ( T  num, T  denom  )

inline

Definition at line 34 of file Math.h.

References value.

                                                      {
  // floor != trunc when the answer isn't exact and truncation went the
  // wrong way (truncation went toward positive infinity).  That happens
  // when the true answer is negative, which happens when num and denom
  // have different signs.  The following code compiles branch-free on
  // many platforms.
  return (num / denom) +
      ((num % denom) != 0 ? 1 : 0) *
      (std::is_signed<T>::value && (num ^ denom) < 0 ? -1 : 0);
}

template<typename T >

constexpr T folly::detail::divRoundAwayBranchful ( T  num, T  denom  )

inline

Definition at line 91 of file Math.h.

References value.

                                                         {
  // First case of second ternary operator handles negative rational
  // result, which is the same as divFloor.  Second case of second ternary
  // operator handles positive result, which is the same as divCeil.
  // Zero case is separated for simplicity.
  return num == 0 ? 0
                  : (num + (num > 0 ? -1 : 1)) / denom +
          (std::is_signed<T>::value && (num ^ denom) < 0 ? -1 : 1);
}

template<typename T >

constexpr T folly::detail::divRoundAwayBranchless ( T  num, T  denom  )

inline

Definition at line 80 of file Math.h.

References value.

                                                          {
  // away != trunc whenever truncation actually occurred, which is when
  // there is a non-zero remainder.  If the unrounded result is negative
  // then fixup moves it toward negative infinity.  If the unrounded
  // result is positive then adjustment makes it larger.
  return (num / denom) +
      ((num % denom) != 0 ? 1 : 0) *
      (std::is_signed<T>::value && (num ^ denom) < 0 ? -1 : 1);
}

void folly::detail::double_radix_sort	(	uint64_t	n,
		uint64_t *	buckets,
		double *	in,
		double *	tmp
	)

Definition at line 83 of file DoubleRadixSort.cpp.

References double_radix_sort_rec().

Referenced by folly::TDigest::merge(), and TEST().

                                                                               {
  // If array is too small, use std::sort directly.
  if (n < 700) {
    std::sort(in, in + n);
  } else {
    detail::double_radix_sort_rec(n, buckets, 0, false, in, tmp);
  }
}

static void folly::detail::double_radix_sort_rec ( uint64_t  n, uint64_t *  buckets, uint8_t  shift, bool  inout, double *  in, double *  out  )

static

Definition at line 36 of file DoubleRadixSort.cpp.

References getRadixBucket(), i, and uint64_t.

Referenced by double_radix_sort().

                 {
  // First pass: calculate bucket counts.
  memset(buckets, 0, 256 * sizeof(uint64_t));
  for (uint64_t i = 0; i < n; i++) {
    buckets[getRadixBucket(&in[i], shift)]++;
  }

  // Second pass: calculate bucket start positions.
  uint64_t tot = 0;
  for (uint64_t i = 0; i < 256; i++) {
    auto prev = tot;
    tot += buckets[i];
    buckets[i + 256] = prev;
  }

  // Third pass: Move based on radix counts.
  for (uint64_t i = 0; i < n; i++) {
    auto pos = buckets[getRadixBucket(&in[i], shift) + 256]++;
    out[pos] = in[i];
  }

  // If we haven't used up all input bytes, recurse and sort.  if the
  // bucket is too small, use std::sort instead, and copy output to
  // correct array.
  if (shift < 56) {
    tot = 0;
    for (int i = 0; i < 256; i++) {
      if (buckets[i] < 256) {
        std::sort(out + tot, out + tot + buckets[i]);
        if (!inout) {
          memcpy(in + tot, out + tot, buckets[i] * sizeof(double));
        }
      } else {
        double_radix_sort_rec(
            buckets[i], buckets + 256, shift + 8, !inout, out + tot, in + tot);
      }
      tot += buckets[i];
    }
  }
}

template<class T , class U >

std::enable_if<HasLess<U, T>::value, bool>::type folly::detail::downTo	(	T &	iter,
		const U &	begin
	)

downTo is similar to notThereYet, but in reverse - it helps the FOR_EACH_RANGE_R macro.

Definition at line 287 of file Foreach.h.

                    {
  return begin < iter--;
}

template<class T , class U >

std::enable_if<!HasLess<U, T>::value, bool>::type folly::detail::downTo	(	T &	iter,
		const U &	begin
	)

Definition at line 294 of file Foreach.h.

                    {
  if (iter == begin) {
    return false;
  }
  --iter;
  return true;
}

template<typename SubsecondRatio , typename Rep >

static Expected<std::pair<time_t, long>, ConversionCode> folly::detail::durationToPosixTime ( const std::chrono::duration< Rep, std::ratio< 1, 1 >> &  duration )

static

Convert a std::chrono::duration with second granularity to a pair of (seconds, subseconds)

The SubsecondRatio template parameter specifies what type of subseconds to return. This must have a numerator of 1.

Definition at line 96 of file Conv.h.

References chronoRangeCheck(), folly::makeUnexpected(), folly::NEGATIVE_OVERFLOW, and value.

                                                            {
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  auto sec = chronoRangeCheck(duration.count());
  if (sec.hasError()) {
    return makeUnexpected(sec.error());
  }

  time_t secValue = sec.value();
  long subsec = 0L;
  if (std::is_floating_point<Rep>::value) {
    auto fraction = (duration.count() - secValue);
    subsec = static_cast<long>(fraction * SubsecondRatio::den);
    if (duration.count() < 0 && fraction < 0) {
      if (secValue == std::numeric_limits<time_t>::lowest()) {
        return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
      }
      secValue -= 1;
      subsec += SubsecondRatio::den;
    }
  }
  return std::pair<time_t, long>{secValue, subsec};
}

template<typename SubsecondRatio , typename Rep , std::intmax_t Denominator>

static Expected<std::pair<time_t, long>, ConversionCode> folly::detail::durationToPosixTime ( const std::chrono::duration< Rep, std::ratio< 1, Denominator >> &  duration )

static

Convert a std::chrono::duration with subsecond granularity to a pair of (seconds, subseconds)

Definition at line 127 of file Conv.h.

References chronoRangeCheck(), folly::makeUnexpected(), folly::NEGATIVE_OVERFLOW, and UNLIKELY.

                                                                      {
  static_assert(Denominator != 1, "special case expecting den != 1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  auto sec = chronoRangeCheck(duration.count() / Denominator);
  if (sec.hasError()) {
    return makeUnexpected(sec.error());
  }
  auto secTimeT = sec.value();

  auto remainder = duration.count() - (secTimeT * Denominator);
  auto subsec = (remainder * SubsecondRatio::den) / Denominator;
  if (UNLIKELY(duration.count() < 0) && remainder != 0) {
    if (secTimeT == std::numeric_limits<time_t>::lowest()) {
      return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
    }
    secTimeT -= 1;
    subsec += SubsecondRatio::den;
  }

  return std::pair<time_t, long>{secTimeT, subsec};
}

template<typename SubsecondRatio , typename Rep , std::intmax_t Numerator>

static Expected<std::pair<time_t, long>, ConversionCode> folly::detail::durationToPosixTime ( const std::chrono::duration< Rep, std::ratio< Numerator, 1 >> &  duration )

static

Convert a std::chrono::duration with coarser-than-second granularity to a pair of (seconds, subseconds)

Definition at line 157 of file Conv.h.

References folly::makeUnexpected(), max, folly::NEGATIVE_OVERFLOW, folly::POSITIVE_OVERFLOW, and value.

                                                                    {
  static_assert(Numerator != 1, "special case expecting num!=1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  constexpr auto maxValue = std::numeric_limits<time_t>::max() / Numerator;
  constexpr auto minValue = std::numeric_limits<time_t>::lowest() / Numerator;
  if (duration.count() > maxValue) {
    return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
  }
  if (duration.count() < minValue) {
    return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
  }

  // Note that we can't use chronoRangeCheck() here since we have to check
  // if (duration.count() * Numerator) would overflow (which we do above).
  auto secOriginalRep = (duration.count() * Numerator);
  auto sec = static_cast<time_t>(secOriginalRep);

  long subsec = 0L;
  if (std::is_floating_point<Rep>::value) {
    auto fraction = secOriginalRep - sec;
    subsec = static_cast<long>(fraction * SubsecondRatio::den);
    if (duration.count() < 0 && fraction < 0) {
      if (sec == std::numeric_limits<time_t>::lowest()) {
        return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
      }
      sec -= 1;
      subsec += SubsecondRatio::den;
    }
  }
  return std::pair<time_t, long>{sec, subsec};
}

template<typename SubsecondRatio , typename Rep , typename Period >

Expected<std::pair<time_t, long>, ConversionCode> folly::detail::durationToPosixTime

(

const std::chrono::duration< Rep, Period > &

duration

)

Convert a std::chrono::duration to a pair of (seconds, subseconds)

This overload is only used for unusual durations where neither the numerator nor denominator are 1.

Definition at line 229 of file Conv.h.

References folly::makeUnexpected(), max, min, folly::NEGATIVE_OVERFLOW, and folly::POSITIVE_OVERFLOW.

                                                    {
  static_assert(Period::num != 1, "should use special-case code when num==1");
  static_assert(Period::den != 1, "should use special-case code when den==1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  // Perform this conversion by first converting to a duration where the
  // numerator is 1, then convert to the output type.
  using IntermediateType = IntermediateDuration<Rep, Period>;
  using IntermediateRep = typename IntermediateType::rep;

  // Check to see if we would have overflow converting to the intermediate
  // type.
  constexpr auto maxInput =
      std::numeric_limits<IntermediateRep>::max() / Period::num;
  if (duration.count() > maxInput) {
    return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
  }
  constexpr auto minInput =
      std::numeric_limits<IntermediateRep>::min() / Period::num;
  if (duration.count() < minInput) {
    return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
  }
  auto intermediate =
      IntermediateType{static_cast<IntermediateRep>(duration.count()) *
                       static_cast<IntermediateRep>(Period::num)};

  return durationToPosixTime<SubsecondRatio>(intermediate);
}

void folly::detail::enforceWhitespace ( StringPiece  sp )

inline

Keep this implementation around for prettyToDouble().

Definition at line 130 of file Conv.h.

References enforceWhitespaceErr(), folly::makeConversionError(), folly::SUCCESS, folly::throw_exception(), type, and folly::value().

Referenced by folly::prettyToDouble().

                                              {
  auto err = enforceWhitespaceErr(sp);
  if (err != ConversionCode::SUCCESS) {
    throw_exception(makeConversionError(err, sp));
  }
}

ConversionCode folly::detail::enforceWhitespaceErr ( StringPiece  sp )

inline

Enforce that the suffix following a number is made up only of whitespace.

Definition at line 118 of file Conv.h.

References c, folly::NON_WHITESPACE_AFTER_END, folly::SUCCESS, and UNLIKELY.

Referenced by enforceWhitespace(), and folly::detail::CheckTrailingSpace::operator()().

                                                           {
  for (auto c : sp) {
    if (UNLIKELY(!std::isspace(c))) {
      return ConversionCode::NON_WHITESPACE_AFTER_END;
    }
  }
  return ConversionCode::SUCCESS;
}

template<typename Tgt , typename Src >

std::string folly::detail::errorValue ( const Src &  value )

inline

Definition at line 1337 of file Conv.h.

References folly::demangle(), value, and folly::value().

                                              {
#ifdef FOLLY_HAS_RTTI
  return to<std::string>("(", demangle(typeid(Tgt)), ") ", value);
#else
  return to<std::string>(value);
#endif
}

QuantileEstimates folly::detail::estimatesFromDigest	(	const TDigest &	digest,
		Range< const double * >	quantiles
	)

Definition at line 22 of file QuantileEstimator.cpp.

References folly::Range< Iter >::begin(), folly::QuantileEstimates::count, folly::TDigest::count(), folly::Range< Iter >::end(), folly::TDigest::estimateQuantile(), folly::QuantileEstimates::quantiles, folly::Range< Iter >::size(), folly::QuantileEstimates::sum, and folly::TDigest::sum().

Referenced by folly::SimpleQuantileEstimator< ClockT >::estimateQuantiles(), and folly::SlidingWindowQuantileEstimator< ClockT >::estimateQuantiles().

                                    {
  QuantileEstimates result;
  result.quantiles.reserve(quantiles.size());
  result.sum = digest.sum();
  result.count = digest.count();
  for (auto it = quantiles.begin(); it != quantiles.end(); ++it) {
    result.quantiles.push_back(
        std::make_pair(*it, digest.estimateQuantile(*it)));
  }
  return result;
}

template<class... KeysDefault>

auto folly::detail::extract_default

(

const KeysDefault &...

keysDefault

)

-> typename DefaultType<KeysDefault...>::type const&

Definition at line 213 of file MapUtil.h.

References folly::pushmi::operators::get.

Referenced by folly::get_default(), and folly::get_ref_default().

                                                    {
  return std::get<sizeof...(KeysDefault) - 1>(std::tie(keysDefault...));
}

template<typename Arg >

auto folly::detail::fallbackFormatOneArg	(	std::string *	str,
		const Arg *	arg,
		int
	)		-> decltype( toAppend(std::declval<Arg>(), std::declval<std::string*>()), std::declval<void>())

Definition at line 42 of file LogStreamProcessor.h.

References folly::demangle(), and folly::toAppend().

Referenced by folly::LogStreamProcessor::fallbackFormat().

                        {
  str->push_back('(');
  try {
#ifdef FOLLY_HAS_RTTI
    toAppend(folly::demangle(typeid(*arg)), str);
    str->append(": ");
#endif
    toAppend(*arg, str);
  } catch (const std::exception&) {
    str->append("<error_converting_to_string>");
  }
  str->push_back(')');
}

template<typename Arg >

void folly::detail::fallbackFormatOneArg ( std::string *  str, const Arg *  arg, long    )

inline

Definition at line 59 of file LogStreamProcessor.h.

References folly::demangle(), and folly::toAppend().

                                                                       {
  str->push_back('(');
#ifdef FOLLY_HAS_RTTI
  try {
    toAppend(folly::demangle(typeid(*arg)), str);
    str->append(": ");
  } catch (const std::exception&) {
    // Ignore the error
  }
#endif
  str->append("<no_string_conversion>)");
}

std::string folly::detail::familyNameStr ( sa_family_t  family )

inline

Definition at line 30 of file IPAddress.h.

References familyNameStrDefault(), and getNthMSBitImplThrow().

Referenced by getNthMSBitImplThrow(), folly::IPAddressV4::getNthMSByte(), folly::IPAddressV6::getNthMSByte(), folly::operator<(), and folly::toAppend().

                                                   {
  switch (family) {
    case AF_INET:
      return "AF_INET";
    case AF_INET6:
      return "AF_INET6";
    case AF_UNSPEC:
      return "AF_UNSPEC";
    case AF_UNIX:
      return "AF_UNIX";
    default:
      return familyNameStrDefault(family);
  }
}

std::string folly::detail::familyNameStrDefault

(

sa_family_t

family

)

Definition at line 24 of file IPAddress.cpp.

References folly::sformat().

Referenced by familyNameStr().

                                                   {
  return sformat("sa_family_t({})", family);
}

void folly::detail::fastIpv4AppendToString ( const in_addr &  inAddr, std::string &  out  )

inline

Definition at line 239 of file IPAddressSource.h.

References fastIpV4ToBufferUnsafe().

Referenced by folly::IPAddressV4::toFullyQualifiedAppend().

                                                                          {
  char str[sizeof("255.255.255.255")];
  out.append(str, fastIpV4ToBufferUnsafe(inAddr, str));
}

size_t folly::detail::fastIpV4ToBufferUnsafe ( const in_addr &  inAddr, char *  str  )

inline

Definition at line 219 of file IPAddressSource.h.

References uint8_t.

Referenced by fastIpv4AppendToString(), and fastIpv4ToString().

                                                                       {
  const uint8_t* octets = reinterpret_cast<const uint8_t*>(&inAddr.s_addr);
  char* buf = str;

  writeIntegerString<uint8_t, 3>(octets[0], &buf);
  *(buf++) = '.';
  writeIntegerString<uint8_t, 3>(octets[1], &buf);
  *(buf++) = '.';
  writeIntegerString<uint8_t, 3>(octets[2], &buf);
  *(buf++) = '.';
  writeIntegerString<uint8_t, 3>(octets[3], &buf);

  return buf - str;
}

std::string folly::detail::fastIpv4ToString ( const in_addr &  inAddr )

inline

Definition at line 234 of file IPAddressSource.h.

References fastIpV4ToBufferUnsafe(), and string.

Referenced by folly::IPAddressV4::str(), and TEST().

                                                         {
  char str[sizeof("255.255.255.255")];
  return std::string(str, fastIpV4ToBufferUnsafe(inAddr, str));
}

void folly::detail::fastIpv6AppendToString ( const in6_addr &  in6Addr, std::string &  out  )

inline

Definition at line 272 of file IPAddressSource.h.

References fastIpv6ToBufferUnsafe().

Referenced by folly::IPAddressV6::toFullyQualifiedAppend().

                                                                            {
  char str[sizeof("2001:0db8:0000:0000:0000:ff00:0042:8329")];
  out.append(str, fastIpv6ToBufferUnsafe(in6Addr, str));
}

size_t folly::detail::fastIpv6ToBufferUnsafe ( const in6_addr &  in6Addr, char *  str  )

inline

Definition at line 244 of file IPAddressSource.h.

References i, uint16_t, and writeIntegerString().

Referenced by fastIpv6AppendToString(), and fastIpv6ToString().

                                                                         {
#ifdef _MSC_VER
  const uint16_t* bytes = reinterpret_cast<const uint16_t*>(&in6Addr.u.Word);
#else
  const uint16_t* bytes = reinterpret_cast<const uint16_t*>(&in6Addr.s6_addr16);
#endif
  char* buf = str;

  for (int i = 0; i < 8; ++i) {
    writeIntegerString<
        uint16_t,
        4, // at most 4 hex digits per ushort
        16, // base 16 (hex)
        true>(htons(bytes[i]), &buf);

    if (i != 7) {
      *(buf++) = ':';
    }
  }

  return buf - str;
}

std::string folly::detail::fastIpv6ToString ( const in6_addr &  in6Addr )

inline

Definition at line 267 of file IPAddressSource.h.

References fastIpv6ToBufferUnsafe(), and string.

Referenced by TEST(), and folly::IPAddressV6::toFullyQualified().

                                                           {
  char str[sizeof("2001:0db8:0000:0000:0000:ff00:0042:8329")];
  return std::string(str, fastIpv6ToBufferUnsafe(in6Addr, str));
}

folly::detail::FOLLY_CREATE_MEMBER_INVOKE_TRAITS	(	AllocatorConstruct_	,
		construct
	)

folly::detail::FOLLY_CREATE_MEMBER_INVOKE_TRAITS	(	AllocatorDestroy_	,
		destroy
	)

FOLLY_PUSH_WARNING folly::detail::FOLLY_MSVC_DISABLE_WARNING

(

4388

)

template<typename Futex >

FutexResult folly::detail::futexWait	(	const Futex *	futex,
		uint32_t	expected,
		uint32_t	waitMask = -1
	)

Puts the thread to sleep if this->load() == expected. Returns true when it is returning because it has consumed a wake() event, false for any other return (signal, this->load() != expected, or spurious wakeup).

Definition at line 100 of file Futex-inl.h.

References futexWaitImpl(), and TIMEDOUT.

Referenced by folly::detail::atomic_notification::atomic_wait_impl(), BENCHMARK(), folly::detail::distributed_mutex::doFutexWait(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WaitForever::doWait(), folly::detail::MemoryIdler::futexWait(), folly::MicroLockCore::lockSlowPath(), MockAtom< T >::MockAtom(), run_basic_tests(), run_basic_thread(), run_wake_blocked_test(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::tryBlockingPop(), folly::detail::TurnSequencer< std::atomic >::tryWaitForTurn(), folly::EventCount::wait(), and folly::detail::ThreadCachedInts< folly::detail::folly::detail::Tag >::waitForZero().

                                                                    {
  auto rv = futexWaitImpl(futex, expected, nullptr, nullptr, waitMask);
  assert(rv != FutexResult::TIMEDOUT);
  return rv;
}

FutexResult folly::detail::futexWaitImpl	(	const Futex< std::atomic > *	futex,
		uint32_t	expected,
		std::chrono::system_clock::time_point const *	absSystemTime,
		std::chrono::steady_clock::time_point const *	absSteadyTime,
		uint32_t	waitMask
	)

Referenced by futexWait(), futexWaitImpl(), futexWaitUntil(), and time_point_conv().

FutexResult folly::detail::futexWaitImpl	(	const Futex< EmulatedFutexAtomic > *	futex,
		uint32_t	expected,
		std::chrono::system_clock::time_point const *	absSystemTime,
		std::chrono::steady_clock::time_point const *	absSteadyTime,
		uint32_t	waitMask
	)

template<typename Futex , typename Deadline >

std::enable_if<Deadline::clock::is_steady, FutexResult>::type folly::detail::futexWaitImpl	(	Futex *	futex,
		uint32_t	expected,
		Deadline const &	deadline,
		uint32_t	waitMask
	)

Definition at line 80 of file Futex-inl.h.

References futexWaitImpl(), and type.

                       {
  return futexWaitImpl(futex, expected, nullptr, &deadline, waitMask);
}

template<typename Futex , typename Deadline >

std::enable_if<!Deadline::clock::is_steady, FutexResult>::type folly::detail::futexWaitImpl	(	Futex *	futex,
		uint32_t	expected,
		Deadline const &	deadline,
		uint32_t	waitMask
	)

Definition at line 90 of file Futex-inl.h.

References futexWaitImpl().

                       {
  return futexWaitImpl(futex, expected, &deadline, nullptr, waitMask);
}

FutexResult folly::detail::futexWaitImpl	(	const Futex< std::atomic > *	futex,
		uint32_t	expected,
		system_clock::time_point const *	absSystemTime,
		steady_clock::time_point const *	absSteadyTime,
		uint32_t	waitMask
	)

Definition at line 245 of file Futex.cpp.

                       {
#ifdef __linux__
  return nativeFutexWaitImpl(
      futex, expected, absSystemTime, absSteadyTime, waitMask);
#else
  return emulatedFutexWaitImpl(
      futex, expected, absSystemTime, absSteadyTime, waitMask);
#endif
}

FutexResult folly::detail::futexWaitImpl	(	const Futex< EmulatedFutexAtomic > *	futex,
		uint32_t	expected,
		system_clock::time_point const *	absSystemTime,
		steady_clock::time_point const *	absSteadyTime,
		uint32_t	waitMask
	)

Definition at line 260 of file Futex.cpp.

                       {
  return emulatedFutexWaitImpl(
      futex, expected, absSystemTime, absSteadyTime, waitMask);
}

template<typename Futex , class Clock , class Duration >

FutexResult folly::detail::futexWaitUntil	(	const Futex *	futex,
		uint32_t	expected,
		std::chrono::time_point< Clock, Duration > const &	deadline,
		uint32_t	waitMask = -1
	)

Similar to futexWait but also accepts a deadline until when the wait call may block.

Optimal clock types: std::chrono::system_clock, std::chrono::steady_clock. NOTE: On some systems steady_clock is just an alias for system_clock, and is not actually steady.

For any other clock type, now() will be invoked twice.

Definition at line 112 of file Futex-inl.h.

References futexWaitImpl(), max, and type.

Referenced by folly::detail::atomic_notification::atomic_wait_until_impl(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::canEnqueue(), deterministicAtomicWaitUntilTests(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WaitForDuration< Rep, Period >::doWait(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WaitUntilDeadline< Clock, Duration >::doWait(), folly::detail::MemoryIdler::futexWaitPreIdle(), folly::detail::MemoryIdler::futexWaitUntil(), liveClockWaitUntilTests(), MockAtom< T >::MockAtom(), TEST(), and folly::detail::TurnSequencer< std::atomic >::tryWaitForTurn().

                       {
  using Target = typename std::conditional<
      Clock::is_steady,
      std::chrono::steady_clock,
      std::chrono::system_clock>::type;
  auto const converted = time_point_conv<Target>(deadline);
  return converted == Target::time_point::max()
      ? futexWaitImpl(futex, expected, nullptr, nullptr, waitMask)
      : futexWaitImpl(futex, expected, converted, waitMask);
}

template<typename Futex >

int folly::detail::futexWake	(	const Futex *	futex,
		int	count = std::numeric_limits< int >::max(),
		uint32_t	wakeMask = -1
	)

Wakes up to count waiters where (waitMask & wakeMask) != 0, returning the number of awoken threads, or -1 if an error occurred. Note that when constructing a concurrency primitive that can guard its own destruction, it is likely that you will want to ignore EINVAL here (as well as making sure that you never touch the object after performing the memory store that is the linearization point for unlock or control handoff). See https://sourceware.org/bugzilla/show_bug.cgi?id=13690

Definition at line 107 of file Futex-inl.h.

References futexWakeImpl().

Referenced by folly::detail::atomic_notification::atomic_notify_all_impl(), folly::detail::atomic_notification::atomic_notify_one_impl(), BENCHMARK(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::blockingPushImpl(), folly::detail::TurnSequencer< std::atomic >::completeTurn(), folly::detail::ThreadCachedInts< folly::detail::folly::detail::Tag >::decrement(), folly::detail::distributed_mutex::doFutexWake(), folly::EventCount::doNotify(), folly::SharedMutexImpl< true >::futexWakeAll(), liveClockWaitUntilTests(), folly::Baton< MayBlock, Atom >::post(), folly::SaturatingSemaphore< MayBlock, Atom >::postSlowWaiterMayBlock(), folly::fibers::Baton::postThread(), run_basic_tests(), run_wake_blocked_test(), folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::transferCredit(), folly::MicroLockCore::unlock(), folly::SharedMutexImpl< true >::wakeRegisteredWaitersImpl(), and folly::detail::ThreadCachedInts< Tag >::Integer::~Integer().

                                                                {
  return futexWakeImpl(futex, count, wakeMask);
}

int folly::detail::futexWakeImpl	(	const Futex< std::atomic > *	futex,
		int	count,
		uint32_t	wakeMask
	)

Available overloads, with definitions elsewhere

These functions are treated as ADL-extension points, the templates above call these functions without them having being pre-declared. This works because ADL lookup finds the definitions of these functions when you pass the relevant arguments

Definition at line 227 of file Futex.cpp.

Referenced by futexWake(), and time_point_conv().

                       {
#ifdef __linux__
  return nativeFutexWake(futex, count, wakeMask);
#else
  return emulatedFutexWake(futex, count, wakeMask);
#endif
}

int folly::detail::futexWakeImpl	(	const Futex< EmulatedFutexAtomic > *	futex,
		int	count,
		uint32_t	wakeMask
	)

Definition at line 238 of file Futex.cpp.

                       {
  return emulatedFutexWake(futex, count, wakeMask);
}

template<typename... Ts>

auto folly::detail::getLastElement

(

const Ts &...

ts

)

-> decltype(LastElementImpl<Ts...>::call(ts...))

Definition at line 232 of file Conv.h.

References folly::detail::LastElementImpl< Ts >::call().

Referenced by folly::reserveInTargetDelim(), folly::to(), and folly::toAppendStrImpl().

                                                   {
  return LastElementImpl<Ts...>::call(ts...);
}

template<typename IPAddrType >

bool folly::detail::getNthMSBitImpl ( const IPAddrType &  ip, size_t  bitIndex, sa_family_t  family  )

inline

Definition at line 49 of file IPAddress.h.

References getNthMSBitImplThrow().

Referenced by folly::IPAddressV4::getNthMSBit(), and folly::IPAddressV6::getNthMSBit().

                                                                           {
  if (bitIndex >= ip.bitCount()) {
    getNthMSBitImplThrow(ip.bitCount(), family);
  }
  // Underlying bytes are in n/w byte order
  return (ip.getNthMSByte(bitIndex / 8) & (0x80 >> (bitIndex % 8))) != 0;
}

void folly::detail::getNthMSBitImplThrow	(	size_t	bitCount,
		sa_family_t	family
	)

Definition at line 28 of file IPAddress.cpp.

References familyNameStr(), and folly::sformat().

Referenced by familyNameStr(), and getNthMSBitImpl().

                                                                            {
  throw std::invalid_argument(sformat(
      "Bit index must be < {} for addresses of type: {}",
      bitCount,
      familyNameStr(family)));
}

template<class Iterator >

FOLLY_ALWAYS_INLINE auto folly::detail::getPointer	(	const Iterator &	it,
		long
	)		-> decltype(std::addressof(*it))

Definition at line 68 of file Enumerate.h.

Referenced by folly::detail::Enumerator< Iterator >::Proxy::operator->().

                                   {
  return std::addressof(*it);
}

template<class Iterator >

FOLLY_ALWAYS_INLINE auto folly::detail::getPointer	(	const Iterator &	it,
		int
	)		-> decltype(it.operator->())

Definition at line 73 of file Enumerate.h.

                                 {
  return it.operator->();
}

static uint8_t folly::detail::getRadixBucket ( double *  f, uint8_t  shift  )

static

Definition at line 27 of file DoubleRadixSort.cpp.

References int64_t, uint64_t, and val.

Referenced by double_radix_sort_rec().

                                                        {
  uint64_t val;
  memcpy(&val, f, sizeof(double));
  uint64_t mask = -int64_t(val >> 63) | 0x8000000000000000;
  auto adjusted = val ^ mask;
  return (adjusted >> (64 - 8 - shift)) & 0xFF;
}

std::shared_ptr< Timekeeper > folly::detail::getTimekeeperSingleton

(

)

Definition at line 159 of file ThreadWheelTimekeeper.cpp.

Referenced by folly::futures::sleep(), and folly::futures::detail::FutureBase< T >::withinImplementation().

                                                   {
  return timekeeperSingleton_.try_get();
}

template<typename RHS , RHS rhs, typename LHS >

bool folly::detail::greater_than_impl

(

LHS const

lhs

)

Definition at line 660 of file Traits.h.

                                      {
  // clang-format off
  return
      rhs > std::numeric_limits<LHS>::max() ? false :
      rhs < std::numeric_limits<LHS>::min() ? true :
      lhs > rhs;
  // clang-format on
}

void folly::detail::handleMallctlError	(	const char *	cmd,
		int	err
	)

Definition at line 27 of file MallctlHelper.cpp.

References folly::errnoStr(), and folly::sformat().

Referenced by mallctlHelper().

                                                               {
  assert(err != 0);
  throw std::runtime_error(
      sformat("mallctl {}: {} ({})", cmd, errnoStr(err), err));
}

constexpr int folly::detail::hazptr_domain_rcount_threshold

(

)

Definition at line 38 of file HazptrDomain.h.

References Atom.

Referenced by TEST().

                                               {
  return 1000;
}

size_t folly::detail::hexDumpLine	(	const void *	ptr,
		size_t	offset,
		size_t	size,
		std::string &	line
	)

Hex-dump at most 16 bytes starting at offset from a memory area of size bytes. Return the number of bytes actually dumped.

Definition at line 651 of file String.cpp.

References c, i, min, ptr, and uint8_t.

Referenced by folly::hexDump(), and folly::unhexlify().

                                                                          {
  static char hexValues[] = "0123456789abcdef";
  // Line layout:
  // 8: address
  // 1: space
  // (1+2)*16: hex bytes, each preceded by a space
  // 1: space separating the two halves
  // 3: "  |"
  // 16: characters
  // 1: "|"
  // Total: 78
  line.clear();
  line.reserve(78);
  const uint8_t* p = reinterpret_cast<const uint8_t*>(ptr) + offset;
  size_t n = std::min(size - offset, size_t(16));
  line.push_back(hexValues[(offset >> 28) & 0xf]);
  line.push_back(hexValues[(offset >> 24) & 0xf]);
  line.push_back(hexValues[(offset >> 20) & 0xf]);
  line.push_back(hexValues[(offset >> 16) & 0xf]);
  line.push_back(hexValues[(offset >> 12) & 0xf]);
  line.push_back(hexValues[(offset >> 8) & 0xf]);
  line.push_back(hexValues[(offset >> 4) & 0xf]);
  line.push_back(hexValues[offset & 0xf]);
  line.push_back(' ');

  for (size_t i = 0; i < n; i++) {
    if (i == 8) {
      line.push_back(' ');
    }

    line.push_back(' ');
    line.push_back(hexValues[(p[i] >> 4) & 0xf]);
    line.push_back(hexValues[p[i] & 0xf]);
  }

  // 3 spaces for each byte we're not printing, one separating the halves
  // if necessary
  line.append(3 * (16 - n) + (n <= 8), ' ');
  line.append("  |");

  for (size_t i = 0; i < n; i++) {
    char c = (p[i] >= 32 && p[i] <= 126 ? static_cast<char>(p[i]) : '.');
    line.push_back(c);
  }
  line.append(16 - n, ' ');
  line.push_back('|');
  DCHECK_EQ(line.size(), 78u);

  return n;
}

template<class OurContainer , class Vector , class GrowthPolicy >

OurContainer::iterator folly::detail::insert_with_hint	(	OurContainer &	sorted,
		Vector &	cont,
		typename OurContainer::iterator	hint,
		typename OurContainer::value_type &&	value,
		GrowthPolicy &	po
	)

Definition at line 131 of file sorted_vector_types.h.

References folly::gen::move, and folly::value().

Referenced by folly::sorted_vector_set< folly::RequestData * >::insert(), and folly::sorted_vector_map< Key, Value, Compare, Allocator, GrowthPolicy, Container >::insert().

                      {
  const typename OurContainer::value_compare& cmp(sorted.value_comp());
  if (hint == cont.end() || cmp(value, *hint)) {
    if (hint == cont.begin() || cmp(*(hint - 1), value)) {
      hint = po.increase_capacity(cont, hint);
      return cont.insert(hint, std::move(value));
    } else {
      return sorted.insert(std::move(value)).first;
    }
  }

  if (cmp(*hint, value)) {
    if (hint + 1 == cont.end() || cmp(value, *(hint + 1))) {
      hint = po.increase_capacity(cont, hint + 1);
      return cont.insert(hint, std::move(value));
    } else {
      return sorted.insert(std::move(value)).first;
    }
  }

  // Value and *hint did not compare, so they are equal keys.
  return hint;
}

void folly::detail::insertThousandsGroupingUnsafe	(	char *	start_buffer,
		char **	end_buffer
	)

Definition at line 387 of file Format.cpp.

References i, and uint32_t.

Referenced by folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat(), and testGrouping().

                                                                          {
  uint32_t remaining_digits = uint32_t(*end_buffer - start_buffer);
  uint32_t separator_size = (remaining_digits - 1) / 3;
  uint32_t result_size = remaining_digits + separator_size;
  *end_buffer = *end_buffer + separator_size;

  // get the end of the new string with the separators
  uint32_t buffer_write_index = result_size - 1;
  uint32_t buffer_read_index = remaining_digits - 1;
  start_buffer[buffer_write_index + 1] = 0;

  bool done = false;
  uint32_t next_group_size = 3;

  while (!done) {
    uint32_t current_group_size = std::max<uint32_t>(
        1, std::min<uint32_t>(remaining_digits, next_group_size));

    // write out the current group's digits to the buffer index
    for (uint32_t i = 0; i < current_group_size; i++) {
      start_buffer[buffer_write_index--] = start_buffer[buffer_read_index--];
    }

    // if not finished, write the separator before the next group
    if (buffer_write_index < buffer_write_index + 1) {
      start_buffer[buffer_write_index--] = ',';
    } else {
      done = true;
    }

    remaining_digits -= current_group_size;
  }
}

template<class Delim , class Iterator , class String >

std::enable_if<IsSizableStringContainerIterator<Iterator>::value>::type folly::detail::internalJoin	(	Delim	delimiter,
		Iterator	begin,
		Iterator	end,
		String &	output
	)

Definition at line 469 of file String-inl.h.

References folly::test::begin(), delimSize(), internalJoinAppend(), folly::size(), and type.

Referenced by folly::join().

                                                                            {
  output.clear();
  if (begin == end) {
    return;
  }
  const size_t dsize = delimSize(delimiter);
  Iterator it = begin;
  size_t size = it->size();
  while (++it != end) {
    size += dsize + it->size();
  }
  output.reserve(size);
  internalJoinAppend(delimiter, begin, end, output);
}

template<class Delim , class Iterator , class String >

std::enable_if< !IsSizableStringContainerIterator<Iterator>::value>::type folly::detail::internalJoin	(	Delim	delimiter,
		Iterator	begin,
		Iterator	end,
		String &	output
	)

Definition at line 487 of file String-inl.h.

References internalJoinAppend().

                                                                            {
  output.clear();
  if (begin == end) {
    return;
  }
  internalJoinAppend(delimiter, begin, end, output);
}

template<class Delim , class Iterator , class String >

void folly::detail::internalJoinAppend	(	Delim	delimiter,
		Iterator	begin,
		Iterator	end,
		String &	output
	)

Definition at line 451 of file String-inl.h.

References delimFront(), delimSize(), folly::toAppend(), type, and value.

Referenced by internalJoin().

                    {
  assert(begin != end);
  if (std::is_same<Delim, StringPiece>::value && delimSize(delimiter) == 1) {
    internalJoinAppend(delimFront(delimiter), begin, end, output);
    return;
  }
  toAppend(*begin, &output);
  while (++begin != end) {
    toAppend(delimiter, *begin, &output);
  }
}

template<class OutStringT , class DelimT , class OutputIterator >

void folly::detail::internalSplit	(	DelimT	delim,
		StringPiece	sp,
		OutputIterator	out,
		bool	ignoreEmpty
	)

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

References atDelim(), delimFront(), delimSize(), folly::Range< Iter >::empty(), i, s, folly::Range< Iter >::size(), folly::Range< Iter >::start(), folly::Range< Iter >::subpiece(), and value.

                      {
  assert(sp.empty() || sp.start() != nullptr);

  const char* s = sp.start();
  const size_t strSize = sp.size();
  const size_t dSize = delimSize(delim);

  if (dSize > strSize || dSize == 0) {
    if (!ignoreEmpty || strSize > 0) {
      *out++ = to<OutStringT>(sp);
    }
    return;
  }
  if (std::is_same<DelimT, StringPiece>::value && dSize == 1) {
    // Call the char version because it is significantly faster.
    return internalSplit<OutStringT>(delimFront(delim), sp, out, ignoreEmpty);
  }

  size_t tokenStartPos = 0;
  size_t tokenSize = 0;
  for (size_t i = 0; i <= strSize - dSize; ++i) {
    if (atDelim(&s[i], delim)) {
      if (!ignoreEmpty || tokenSize > 0) {
        *out++ = to<OutStringT>(sp.subpiece(tokenStartPos, tokenSize));
      }

      tokenStartPos = i + dSize;
      tokenSize = 0;
      i += dSize - 1;
    } else {
      ++tokenSize;
    }
  }
  tokenSize = strSize - tokenStartPos;
  if (!ignoreEmpty || tokenSize > 0) {
    *out++ = to<OutStringT>(sp.subpiece(tokenStartPos, tokenSize));
  }
}

template<typename Fn >

EnableForArgTypes<Fn> folly::detail::invokeForKeyValue	(	Fn	f,
		const folly::dynamic &	,
		const folly::dynamic &
	)

Definition at line 102 of file DynamicParser-inl.h.

References f.

Referenced by folly::DynamicParser::parse().

                                                                  {
  f();
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	,
		const folly::dynamic &	v
	)

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

                                                                     {
  fn(v);
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	,
		const folly::dynamic &	v
	)

Definition at line 117 of file DynamicParser-inl.h.

References folly::dynamic::asInt().

                                                                     {
  fn(v.asInt());
}

template<typename Fn >

EnableForArgTypes<Fn, bool> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	,
		const folly::dynamic &	v
	)

Definition at line 123 of file DynamicParser-inl.h.

References folly::dynamic::asBool().

                                                                     {
  fn(v.asBool());
}

template<typename Fn >

EnableForArgTypes<Fn, double> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	,
		const folly::dynamic &	v
	)

Definition at line 129 of file DynamicParser-inl.h.

References folly::dynamic::asDouble().

                                                                     {
  fn(v.asDouble());
}

template<typename Fn >

EnableForArgTypes<Fn, std::string> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	,
		const folly::dynamic &	v
	)

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

References folly::dynamic::asString().

                                                                     {
  fn(v.asString());
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic, folly::dynamic> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

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

                                                                       {
  fn(k, v);
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic, int64_t> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 154 of file DynamicParser-inl.h.

References folly::dynamic::asInt().

                                                                       {
  fn(k, v.asInt());
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic, bool> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 160 of file DynamicParser-inl.h.

References folly::dynamic::asBool().

                                                                       {
  fn(k, v.asBool());
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic, double> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 166 of file DynamicParser-inl.h.

References folly::dynamic::asDouble().

                                                                       {
  fn(k, v.asDouble());
}

template<typename Fn >

EnableForArgTypes<Fn, folly::dynamic, std::string> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 172 of file DynamicParser-inl.h.

References folly::dynamic::asString().

                                                                       {
  fn(k, v.asString());
}

template<typename Fn >

EnableForArgTypes<Fn, std::string, folly::dynamic> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 181 of file DynamicParser-inl.h.

References folly::dynamic::asString(), and v.

                                                                       {
  fn(k.asString(), v);
}

template<typename Fn >

EnableForArgTypes<Fn, std::string, int64_t> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 187 of file DynamicParser-inl.h.

References folly::dynamic::asInt(), and folly::dynamic::asString().

                                                                       {
  fn(k.asString(), v.asInt());
}

template<typename Fn >

EnableForArgTypes<Fn, std::string, bool> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 193 of file DynamicParser-inl.h.

References folly::dynamic::asBool(), and folly::dynamic::asString().

                                                                       {
  fn(k.asString(), v.asBool());
}

template<typename Fn >

EnableForArgTypes<Fn, std::string, double> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 199 of file DynamicParser-inl.h.

References folly::dynamic::asDouble(), and folly::dynamic::asString().

                                                                       {
  fn(k.asString(), v.asDouble());
}

template<typename Fn >

EnableForArgTypes<Fn, std::string, std::string> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 205 of file DynamicParser-inl.h.

References folly::dynamic::asString().

                                                                       {
  fn(k.asString(), v.asString());
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t, folly::dynamic> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 214 of file DynamicParser-inl.h.

References folly::dynamic::asInt(), and v.

                                                                       {
  fn(k.asInt(), v);
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t, int64_t> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 220 of file DynamicParser-inl.h.

References folly::dynamic::asInt().

                                                                       {
  fn(k.asInt(), v.asInt());
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t, bool> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 226 of file DynamicParser-inl.h.

References folly::dynamic::asBool(), and folly::dynamic::asInt().

                                                                       {
  fn(k.asInt(), v.asBool());
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t, double> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 232 of file DynamicParser-inl.h.

References folly::dynamic::asDouble(), and folly::dynamic::asInt().

                                                                       {
  fn(k.asInt(), v.asDouble());
}

template<typename Fn >

EnableForArgTypes<Fn, int64_t, std::string> folly::detail::invokeForKeyValue	(	Fn	fn,
		const folly::dynamic &	k,
		const folly::dynamic &	v
	)

Definition at line 238 of file DynamicParser-inl.h.

References folly::dynamic::asInt(), and folly::dynamic::asString().

                                                                       {
  fn(k.asInt(), v.asString());
}

FOLLY_PUSH_WARNING RHS LHS bool folly::detail::less_than_impl

(

LHS const

lhs

)

Definition at line 650 of file Traits.h.

                                   {
  // clang-format off
  return
      rhs > std::numeric_limits<LHS>::max() ? true :
      rhs <= std::numeric_limits<LHS>::min() ? false :
      lhs < rhs;
  // clang-format on
}

template<typename... SynchronizedLocker>

auto folly::detail::lock

(

SynchronizedLocker...

lockersIn

)

-> std::tuple<typename SynchronizedLocker::LockedPtr...>

Acquire locks for multiple Synchronized<T> objects, in a deadlock-safe manner.

The function uses the "smart and polite" algorithm from this link http://howardhinnant.github.io/dining_philosophers.html#Polite

The gist of the algorithm is that it locks a mutex, then tries to lock the other mutexes in a non-blocking manner. If all the locks succeed, we are done, if not, we release the locks we have held, yield to allow other threads to continue and then block on the mutex that we failed to acquire.

This allows dynamically yielding ownership of all the mutexes but one, so that other threads can continue doing work and locking the other mutexes. See the benchmarks in folly/test/SynchronizedBenchmark.cpp for more.

Definition at line 871 of file Synchronized.h.

References testing::Args(), folly::fetch(), folly::for_each(), folly::loop_break, folly::loop_continue, folly::gen::move, and folly::fibers::yield().

Referenced by testing::UnitTest::AddTestPartResult(), BENCHMARK(), burn(), testing::UnitTest::current_test_case(), testing::UnitTest::current_test_info(), testing::internal::linked_ptr_internal::depart(), folly::ssl::detail::dyn_destroy(), testing::internal::UnitTestImpl::GetGlobalTestPartResultReporter(), wangle::ThreadSafeSSLSessionCache::getSSLSession(), testing::internal::GetThreadCount(), folly::ssl::detail::isSSLLockDisabled(), testing::internal::linked_ptr_internal::join(), folly::LockPolicyExclusive::lock(), folly::lock(), testing::internal::NoDefaultContructor::NoDefaultContructor(), folly::SharedPromise< T >::operator=(), testing::UnitTest::PopGTestTrace(), testing::UnitTest::PushGTestTrace(), wangle::LRUPersistentCache< K, V, MutexT >::put(), testing::TestResult::RecordProperty(), wangle::ThreadSafeSSLSessionCache::removeSSLSession(), runContended(), runFairness(), runUncontended(), testing::internal::UnitTestImpl::SetGlobalTestPartResultReporter(), wangle::ThreadSafeSSLSessionCache::setSSLSession(), testing::internal::ShouldRunTestCase(), wangle::ThreadSafeSSLSessionCache::size(), wangle::ThreadSafeSSLSessionCache::supportsPersistence(), TEST(), testing::internal::TEST(), testing::internal::To::To(), wangle::LRUPersistentCache< K, V, MutexT >::~LRUPersistentCache(), and testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile().

                                                         {
  // capture the list of lockers as a tuple
  auto lockers = std::forward_as_tuple(lockersIn...);

  // make a list of null LockedPtr instances that we will return to the caller
  auto lockedPtrs = std::tuple<typename SynchronizedLocker::LockedPtr...>{};

  // start by locking the first thing in the list
  std::get<0>(lockedPtrs) = std::get<0>(lockers).lock();
  auto indexLocked = 0;

  while (true) {
    auto couldLockAll = true;

    for_each(lockers, [&](auto& locker, auto index) {
      // if we should try_lock on the current locker then do so
      if (index != indexLocked) {
        auto lockedPtr = locker.tryLock();

        // if we were unable to lock this mutex,
        //
        // 1. release all the locks,
        // 2. yield control to another thread to be nice
        // 3. block on the mutex we failed to lock, acquire the lock
        // 4. break out and set the index of the current mutex to indicate
        //    which mutex we have locked
        if (!lockedPtr) {
          // writing lockedPtrs = decltype(lockedPtrs){} does not compile on
          // gcc, I believe this is a bug D7676798
          lockedPtrs = std::tuple<typename SynchronizedLocker::LockedPtr...>{};

          std::this_thread::yield();
          fetch(lockedPtrs, index) = locker.lock();
          indexLocked = index;
          couldLockAll = false;

          return loop_break;
        }

        // else store the locked mutex in the list we return
        fetch(lockedPtrs, index) = std::move(lockedPtr);
      }

      return loop_continue;
    });

    if (couldLockAll) {
      return lockedPtrs;
    }
  }
}

template<typename Synchronized , typename... Args>

auto folly::detail::lock	(	Synchronized &	synchronized,
		Args &&...	args
	)

Definition at line 955 of file Synchronized.h.

References a, makeSynchronizedLocker(), and s.

                                                      {
  return detail::makeSynchronizedLocker(
      synchronized,
      [](auto& s, auto&&... a) {
        return s.lock(std::forward<decltype(a)>(a)...);
      },
      [](auto& s) { return s.tryLock(); },
      std::forward<Args>(args)...);
}

template<typename Synchronized , typename LockFunc , typename TryLockFunc , typename... Args>

auto folly::detail::makeSynchronizedLocker	(	Synchronized &	synchronized,
		LockFunc &&	lockFunc,
		TryLockFunc &&	tryLockFunc,
		Args &&...	args
	)

Definition at line 837 of file Synchronized.h.

Referenced by lock(), folly::lock(), rlock(), ulock(), and wlock().

                    {
  using LockFuncType = std::decay_t<LockFunc>;
  using TryLockFuncType = std::decay_t<TryLockFunc>;
  return SynchronizedLocker<
      Synchronized,
      LockFuncType,
      TryLockFuncType,
      std::decay_t<Args>...>{synchronized,
                             std::forward<LockFunc>(lockFunc),
                             std::forward<TryLockFunc>(tryLockFunc),
                             std::forward<Args>(args)...};
}

template<typename T >

void folly::detail::mallctlHelper	(	const char *	cmd,
		T *	out,
		T *	in
	)

Definition at line 33 of file MallctlHelper.h.

References handleMallctlError(), mallctl, folly::T, UNLIKELY, and folly::usingJEMalloc().

Referenced by folly::mallctlRead(), folly::mallctlReadWrite(), and folly::mallctlWrite().

                                                   {
  if (UNLIKELY(!usingJEMalloc())) {
    throw std::logic_error("Calling mallctl when not using jemalloc.");
  }

  size_t outLen = sizeof(T);
  int err = mallctl(cmd, out, out ? &outLen : nullptr, in, in ? sizeof(T) : 0);
  if (UNLIKELY(err != 0)) {
    handleMallctlError(cmd, err);
  }
}

constexpr size_t folly::detail::max_align_

(

std::size_t

a

)

Definition at line 29 of file Align.h.

References a.

Referenced by max_align_().

                                         {
  return a;
}

template<typename... Es>

constexpr std::size_t folly::detail::max_align_	(	std::size_t	a,
		std::size_t	e,
		Es...	es
	)

Definition at line 33 of file Align.h.

References max_align_().

                                                                   {
  return !(a < e) ? a : max_align_(e, es...);
}

template<class T >

std::enable_if< std::is_default_constructible<T>::value && !folly::is_trivially_copyable<T>::value>::type folly::detail::moveObjectsRight	(	T *	first,
		T *	lastConstructed,
		T *	realLast
	)

Definition at line 108 of file small_vector.h.

References folly::test::end(), folly::gen::move, T, type, and value.

                                                            {
  if (lastConstructed == realLast) {
    return;
  }

  T* end = first - 1; // Past the end going backwards.
  T* out = realLast - 1;
  T* in = lastConstructed - 1;
  try {
    for (; in != end && out >= lastConstructed; --in, --out) {
      new (out) T(std::move(*in));
    }
    for (; in != end; --in, --out) {
      *out = std::move(*in);
    }
    for (; out >= lastConstructed; --out) {
      new (out) T();
    }
  } catch (...) {
    // We want to make sure the same stuff is uninitialized memory
    // if we exit via an exception (this is to make sure we provide
    // the basic exception safety guarantee for insert functions).
    if (out < lastConstructed) {
      out = lastConstructed - 1;
    }
    for (auto it = out + 1; it != realLast; ++it) {
      it->~T();
    }
    throw;
  }
}

template<class T >

std::enable_if< !std::is_default_constructible<T>::value || folly::is_trivially_copyable<T>::value>::type folly::detail::moveObjectsRight	(	T *	first,
		T *	lastConstructed,
		T *	realLast
	)

Definition at line 147 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::insert(), and folly::small_vector< Observer< T > *, InlineObservers >::insertImpl().

                                                            {
  std::move_backward(first, lastConstructed, realLast);
}

template<class T , class U >

std::enable_if< (std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) || (std::is_pointer<T>::value && std::is_pointer<U>::value), bool>::type folly::detail::notThereYet	(	T &	iter,
		const U &	end
	)

notThereYet helps the FOR_EACH_RANGE macro by opportunistically using "<" instead of "!=" whenever available when checking for loop termination. This makes e.g. examples such as FOR_EACH_RANGE (i, 10, 5) execute zero iterations instead of looping virtually forever. At the same time, some iterator types define "!=" but not "<". The notThereYet function will dispatch differently for those.

Below is the correct implementation of notThereYet. It is disabled because of a bug in Boost 1.46: The filesystem::path::iterator defines operator< (via boost::iterator_facade), but that in turn uses distance_to which is undefined for that particular iterator. So HasLess (defined above) identifies boost::filesystem::path as properly comparable with <, but in fact attempting to do so will yield a compile-time error.

The else branch (active) contains a conservative implementation.

Definition at line 267 of file Foreach.h.

References folly::test::end(), type, and value.

                                   {
  return iter < end;
}

template<class T , class U >

std::enable_if< !((std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) || (std::is_pointer<T>::value && std::is_pointer<U>::value)), bool>::type folly::detail::notThereYet	(	T &	iter,
		const U &	end
	)

Definition at line 276 of file Foreach.h.

References folly::test::end().

                                   {
  return iter != end;
}

template<template< class > class Op>

dynamic folly::detail::numericOp	(	dynamic const &	a,
		dynamic const &	b
	)

Definition at line 169 of file dynamic-inl.h.

References a, folly::dynamic::asDouble(), folly::dynamic::asInt(), b, folly::dynamic::isDouble(), folly::dynamic::isInt(), folly::dynamic::isNumber(), and folly::dynamic::type().

                                                      {
  if (!a.isNumber() || !b.isNumber()) {
    throw_exception<TypeError>("numeric", a.type(), b.type());
  }
  if (a.type() != b.type()) {
    auto& integ = a.isInt() ? a : b;
    auto& nonint = a.isInt() ? b : a;
    return Op<double>()(to<double>(integ.asInt()), nonint.asDouble());
  }
  if (a.isDouble()) {
    return Op<double>()(a.asDouble(), b.asDouble());
  }
  return Op<int64_t>()(a.asInt(), b.asInt());
}

template<typename FunctionType >

ScopeGuardImpl<typename std::decay<FunctionType>::type, true> folly::detail::operator+	(	detail::ScopeGuardOnExit	,
		FunctionType &&	fn
	)

Definition at line 264 of file ScopeGuard.h.

Referenced by folly::makeGuard().

                       {
  return ScopeGuardImpl<typename std::decay<FunctionType>::type, true>(
      std::forward<FunctionType>(fn));
}

template<class Tgt >

std::enable_if< std::is_void<ParseToResult<Tgt> >::value, Expected<StringPiece, ConversionCode> >::type folly::detail::parseToWrap ( StringPiece  sp, Tgt &  out  )

inline

Definition at line 1447 of file Conv.h.

References folly::Range< Iter >::end(), folly::parseTo(), type, and folly::value().

Referenced by folly::to().

                                      {
  parseTo(sp, out);
  return StringPiece(sp.end(), sp.end());
}

template<class Tgt >

std::enable_if< !std::is_void<ParseToResult<Tgt> >::value, ParseToResult<Tgt> >::type folly::detail::parseToWrap ( StringPiece  sp, Tgt &  out  )

inline

Definition at line 1456 of file Conv.h.

References folly::parseTo().

                                      {
  return parseTo(sp, out);
}

template<class T >

T* folly::detail::pointerFlagClear

(

T *

p

)

Definition at line 387 of file small_vector.h.

References T.

Referenced by folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::Data::freeHeap(), folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::HeapPtr::getCapacity(), folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::Data::heap(), and folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::HeapPtr::setCapacity().

                          {
  return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(p) & ~uintptr_t(1));
}

template<class T >

bool folly::detail::pointerFlagGet

(

T *

p

)

Definition at line 383 of file small_vector.h.

Referenced by folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::HeapPtr::getCapacity(), folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::Data::hasCapacity(), folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::Data::heap(), and folly::small_vector< Observer< T > *, InlineObservers >::makeSizeInternal().

                          {
  return reinterpret_cast<uintptr_t>(p) & 1;
}

template<class T >

T* folly::detail::pointerFlagSet

(

T *

p

)

Definition at line 379 of file small_vector.h.

References T.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::makeSizeInternal().

                        {
  return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(p) | 1);
}

constexpr size_t folly::detail::poly_size

(

size_t

bits

)

Definition at line 55 of file Fingerprint.h.

Referenced by folly::Fingerprint< BITS >::size().

                                        {
  return 1 + (bits - 1) / 64;
}

template<class T , class Function >

void folly::detail::populateMemForward	(	T *	mem,
		std::size_t	n,
		Function const &	op
	)

Definition at line 156 of file small_vector.h.

References i.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::constructImpl(), folly::small_vector< Observer< T > *, InlineObservers >::doConstruct(), and folly::small_vector< Observer< T > *, InlineObservers >::resize().

                                                                 {
  std::size_t idx = 0;
  try {
    for (size_t i = 0; i < n; ++i) {
      op(&mem[idx]);
      ++idx;
    }
  } catch (...) {
    for (std::size_t i = 0; i < idx; ++i) {
      mem[i].~T();
    }
    throw;
  }
}

template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep >

auto folly::detail::posixTimeToDuration	(	Seconds	seconds,
		Subseconds	subseconds,
		std::chrono::duration< Rep, std::ratio< 1, 1 >>	dummy
	)		-> Expected<decltype(dummy), ConversionCode>

Convert a timeval or a timespec to a std::chrono::duration with second granularity.

The SubsecondRatio template parameter specifies what type of subseconds to return. This must have a numerator of 1.

The input must be in normalized form: the subseconds field must be greater than or equal to 0, and less than SubsecondRatio::den (i.e., less than 1 second).

Definition at line 380 of file Conv.h.

References dummy(), folly::makeUnexpected(), folly::NEGATIVE_OVERFLOW, UNLIKELY, and value.

                                                 {
  using Tgt = decltype(dummy);
  static_assert(Tgt::period::num == 1, "special case expecting num==1");
  static_assert(Tgt::period::den == 1, "special case expecting den==1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  auto outputSeconds = tryTo<typename Tgt::rep>(seconds);
  if (outputSeconds.hasError()) {
    return makeUnexpected(outputSeconds.error());
  }

  if (std::is_floating_point<typename Tgt::rep>::value) {
    return Tgt{typename Tgt::rep(seconds) +
               (typename Tgt::rep(subseconds) / SubsecondRatio::den)};
  }

  // If the value is negative, we have to round up a non-zero subseconds value
  if (UNLIKELY(outputSeconds.value() < 0) && subseconds > 0) {
    if (UNLIKELY(
            outputSeconds.value() ==
            std::numeric_limits<typename Tgt::rep>::lowest())) {
      return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
    }
    return Tgt{outputSeconds.value() + 1};
  }

  return Tgt{outputSeconds.value()};
}

template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Denominator>

auto folly::detail::posixTimeToDuration	(	Seconds	seconds,
		Subseconds	subseconds,
		std::chrono::duration< Rep, std::ratio< 1, Denominator >>	dummy
	)		-> Expected<decltype(dummy), ConversionCode>

Convert a timeval or a timespec to a std::chrono::duration with subsecond granularity

Definition at line 424 of file Conv.h.

References dummy(), LIKELY, folly::makeUnexpected(), folly::SUCCESS, and value.

                                                 {
  using Tgt = decltype(dummy);
  static_assert(Tgt::period::num == 1, "special case expecting num==1");
  static_assert(Tgt::period::den != 1, "special case expecting den!=1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  auto errorCode = detail::CheckOverflowToDuration<
      std::is_floating_point<typename Tgt::rep>::value>::
      template check<Tgt, SubsecondRatio>(seconds, subseconds);
  if (errorCode != ConversionCode::SUCCESS) {
    return makeUnexpected(errorCode);
  }

  if (LIKELY(seconds >= 0)) {
    return std::chrono::duration_cast<Tgt>(
               std::chrono::duration<typename Tgt::rep>{seconds}) +
        std::chrono::duration_cast<Tgt>(
               std::chrono::duration<typename Tgt::rep, SubsecondRatio>{
                   subseconds});
  } else {
    // For negative numbers we have to round subseconds up towards zero, even
    // though it is a positive value, since the overall value is negative.
    return std::chrono::duration_cast<Tgt>(
               std::chrono::duration<typename Tgt::rep>{seconds + 1}) -
        std::chrono::duration_cast<Tgt>(
               std::chrono::duration<typename Tgt::rep, SubsecondRatio>{
                   SubsecondRatio::den - subseconds});
  }
}

template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Numerator>

auto folly::detail::posixTimeToDuration	(	Seconds	seconds,
		Subseconds	subseconds,
		std::chrono::duration< Rep, std::ratio< Numerator, 1 >>	dummy
	)		-> Expected<decltype(dummy), ConversionCode>

Convert a timeval or a timespec to a std::chrono::duration with granularity coarser than 1 second.

Definition at line 469 of file Conv.h.

References dummy(), folly::makeUnexpected(), folly::NEGATIVE_OVERFLOW, UNLIKELY, and value.

                                                 {
  using Tgt = decltype(dummy);
  static_assert(Tgt::period::num != 1, "special case expecting num!=1");
  static_assert(Tgt::period::den == 1, "special case expecting den==1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  if (UNLIKELY(seconds < 0) && subseconds > 0) {
    // Increment seconds by one to handle truncation of negative numbers
    // properly.
    if (UNLIKELY(seconds == std::numeric_limits<Seconds>::lowest())) {
      return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
    }
    seconds += 1;
  }

  if (std::is_floating_point<typename Tgt::rep>::value) {
    // Convert to the floating point type before performing the division
    return Tgt{static_cast<typename Tgt::rep>(seconds) / Tgt::period::num};
  } else {
    // Perform the division as an integer, and check that the result fits in
    // the output integer type
    auto outputValue = (seconds / Tgt::period::num);
    auto expectedOuput = tryTo<typename Tgt::rep>(outputValue);
    if (expectedOuput.hasError()) {
      return makeUnexpected(expectedOuput.error());
    }

    return Tgt{expectedOuput.value()};
  }
}

template<typename SubsecondRatio , typename Seconds , typename Subseconds , typename Rep , std::intmax_t Denominator, std::intmax_t Numerator>

auto folly::detail::posixTimeToDuration	(	Seconds	seconds,
		Subseconds	subseconds,
		std::chrono::duration< Rep, std::ratio< Numerator, Denominator >>	dummy
	)		-> Expected<decltype(dummy), ConversionCode>

Convert a timeval or timespec to a std::chrono::duration

This overload is only used for unusual durations where neither the numerator nor denominator are 1.

Definition at line 518 of file Conv.h.

References dummy(), and folly::makeUnexpected().

                                                 {
  using Tgt = decltype(dummy);
  static_assert(
      Tgt::period::num != 1, "should use special-case code when num==1");
  static_assert(
      Tgt::period::den != 1, "should use special-case code when den==1");
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  // Cast through an intermediate type with subsecond granularity.
  // Note that this could fail due to overflow during the initial conversion
  // even if the result is representable in the output POSIX-style types.
  //
  // Note that for integer type conversions going through this intermediate
  // type can result in slight imprecision due to truncating the intermediate
  // calculation to an integer.
  using IntermediateType =
      IntermediateDuration<typename Tgt::rep, typename Tgt::period>;
  auto intermediate = posixTimeToDuration<SubsecondRatio>(
      seconds, subseconds, IntermediateType{});
  if (intermediate.hasError()) {
    return makeUnexpected(intermediate.error());
  }
  // Now convert back to the target duration.  Use tryTo() to confirm that the
  // result fits in the target representation type.
  return tryTo<typename Tgt::rep>(
             intermediate.value().count() / Tgt::period::num)
      .then([](typename Tgt::rep tgt) { return Tgt{tgt}; });
}

template<class String >

StringPiece folly::detail::prepareDelim

(

const String &

s

)

Definition at line 328 of file String-inl.h.

Referenced by folly::join(), folly::split(), and folly::splitTo().

                                          {
  return StringPiece(s);
}

char folly::detail::prepareDelim ( char  c )

inline

Definition at line 331 of file String-inl.h.

References c.

                                 {
  return c;
}

size_t folly::detail::qfind_first_byte_of ( const StringPiece  haystack, const StringPiece  needles  )

inline

Definition at line 1349 of file Range.h.

References qfind_first_byte_of_nosse(), qfind_first_byte_of_sse42(), and folly::CpuId::sse42().

Referenced by BENCHMARK(), SseNeedleFinder::find_first_byte_of(), and folly::qfind_first_of().

                               {
  static auto const qfind_first_byte_of_fn = folly::CpuId().sse42()
      ? qfind_first_byte_of_sse42
      : qfind_first_byte_of_nosse;
  return qfind_first_byte_of_fn(haystack, needles);
}

size_t folly::detail::qfind_first_byte_of_bitset	(	const StringPieceLite	haystack,
		const StringPieceLite	needles
	)

Definition at line 27 of file RangeCommon.cpp.

References needle, s, folly::detail::StringPieceLite::size(), and uint8_t.

Referenced by BENCHMARK_RELATIVE(), and qfind_first_byte_of_std().

                                   {
  std::bitset<256> s;
  for (auto needle : needles) {
    s[(uint8_t)needle] = true;
  }
  for (size_t index = 0; index < haystack.size(); ++index) {
    if (s[(uint8_t)haystack[index]]) {
      return index;
    }
  }
  return std::string::npos;
}

size_t folly::detail::qfind_first_byte_of_byteset	(	const StringPieceLite	haystack,
		const StringPieceLite	needles
	)

Definition at line 42 of file RangeCommon.cpp.

References folly::SparseByteSet::add(), folly::SparseByteSet::contains(), needle, s, folly::detail::StringPieceLite::size(), and uint8_t.

Referenced by BENCHMARK_RELATIVE(), ByteSetNeedleFinder::find_first_byte_of(), qfind_first_byte_of_nosse(), qfind_first_byte_of_sse42(), and qfind_first_byte_of_std().

                                   {
  SparseByteSet s;
  for (auto needle : needles) {
    s.add(uint8_t(needle));
  }
  for (size_t index = 0; index < haystack.size(); ++index) {
    if (s.contains(uint8_t(haystack[index]))) {
      return index;
    }
  }
  return std::string::npos;
}

size_t folly::detail::qfind_first_byte_of_nosse ( const StringPieceLite  haystack, const StringPieceLite  needles  )

inline

Definition at line 92 of file RangeCommon.h.

References folly::detail::StringPieceLite::empty(), qfind_first_byte_of_byteset(), qfind_first_byte_of_std(), folly::detail::StringPieceLite::size(), and UNLIKELY.

Referenced by BENCHMARK_RELATIVE(), NoSseNeedleFinder::find_first_byte_of(), qfind_first_byte_of(), and qfind_first_byte_of_sse42().

                                   {
  if (UNLIKELY(needles.empty() || haystack.empty())) {
    return std::string::npos;
  }
  // The thresholds below were empirically determined by benchmarking.
  // This is not an exact science since it depends on the CPU, the size of
  // needles, and the size of haystack.
  if ((needles.size() >= 4 && haystack.size() <= 10) ||
      (needles.size() >= 16 && haystack.size() <= 64) || needles.size() >= 32) {
    return qfind_first_byte_of_byteset(haystack, needles);
  }
  return qfind_first_byte_of_std(haystack, needles);
}

size_t folly::detail::qfind_first_byte_of_sse42	(	const StringPieceLite	haystack,
		const StringPieceLite	needles
	)

Definition at line 31 of file RangeSse42.cpp.

References addr, b, folly::detail::StringPieceLite::data(), folly::detail::StringPieceLite::empty(), folly::detail::StringPieceLite::end(), i, min, qfind_first_byte_of_byteset(), qfind_first_byte_of_nosse(), qfind_first_byte_of_std(), folly::detail::StringPieceLite::size(), folly::T, uint64_t, and UNLIKELY.

Referenced by qfind_first_byte_of().

                                   {
  return qfind_first_byte_of_nosse(haystack, needles);
}

size_t folly::detail::qfind_first_byte_of_std ( const StringPieceLite  haystack, const StringPieceLite  needles  )

inline

Definition at line 72 of file RangeCommon.h.

References a, b, folly::detail::StringPieceLite::begin(), folly::detail::StringPieceLite::end(), qfind_first_byte_of_bitset(), and qfind_first_byte_of_byteset().

Referenced by BENCHMARK_RELATIVE(), qfind_first_byte_of_nosse(), and qfind_first_byte_of_sse42().

                                   {
  auto ret = std::find_first_of(
      haystack.begin(),
      haystack.end(),
      needles.begin(),
      needles.end(),
      [](char a, char b) { return a == b; });
  return ret == haystack.end() ? std::string::npos : ret - haystack.begin();
}

template<typename ReturnType = double, typename Duration = std::chrono::seconds, typename Interval = Duration>

ReturnType folly::detail::rateHelper	(	ReturnType	count,
		Duration	elapsed
	)

Definition at line 65 of file Bucket.h.

                                                          {
  if (elapsed == Duration(0)) {
    return 0;
  }

  // Use std::chrono::duration_cast to convert between the native
  // duration and the desired interval.  However, convert the rates,
  // rather than just converting the elapsed duration.  Converting the
  // elapsed time first may collapse it down to 0 if the elapsed interval
  // is less than the desired interval, which will incorrectly result in
  // an infinite rate.
  typedef std::chrono::duration<
      ReturnType,
      std::ratio<Duration::period::den, Duration::period::num>>
      NativeRate;
  typedef std::chrono::duration<
      ReturnType,
      std::ratio<Interval::period::den, Interval::period::num>>
      DesiredRate;

  NativeRate native(count / elapsed.count());
  DesiredRate desired = std::chrono::duration_cast<DesiredRate>(native);
  return desired.count();
}

template<typename Alloc , size_t kAlign, bool kAllocate>

void folly::detail::rawOverAlignedImpl	(	Alloc const &	alloc,
		size_t	n,
		void *&	raw
	)

Definition at line 97 of file Memory.h.

References a, folly::aligned_free(), folly::aligned_malloc(), folly::constexpr_min(), folly::T, and folly::value().

                                                                  {
  static_assert((kAlign & (kAlign - 1)) == 0, "Align must be a power of 2");

  using AllocTraits = std::allocator_traits<Alloc>;
  using T = typename AllocTraits::value_type;

  constexpr bool kCanBypass = std::is_same<Alloc, std::allocator<T>>::value;

  // BaseType is a type that gives us as much alignment as we need if
  // we can get it naturally, otherwise it is aligned as max_align_t.
  // kBaseAlign is both the alignment and size of this type.
  constexpr size_t kBaseAlign = constexpr_min(kAlign, alignof(max_align_t));
  using BaseType = std::aligned_storage_t<kBaseAlign, kBaseAlign>;
  using BaseAllocTraits =
      typename AllocTraits::template rebind_traits<BaseType>;
  using BaseAlloc = typename BaseAllocTraits::allocator_type;
  static_assert(
      sizeof(BaseType) == kBaseAlign && alignof(BaseType) == kBaseAlign, "");

#if __cpp_sized_deallocation
  if (kCanBypass && kAlign == kBaseAlign) {
    // until std::allocator uses sized deallocation, it is worth the
    // effort to bypass it when we are able
    if (kAllocate) {
      raw = ::operator new(n * sizeof(T));
    } else {
      ::operator delete(raw, n * sizeof(T));
    }
    return;
  }
#endif

  if (kCanBypass && kAlign > kBaseAlign) {
    // allocating as BaseType isn't sufficient to get alignment, but
    // since we can bypass Alloc we can use something like posix_memalign
    if (kAllocate) {
      raw = aligned_malloc(n * sizeof(T), kAlign);
    } else {
      aligned_free(raw);
    }
    return;
  }

  // we're not allowed to bypass Alloc, or we don't want to
  BaseAlloc a(alloc);

  // allocation size is counted in sizeof(BaseType)
  size_t quanta = (n * sizeof(T) + kBaseAlign - 1) / sizeof(BaseType);
  if (kAlign <= kBaseAlign) {
    // rebinding Alloc to BaseType is sufficient to get us the alignment
    // we want, happy path
    if (kAllocate) {
      raw = static_cast<void*>(
          std::addressof(*BaseAllocTraits::allocate(a, quanta)));
    } else {
      BaseAllocTraits::deallocate(
          a,
          std::pointer_traits<typename BaseAllocTraits::pointer>::pointer_to(
              *static_cast<BaseType*>(raw)),
          quanta);
    }
    return;
  }

  // Overaligned and custom allocator, our only option is to
  // overallocate and store a delta to the actual allocation just
  // before the returned ptr.
  //
  // If we give ourselves kAlign extra bytes, then since
  // sizeof(BaseType) divides kAlign we can meet alignment while
  // getting a prefix of one BaseType.  If we happen to get a
  // kAlign-aligned block, then we can return a pointer to underlying
  // + kAlign, otherwise there will be at least kBaseAlign bytes in
  // the unused prefix of the first kAlign-aligned block.
  if (kAllocate) {
    char* base = reinterpret_cast<char*>(std::addressof(
        *BaseAllocTraits::allocate(a, quanta + kAlign / sizeof(BaseType))));
    size_t byteDelta =
        kAlign - (reinterpret_cast<uintptr_t>(base) & (kAlign - 1));
    raw = static_cast<void*>(base + byteDelta);
    static_cast<size_t*>(raw)[-1] = byteDelta;
  } else {
    size_t byteDelta = static_cast<size_t*>(raw)[-1];
    char* base = static_cast<char*>(raw) - byteDelta;
    BaseAllocTraits::deallocate(
        a,
        std::pointer_traits<typename BaseAllocTraits::pointer>::pointer_to(
            *reinterpret_cast<BaseType*>(base)),
        quanta + kAlign / sizeof(BaseType));
  }
}

template<typename Synchronized , typename... Args>

auto folly::detail::rlock	(	Synchronized &	synchronized,
		Args &&...	args
	)

Definition at line 935 of file Synchronized.h.

References a, testing::Args(), makeSynchronizedLocker(), and s.

Referenced by folly::rlock(), and runFairness().

                                                       {
  return detail::makeSynchronizedLocker(
      synchronized,
      [](auto& s, auto&&... a) {
        return s.rlock(std::forward<decltype(a)>(a)...);
      },
      [](auto& s) { return s.tryRLock(); },
      std::forward<Args>(args)...);
}

std::unique_lock< std::mutex > folly::detail::sharedMutexAnnotationGuard

(

void *

ptr

)

Definition at line 25 of file SharedMutex.cpp.

References folly::kIsSanitizeThread, and ptr.

Referenced by folly::SharedMutexImpl< true >::annotateLazyCreate().

                                                               {
  if (folly::kIsSanitizeThread) {
    // On TSAN builds, we have an array of mutexes and index into them based on
    // the address. If the array is of prime size things will work out okay
    // without a complicated hash function.
    static constexpr std::size_t kNumAnnotationMutexes = 251;
    static std::array<std::mutex, kNumAnnotationMutexes> kAnnotationMutexes{};
    auto index = reinterpret_cast<uintptr_t>(ptr) % kNumAnnotationMutexes;
    return std::unique_lock<std::mutex>(kAnnotationMutexes[index]);
  } else {
    return std::unique_lock<std::mutex>();
  }
}

template<typename... Arguments>

std::vector<std::string> folly::detail::shellify	(	StringPiece	format,
		Arguments &&...	arguments
	)

Definition at line 43 of file Shell.h.

References folly::sformat(), and folly::shellQuote().

Referenced by folly::shellify().

                              {
  auto command = sformat(
      format,
      shellQuote(to<std::string>(std::forward<Arguments>(arguments)))...);
  return {"/bin/sh", "-c", command};
}

void* folly::detail::shiftPointer ( void *  p, size_t  sizeBytes  )

inline

Definition at line 390 of file small_vector.h.

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

Referenced by folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::Data::heap(), and folly::small_vector< Observer< T > *, InlineObservers >::makeSizeInternal().

                                                     {
  return static_cast<char*>(p) + sizeBytes;
}

static void folly::detail::singleton_hs_init_weak ( int *  argc, char **  argv[]  )

static

Referenced by folly::SingletonVault::defaultVaultType().

void folly::detail::singletonPrintDestructionStackTrace

(

const TypeDescriptor &

type

)

Definition at line 159 of file Singleton.cpp.

References folly::detail::TypeDescriptor::name(), gmock_output_test::output, folly::SingletonVault::stackTraceGetter(), and string.

Referenced by folly::detail::SingletonHolder< T >::createInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                                                                     {
  std::string output = "Singleton " + type.name() + " was released.\n";

  auto stack_trace_getter = SingletonVault::stackTraceGetter().load();
  auto stack_trace = stack_trace_getter ? stack_trace_getter() : "";
  if (stack_trace.empty()) {
    output += "Failed to get release stack trace.";
  } else {
    output += "Release stack trace:\n";
    output += stack_trace;
  }

  LOG(ERROR) << output;
}

void folly::detail::singletonThrowGetInvokedAfterDestruction

(

const TypeDescriptor &

type

)

Definition at line 181 of file Singleton.cpp.

References folly::DFATAL, leakedSingletons_, folly::detail::TypeDescriptor::name(), folly::singleton, and string.

Referenced by folly::detail::SingletonHolder< T >::get(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  throw std::runtime_error(
      "Raw pointer to a singleton requested after its destruction."
      " Singleton type is: " +
      type.name());
}

void folly::detail::singletonThrowNullCreator

(

const std::type_info &

type

)

Definition at line 174 of file Singleton.cpp.

References folly::demangle(), and folly::sformat().

Referenced by folly::Singleton< folly::observer_detail::ObserverManager >::make_mock(), folly::LeakySingleton< T, Tag >::make_mock(), folly::detail::TypeDescriptorHasher::operator()(), and folly::Singleton< folly::observer_detail::ObserverManager >::Singleton().

                                                                      {
  auto const msg = sformat(
      "nullptr_t should be passed if you want {} to be default constructed",
      demangle(type));
  throw std::logic_error(msg);
}

void folly::detail::singletonWarnCreateBeforeRegistrationCompleteAndAbort

(

const TypeDescriptor &

type

)

Definition at line 143 of file Singleton.cpp.

References folly::FATAL, folly::detail::TypeDescriptor::name(), and folly::SingletonVault::stackTraceGetter().

Referenced by folly::detail::SingletonHolder< T >::createInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  auto stack_trace_getter = SingletonVault::stackTraceGetter().load();
  auto stack_trace = stack_trace_getter ? stack_trace_getter() : "";
  if (!stack_trace.empty()) {
    stack_trace = "Stack trace:\n" + stack_trace;
  }

  LOG(FATAL) << "Singleton " << type.name() << " requested before "
             << "registrationComplete() call.\n"
             << "This usually means that either main() never called "
             << "folly::init, or singleton was requested before main() "
             << "(which is not allowed).\n"
             << stack_trace;
}

void folly::detail::singletonWarnCreateCircularDependencyAndAbort

(

const TypeDescriptor &

type

)

Definition at line 128 of file Singleton.cpp.

References folly::FATAL, and folly::detail::TypeDescriptor::name().

Referenced by folly::detail::SingletonHolder< T >::createInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  LOG(FATAL) << "circular singleton dependency: " << type.name();
}

void folly::detail::singletonWarnCreateUnregisteredAndAbort

(

const TypeDescriptor &

type

)

Definition at line 133 of file Singleton.cpp.

References folly::FATAL, folly::detail::TypeDescriptor::name(), ptr, and folly::SingletonVault::stackTraceGetter().

Referenced by folly::detail::SingletonHolder< T >::createInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  auto ptr = SingletonVault::stackTraceGetter().load();
  LOG(FATAL) << "Creating instance for unregistered singleton: " << type.name()
             << "\n"
             << "Stacktrace:"
             << "\n"
             << (ptr ? (*ptr)() : "(not available)");
}

void folly::detail::singletonWarnDestroyInstanceLeak	(	const TypeDescriptor &	type,
		const void *	ptr
	)

Definition at line 115 of file Singleton.cpp.

References folly::detail::TypeDescriptor::name().

Referenced by folly::detail::SingletonHolder< T >::destroyInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                     {
  LOG(ERROR) << "Singleton of type " << type.name() << " has a "
             << "living reference at destroyInstances time; beware! Raw "
             << "pointer is " << ptr << ". It is very likely "
             << "that some other singleton is holding a shared_ptr to it. "
             << "This singleton will be leaked (even if a shared_ptr to it "
             << "is eventually released)."
             << "Make sure dependencies between these singletons are "
             << "properly defined.";
}

void folly::detail::singletonWarnDoubleRegistrationAndAbort

(

const TypeDescriptor &

type

)

Definition at line 77 of file Singleton.cpp.

References folly::detail::TypeDescriptor::name().

Referenced by folly::detail::SingletonHolder< T >::registerSingleton(), and folly::detail::SingletonHolder< T >::singleton().

                                {
  // Ensure the availability of std::cerr
  std::ios_base::Init ioInit;
  std::cerr << "Double registration of singletons of the same "
               "underlying type; check for multiple definitions "
               "of type folly::Singleton<"
            << type.name() << ">\n";
  std::abort();
}

void folly::detail::singletonWarnLeakyDoubleRegistrationAndAbort

(

const TypeDescriptor &

type

)

Definition at line 88 of file Singleton.cpp.

References folly::detail::TypeDescriptor::name().

Referenced by folly::LeakySingleton< T, Tag >::LeakySingleton(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  // Ensure the availability of std::cerr
  std::ios_base::Init ioInit;
  std::cerr << "Double registration of singletons of the same "
               "underlying type; check for multiple definitions "
               "of type folly::LeakySingleton<"
            << type.name() << ">\n";
  std::abort();
}

void folly::detail::singletonWarnLeakyInstantiatingNotRegisteredAndAbort

(

const TypeDescriptor &

type

)

Definition at line 99 of file Singleton.cpp.

References folly::FATAL, folly::detail::TypeDescriptor::name(), ptr, and folly::SingletonVault::stackTraceGetter().

Referenced by folly::LeakySingleton< T, Tag >::createInstance(), and folly::detail::TypeDescriptorHasher::operator()().

                                {
  auto ptr = SingletonVault::stackTraceGetter().load();
  LOG(FATAL) << "Creating instance for unregistered singleton: " << type.name()
             << "\n"
             << "Stacktrace:"
             << "\n"
             << (ptr ? (*ptr)() : "(not available)");
}

void folly::detail::singletonWarnRegisterMockEarlyAndAbort

(

const TypeDescriptor &

type

)

Definition at line 109 of file Singleton.cpp.

References folly::FATAL, and folly::detail::TypeDescriptor::name().

Referenced by folly::detail::TypeDescriptorHasher::operator()(), and folly::detail::SingletonHolder< T >::registerSingletonMock().

                                {
  LOG(FATAL) << "Registering mock before singleton was registered: "
             << type.name();
}

template<typename Clock , typename Duration , typename F >

spin_result folly::detail::spin_pause_until	(	std::chrono::time_point< Clock, Duration > const &	deadline,
		WaitOptions const &	opt,
		F	f
	)

Definition at line 36 of file Spin.h.

References advance, folly::asm_volatile_pause(), f, min, now(), folly::WaitOptions::spin_max(), success, and timeout.

Referenced by folly::UnboundedQueue< T, false, 6 >::getAllocNextSegment(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::trySpinBeforeBlock(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::tryWait(), folly::Baton< MayBlock, Atom >::tryWaitSlow(), and folly::SaturatingSemaphore< MayBlock, Atom >::tryWaitSlow().

         {
  if (opt.spin_max() <= opt.spin_max().zero()) {
    return spin_result::advance;
  }

  auto tbegin = Clock::now();
  while (true) {
    if (f()) {
      return spin_result::success;
    }

    auto const tnow = Clock::now();
    if (tnow >= deadline) {
      return spin_result::timeout;
    }

    //  Backward time discontinuity in Clock? revise pre_block starting point
    tbegin = std::min(tbegin, tnow);
    if (tnow >= tbegin + opt.spin_max()) {
      return spin_result::advance;
    }

    //  The pause instruction is the polite way to spin, but it doesn't
    //  actually affect correctness to omit it if we don't have it. Pausing
    //  donates the full capabilities of the current core to its other
    //  hyperthreads for a dozen cycles or so.
    asm_volatile_pause();
  }
}

template<typename Clock , typename Duration , typename F >

spin_result folly::detail::spin_yield_until	(	std::chrono::time_point< Clock, Duration > const &	deadline,
		F	f
	)

Definition at line 70 of file Spin.h.

References f, max, now(), success, timeout, and folly::fibers::yield().

Referenced by TEST(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::tryWait(), folly::Baton< MayBlock, Atom >::tryWaitSlow(), and folly::SaturatingSemaphore< MayBlock, Atom >::tryWaitSlow().

         {
  while (true) {
    if (f()) {
      return spin_result::success;
    }

    auto const max = std::chrono::time_point<Clock, Duration>::max();
    if (deadline != max && Clock::now() >= deadline) {
      return spin_result::timeout;
    }

    std::this_thread::yield();
  }
}

template<bool exact, class Delim , class OutputType >

bool folly::detail::splitFixed	(	const Delim &	delimiter,
		StringPiece	input,
		OutputType &	output
	)

Definition at line 343 of file String-inl.h.

References folly::Range< Iter >::find(), toOrIgnore(), UNLIKELY, value, and folly::value().

                                                                               {
  static_assert(
      exact || std::is_same<OutputType, StringPiece>::value ||
          IsSomeString<OutputType>::value ||
          std::is_same<OutputType, decltype(std::ignore)>::value,
      "split<false>() requires that the last argument be a string type "
      "or std::ignore");
  if (exact && UNLIKELY(std::string::npos != input.find(delimiter))) {
    return false;
  }
  toOrIgnore(input, output);
  return true;
}

template<bool exact, class Delim , class OutputType , class... OutputTypes>

bool folly::detail::splitFixed	(	const Delim &	delimiter,
		StringPiece	input,
		OutputType &	outHead,
		OutputTypes &...	outTail
	)

Definition at line 358 of file String-inl.h.

References folly::Range< Iter >::begin(), delimSize(), folly::Range< Iter >::end(), folly::Range< Iter >::find(), LIKELY, toOrIgnore(), and UNLIKELY.

                             {
  size_t cut = input.find(delimiter);
  if (UNLIKELY(cut == std::string::npos)) {
    return false;
  }
  StringPiece head(input.begin(), input.begin() + cut);
  StringPiece tail(
      input.begin() + cut + detail::delimSize(delimiter), input.end());
  if (LIKELY(splitFixed<exact>(delimiter, tail, outTail...))) {
    toOrIgnore(head, outHead);
    return true;
  }
  return false;
}

Expected<bool, ConversionCode> folly::detail::str_to_bool ( StringPiece *  src )

noexcept

Definition at line 266 of file Conv.cpp.

References b, folly::BOOL_INVALID_VALUE, folly::BOOL_OVERFLOW, folly::EMPTY_INPUT_STRING, and folly::makeUnexpected().

Referenced by folly::toAppendStrImpl().

                                                                      {
  auto b = src->begin(), e = src->end();
  for (;; ++b) {
    if (b >= e) {
      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
    }
    if (!std::isspace(*b)) {
      break;
    }
  }

  bool result;
  size_t len = size_t(e - b);
  switch (*b) {
    case '0':
    case '1': {
      result = false;
      for (; b < e && isdigit(*b); ++b) {
        if (result || (*b != '0' && *b != '1')) {
          return makeUnexpected(ConversionCode::BOOL_OVERFLOW);
        }
        result = (*b == '1');
      }
      break;
    }
    case 'y':
    case 'Y':
      result = true;
      if (!bool_str_cmp(&b, len, "yes")) {
        ++b; // accept the single 'y' character
      }
      break;
    case 'n':
    case 'N':
      result = false;
      if (!bool_str_cmp(&b, len, "no")) {
        ++b;
      }
      break;
    case 't':
    case 'T':
      result = true;
      if (!bool_str_cmp(&b, len, "true")) {
        ++b;
      }
      break;
    case 'f':
    case 'F':
      result = false;
      if (!bool_str_cmp(&b, len, "false")) {
        ++b;
      }
      break;
    case 'o':
    case 'O':
      if (bool_str_cmp(&b, len, "on")) {
        result = true;
      } else if (bool_str_cmp(&b, len, "off")) {
        result = false;
      } else {
        return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
      }
      break;
    default:
      return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
  }

  src->assign(b, e);

  return result;
}

template<class Tgt >

Expected<Tgt, ConversionCode> folly::detail::str_to_floating ( StringPiece *  src )

noexcept

StringPiece to double, with progress information. Alters the StringPiece parameter to munch the already-parsed characters.

Definition at line 343 of file Conv.cpp.

References b, c, folly::EMPTY_INPUT_STRING, folly::makeUnexpected(), folly::pushmi::__adl::noexcept(), folly::size(), str_to_floating< double >(), str_to_floating< float >(), folly::STRING_TO_FLOAT_ERROR, suffix, and value.

Referenced by folly::toAppendStrImpl().

                                                                         {
  using namespace double_conversion;
  static StringToDoubleConverter conv(
      StringToDoubleConverter::ALLOW_TRAILING_JUNK |
          StringToDoubleConverter::ALLOW_LEADING_SPACES,
      0.0,
      // return this for junk input string
      std::numeric_limits<double>::quiet_NaN(),
      nullptr,
      nullptr);

  if (src->empty()) {
    return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
  }

  int length;
  auto result = conv.StringToDouble(
      src->data(),
      static_cast<int>(src->size()),
      &length); // processed char count

  if (!std::isnan(result)) {
    // If we get here with length = 0, the input string is empty.
    // If we get here with result = 0.0, it's either because the string
    // contained only whitespace, or because we had an actual zero value
    // (with potential trailing junk). If it was only whitespace, we
    // want to raise an error; length will point past the last character
    // that was processed, so we need to check if that character was
    // whitespace or not.
    if (length == 0 ||
        (result == 0.0 && std::isspace((*src)[size_t(length) - 1]))) {
      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
    }
    if (length >= 2) {
      const char* suffix = src->data() + length - 1;
      // double_conversion doesn't update length correctly when there is an
      // incomplete exponent specifier. Converting "12e-f-g" shouldn't consume
      // any more than "12", but it will consume "12e-".

      // "123-" should only parse "123"
      if (*suffix == '-' || *suffix == '+') {
        --suffix;
        --length;
      }
      // "12e-f-g" or "12euro" should only parse "12"
      if (*suffix == 'e' || *suffix == 'E') {
        --length;
      }
    }
    src->advance(size_t(length));
    return Tgt(result);
  }

  auto* e = src->end();
  auto* b =
      std::find_if_not(src->begin(), e, [](char c) { return std::isspace(c); });

  // There must be non-whitespace, otherwise we would have caught this above
  assert(b < e);
  size_t size = size_t(e - b);

  bool negative = false;
  if (*b == '-') {
    negative = true;
    ++b;
    --size;
  }

  result = 0.0;

  switch (tolower_ascii(*b)) {
    case 'i':
      if (size >= 3 && tolower_ascii(b[1]) == 'n' &&
          tolower_ascii(b[2]) == 'f') {
        if (size >= 8 && tolower_ascii(b[3]) == 'i' &&
            tolower_ascii(b[4]) == 'n' && tolower_ascii(b[5]) == 'i' &&
            tolower_ascii(b[6]) == 't' && tolower_ascii(b[7]) == 'y') {
          b += 8;
        } else {
          b += 3;
        }
        result = std::numeric_limits<Tgt>::infinity();
      }
      break;

    case 'n':
      if (size >= 3 && tolower_ascii(b[1]) == 'a' &&
          tolower_ascii(b[2]) == 'n') {
        b += 3;
        result = std::numeric_limits<Tgt>::quiet_NaN();
      }
      break;

    default:
      break;
  }

  if (result == 0.0) {
    // All bets are off
    return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
  }

  if (negative) {
    result = -result;
  }

  src->assign(b, e);

  return Tgt(result);
}

template Expected<double, ConversionCode> folly::detail::str_to_floating< double > ( StringPiece *  src )

noexcept

Referenced by str_to_floating(), and folly::toAppendStrImpl().

template Expected<float, ConversionCode> folly::detail::str_to_floating< float > ( StringPiece *  src )

noexcept

Referenced by str_to_floating(), and folly::toAppendStrImpl().

template<class Tgt >

Expected<Tgt, ConversionCode> folly::detail::str_to_integral ( StringPiece *  src )

noexcept

StringPiece to integrals, with progress information. Alters the StringPiece parameter to munch the already-parsed characters.

Definition at line 683 of file Conv.cpp.

References b, folly::EMPTY_INPUT_STRING, m, folly::makeUnexpected(), folly::NO_DIGITS, folly::pushmi::__adl::noexcept(), folly::NON_DIGIT_CHAR, folly::POSITIVE_OVERFLOW, str_to_integral< char >(), str_to_integral< int >(), str_to_integral< long >(), str_to_integral< long long >(), str_to_integral< short >(), str_to_integral< signed char >(), str_to_integral< unsigned char >(), str_to_integral< unsigned int >(), str_to_integral< unsigned long >(), str_to_integral< unsigned long long >(), str_to_integral< unsigned short >(), folly::SUCCESS, type, UNLIKELY, and value.

Referenced by folly::toAppendStrImpl().

                                                                         {
  using UT = typename std::make_unsigned<Tgt>::type;

  auto b = src->data(), past = src->data() + src->size();

  for (;; ++b) {
    if (UNLIKELY(b >= past)) {
      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
    }
    if (!std::isspace(*b)) {
      break;
    }
  }

  SignedValueHandler<Tgt> sgn;
  auto err = sgn.init(b);

  if (UNLIKELY(err != ConversionCode::SUCCESS)) {
    return makeUnexpected(err);
  }
  if (std::is_signed<Tgt>::value && UNLIKELY(b >= past)) {
    return makeUnexpected(ConversionCode::NO_DIGITS);
  }
  if (UNLIKELY(!isdigit(*b))) {
    return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
  }

  auto m = findFirstNonDigit(b + 1, past);

  auto tmp = digits_to<UT>(b, m);

  if (UNLIKELY(!tmp.hasValue())) {
    return makeUnexpected(
        tmp.error() == ConversionCode::POSITIVE_OVERFLOW ? sgn.overflow()
                                                         : tmp.error());
  }

  auto res = sgn.finalize(tmp.value());

  if (res.hasValue()) {
    src->advance(size_t(m - src->data()));
  }

  return res;
}

template Expected<char, ConversionCode> folly::detail::str_to_integral< char > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<int, ConversionCode> folly::detail::str_to_integral< int > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<long, ConversionCode> folly::detail::str_to_integral< long > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<long long, ConversionCode> folly::detail::str_to_integral< long long > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<short, ConversionCode> folly::detail::str_to_integral< short > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<signed char, ConversionCode> folly::detail::str_to_integral< signed char > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<unsigned char, ConversionCode> folly::detail::str_to_integral< unsigned char > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<unsigned int, ConversionCode> folly::detail::str_to_integral< unsigned int > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<unsigned long, ConversionCode> folly::detail::str_to_integral< unsigned long > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<unsigned long long, ConversionCode> folly::detail::str_to_integral< unsigned long long > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

template Expected<unsigned short, ConversionCode> folly::detail::str_to_integral< unsigned short > ( StringPiece *  src )

noexcept

Referenced by str_to_integral(), and folly::toAppendStrImpl().

int folly::detail::sysMembarrier

(

)

Definition at line 58 of file SysMembarrier.cpp.

Referenced by folly::asymmetricHeavyBarrier().

                    {
#if FOLLY_USE_SYS_MEMBARRIER
  return syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, /* flags = */ 0);
#else
  return -1;
#endif
}

bool folly::detail::sysMembarrierAvailable

(

)

Definition at line 41 of file SysMembarrier.cpp.

References folly::kIsLinux.

Referenced by folly::asymmetricHeavyBarrier().

                              {
  if (!kIsLinux) {
    return false;
  }

#if FOLLY_USE_SYS_MEMBARRIER
  auto r = syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, /* flags = */ 0);
  if (r == -1) {
    return false;
  }

  return r & MEMBARRIER_CMD_SHARED;
#else
  return false;
#endif
}

template<typename Ex , typename... Args>

FOLLY_NOINLINE FOLLY_COLD void folly::detail::terminate_with_ ( Args &&...  args )

noexcept

Definition at line 65 of file Exception.h.

References testing::Args(), FOLLY_ALWAYS_INLINE, FOLLY_ATTR_VISIBILITY_HIDDEN, and folly::throw_exception().

                             {
  throw_exception(Ex(static_cast<Args&&>(args)...));
}

folly::detail::TEST_F	(	StaticSingletonManagerTest	,
		example
	)

Definition at line 29 of file StaticSingletonManagerTest.cpp.

References ASSERT_NE, EXPECT_EQ, EXPECT_NE, i, k, and folly::gen::move.

                                            {
  auto make3 = [n = 3] { return new int(n); };
  auto i = createGlobal<int, Tag<char>>(make3);
  ASSERT_NE(nullptr, i);
  EXPECT_EQ(3, *i);

  auto const make4 = [n = 4] { return new int(n); };
  auto j = createGlobal<int, Tag<char>>(make4);
  ASSERT_NE(nullptr, j);
  EXPECT_EQ(i, j);
  EXPECT_EQ(3, *j);

  auto make5 = [n = 5] { return new int(n); };
  auto k = createGlobal<int, Tag<char*>>(std::move(make5));
  ASSERT_NE(nullptr, k);
  EXPECT_NE(i, k);
  EXPECT_EQ(5, *k);
}

int folly::detail::tfo_enable	(	int	sockfd,
		size_t	max_queue_size
	)

Enable TFO on a listening socket.

Definition at line 113 of file SocketFastOpen.cpp.

Referenced by folly::AsyncServerSocket::setupSocket(), and TestServer::TestServer().

                                {
  errno = ENOPROTOOPT;
  return -1;
}

ssize_t folly::detail::tfo_sendmsg	(	int	sockfd,
		const struct msghdr *	msg,
		int	flags
	)

tfo_sendto has the same semantics as sendmsg, but is used to send with TFO data.

Definition at line 108 of file SocketFastOpen.cpp.

Referenced by folly::AsyncSocket::tfoSendMsg().

                                                  {
  errno = EOPNOTSUPP;
  return -1;
}

bool folly::detail::tfo_succeeded

(

int

sockfd

)

Check if TFO succeeded in being used.

Definition at line 118 of file SocketFastOpen.cpp.

Referenced by folly::AsyncSocket::getTFOSucceded().

                          {
  errno = EOPNOTSUPP;
  return false;
}

template<typename Ex , typename... Args>

FOLLY_NOINLINE FOLLY_COLD void folly::detail::throw_exception_

(

Args &&...

args

)

Definition at line 61 of file Exception.h.

References testing::Args(), and folly::throw_exception().

                                                                             {
  throw_exception(Ex(static_cast<Args&&>(args)...));
}

template<typename TargetClock , typename Clock , typename Duration >

TargetClock::time_point folly::detail::time_point_conv

(

std::chrono::time_point< Clock, Duration > const &

time

)

Optimal when TargetClock is the same type as Clock.

Otherwise, both Clock::now() and TargetClock::now() must be invoked.

Definition at line 29 of file Futex-inl.h.

References count, futexWaitImpl(), futexWakeImpl(), max, now(), type, uint32_t, and value.

                                                      {
  using std::chrono::duration_cast;
  using TimePoint = std::chrono::time_point<Clock, Duration>;
  using TargetDuration = typename TargetClock::duration;
  using TargetTimePoint = typename TargetClock::time_point;
  if (time == TimePoint::max()) {
    return TargetTimePoint::max();
  } else if (std::is_same<Clock, TargetClock>::value) {
    // in place of time_point_cast, which cannot compile without if-constexpr
    auto const delta = time.time_since_epoch();
    return TargetTimePoint(duration_cast<TargetDuration>(delta));
  } else {
    // different clocks with different epochs, so non-optimal case
    auto const delta = time - Clock::now();
    return TargetClock::now() + duration_cast<TargetDuration>(delta);
  }
}

template<typename T >

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN T&& folly::detail::to_exception_arg_

(

T &&

t

)

Definition at line 52 of file Exception.h.

References folly::pushmi::detail::t, and folly::T.

Referenced by folly::terminate_with(), and folly::throw_exception().

                                                                              {
  return static_cast<T&&>(t);
}

template<std::size_t N>

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN char const* folly::detail::to_exception_arg_

(

char const (&)

array[N]

)

Definition at line 56 of file Exception.h.

References testing::Args(), and upload::const.

                            {
  return static_cast<char const*>(array);
}

template<class OutputType >

void folly::detail::toOrIgnore	(	StringPiece	input,
		OutputType &	output
	)

Definition at line 336 of file String-inl.h.

Referenced by splitFixed().

                                                       {
  output = folly::to<OutputType>(input);
}

void folly::detail::toOrIgnore ( StringPiece  , decltype(std::ignore)&    )

inline

Definition at line 340 of file String-inl.h.

{}

std::string folly::detail::toPseudoJson

(

const folly::dynamic &

d

)

Definition at line 194 of file DynamicParser.cpp.

Referenced by folly::DynamicParser::reportError(), and folly::DynamicParser::required().

                                              {
  std::stringstream ss;
  ss << d;
  return ss.str();
}

template<typename F >

exception_wrapper folly::detail::try_and_catch_ ( F &&  f )

inline

Definition at line 653 of file ExceptionWrapper.h.

References f.

Referenced by folly::try_and_catch().

                                               {
  return (f(), exception_wrapper());
}

template<typename F , typename Ex , typename... Exs>

exception_wrapper folly::detail::try_and_catch_ ( F &&  f )

inline

Definition at line 658 of file ExceptionWrapper.h.

References f.

                                               {
  try {
    return try_and_catch_<F, Exs...>(std::forward<F>(f));
  } catch (Ex& ex) {
    return exception_wrapper(std::current_exception(), ex);
  }
}

template<typename Tgt , typename SubsecondRatio , typename Seconds , typename Subseconds >

Expected<Tgt, ConversionCode> folly::detail::tryPosixTimeToDuration	(	Seconds	seconds,
		Subseconds	subseconds
	)

Definition at line 557 of file Conv.h.

References folly::makeUnexpected(), max, folly::NEGATIVE_OVERFLOW, folly::POSITIVE_OVERFLOW, type, and UNLIKELY.

                           {
  static_assert(
      SubsecondRatio::num == 1, "subsecond numerator should always be 1");

  // Normalize the input if required
  if (UNLIKELY(subseconds < 0)) {
    const auto overflowSeconds = (subseconds / SubsecondRatio::den);
    const auto remainder = (subseconds % SubsecondRatio::den);
    if (std::numeric_limits<Seconds>::lowest() + 1 - overflowSeconds >
        seconds) {
      return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
    }
    seconds = seconds - 1 + overflowSeconds;
    subseconds = remainder + SubsecondRatio::den;
  } else if (UNLIKELY(subseconds >= SubsecondRatio::den)) {
    const auto overflowSeconds = (subseconds / SubsecondRatio::den);
    const auto remainder = (subseconds % SubsecondRatio::den);
    if (std::numeric_limits<Seconds>::max() - overflowSeconds < seconds) {
      return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
    }
    seconds += overflowSeconds;
    subseconds = remainder;
  }

  return posixTimeToDuration<SubsecondRatio>(seconds, subseconds, Tgt{});
}

template<class Uint >

size_t folly::detail::uintToBinary	(	char *	buffer,
		size_t	bufLen,
		Uint	v
	)

Convert an unsigned to binary.

Just like folly::detail::uintToBuffer in Conv.h, writes at the end of the supplied buffer and returns the offset of the beginning of the string from the start of the buffer. The formatted string will be in range [buf+begin, buf+bufLen).

Definition at line 142 of file Format-inl.h.

References testing::Args(), b, formatBinary, and v.

Referenced by compareBinary(), and folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat().

                                                         {
  auto& repr = formatBinary;
  if (v == 0) {
    buffer[--bufLen] = '0';
    return bufLen;
  }
  for (; v; v >>= 7, v >>= 1) {
    auto b = v & 0xff;
    bufLen -= 8;
    memcpy(buffer + bufLen, &(repr[b][0]), 8);
  }
  while (buffer[bufLen] == '0') {
    ++bufLen;
  }
  return bufLen;
}

template<class Uint >

size_t folly::detail::uintToHex	(	char *	buffer,
		size_t	bufLen,
		Uint	v,
		std::array< std::array< char, 2 >, 256 > const &	repr
	)

Convert an unsigned to hex, using repr (which maps from each possible 2-hex-bytes value to the 2-character representation).

Just like folly::detail::uintToBuffer in Conv.h, writes at the end of the supplied buffer and returns the offset of the beginning of the string from the start of the buffer. The formatted string will be in range [buf+begin, buf+bufLen).

Definition at line 65 of file Format-inl.h.

References b, and v.

Referenced by uintToHexLower(), and uintToHexUpper().

                                                  {
  // 'v >>= 7, v >>= 1' is no more than a work around to get rid of shift size
  // warning when Uint = uint8_t (it's false as v >= 256 implies sizeof(v) > 1).
  for (; !less_than<unsigned, 256>(v); v >>= 7, v >>= 1) {
    auto b = v & 0xff;
    bufLen -= 2;
    buffer[bufLen] = repr[b][0];
    buffer[bufLen + 1] = repr[b][1];
  }
  buffer[--bufLen] = repr[v][1];
  if (v >= 16) {
    buffer[--bufLen] = repr[v][0];
  }
  return bufLen;
}

template<class Uint >

size_t folly::detail::uintToHexLower ( char *  buffer, size_t  bufLen, Uint  v  )

inline

Convert an unsigned to hex, using lower-case letters for the digits above 9. See the comments for uintToHex.

Definition at line 90 of file Format-inl.h.

References uintToHex().

Referenced by BENCHMARK_RELATIVE(), compareHex(), and folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat().

                                                                  {
  return uintToHex(buffer, bufLen, v, formatHexLower);
}

template<class Uint >

size_t folly::detail::uintToHexUpper ( char *  buffer, size_t  bufLen, Uint  v  )

inline

Convert an unsigned to hex, using upper-case letters for the digits above 9. See the comments for uintToHex.

Definition at line 99 of file Format-inl.h.

References uintToHex().

Referenced by folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat().

                                                                  {
  return uintToHex(buffer, bufLen, v, formatHexUpper);
}

template<class Uint >

size_t folly::detail::uintToOctal	(	char *	buffer,
		size_t	bufLen,
		Uint	v
	)

Convert an unsigned to octal.

Just like folly::detail::uintToBuffer in Conv.h, writes at the end of the supplied buffer and returns the offset of the beginning of the string from the start of the buffer. The formatted string will be in range [buf+begin, buf+bufLen).

Definition at line 112 of file Format-inl.h.

References b, formatOctal, and v.

Referenced by BENCHMARK_RELATIVE(), compareOctal(), and folly::FormatValue< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value >::type >::doFormat().

                                                        {
  auto& repr = formatOctal;
  // 'v >>= 7, v >>= 2' is no more than a work around to get rid of shift size
  // warning when Uint = uint8_t (it's false as v >= 512 implies sizeof(v) > 1).
  for (; !less_than<unsigned, 512>(v); v >>= 7, v >>= 2) {
    auto b = v & 0x1ff;
    bufLen -= 3;
    buffer[bufLen] = repr[b][0];
    buffer[bufLen + 1] = repr[b][1];
    buffer[bufLen + 2] = repr[b][2];
  }
  buffer[--bufLen] = repr[v][2];
  if (v >= 8) {
    buffer[--bufLen] = repr[v][1];
  }
  if (v >= 64) {
    buffer[--bufLen] = repr[v][0];
  }
  return bufLen;
}

template<typename Synchronized , typename... Args>

auto folly::detail::ulock	(	Synchronized &	synchronized,
		Args &&...	args
	)

Definition at line 945 of file Synchronized.h.

References a, testing::Args(), makeSynchronizedLocker(), and s.

Referenced by folly::ulock().

                                                       {
  return detail::makeSynchronizedLocker(
      synchronized,
      [](auto& s, auto&&... a) {
        return s.ulock(std::forward<decltype(a)>(a)...);
      },
      [](auto& s) { return s.tryULock(); },
      std::forward<Args>(args)...);
}

void folly::detail::unsafeStringSetLargerSize	(	std::string &	s,
		std::size_t	n
	)

Referenced by folly::resizeWithoutInitialization().

template<typename T >

void folly::detail::unsafeVectorSetLargerSize	(	std::vector< T > &	v,
		std::size_t	n
	)

Referenced by folly::resizeWithoutInitialization().

template<typename Arg >

decltype(auto) folly::detail::unwrap_emplace_arg ( Arg &&  arg )

noexcept

Examples:

/facebook/proxygen/proxygen/folly/folly/container/Iterator.h.

Definition at line 99 of file Iterator.h.

Referenced by folly::get_emplace_arg().

                                                      {
  return std::forward<Arg>(arg);
}

template<typename Arg >

decltype(auto) folly::detail::unwrap_emplace_arg ( std::reference_wrapper< Arg >  arg )

noexcept

Definition at line 103 of file Iterator.h.

                                                                          {
  return arg.get();
}

template<typename Arg >

decltype(auto) folly::detail::unwrap_emplace_arg ( folly::rvalue_reference_wrapper< Arg >  arg )

noexcept

Definition at line 107 of file Iterator.h.

References testing::Args(), and folly::gen::move.

                                                     {
  return std::move(arg).get();
}

template<class Iter >

std::enable_if< std::is_same< typename std::iterator_traits<Iter>::iterator_category, std::random_access_iterator_tag>::value, typename std::iterator_traits<Iter>::reference>::type folly::detail::value_before

(

Iter

i

)

For random-access iterators, the value before is simply i[-1].

Definition at line 123 of file Range.h.

References type, and value.

                     {
  return i[-1];
}

template<class Iter >

std::enable_if< !std::is_same< typename std::iterator_traits<Iter>::iterator_category, std::random_access_iterator_tag>::value, typename std::iterator_traits<Iter>::reference>::type folly::detail::value_before

(

Iter

i

)

For all other iterators, we need to use the decrement operator.

Definition at line 136 of file Range.h.

References i.

Referenced by folly::Range< unsigned char * >::back().

                     {
  return *--i;
}

template<typename Synchronized , typename... Args>

auto folly::detail::wlock	(	Synchronized &	synchronized,
		Args &&...	args
	)

Definition at line 925 of file Synchronized.h.

References a, testing::Args(), makeSynchronizedLocker(), and s.

Referenced by folly::wlock().

                                                       {
  return detail::makeSynchronizedLocker(
      synchronized,
      [](auto& s, auto&&... a) {
        return s.wlock(std::forward<decltype(a)>(a)...);
      },
      [](auto& s) { return s.tryWLock(); },
      std::forward<Args>(args)...);
}

template<class IntegralType , IntegralType DigitCount, IntegralType Base = IntegralType(10), bool PrintAllDigits = false, class = typename std::enable_if< std::is_integral<IntegralType>::value && std::is_unsigned<IntegralType>::value, bool>::type>

void folly::detail::writeIntegerString ( IntegralType  val, char **  buffer  )

inline

Definition at line 185 of file IPAddressSource.h.

References buffer(), i, and folly::value().

Referenced by fastIpv6ToBufferUnsafe().

                                                                {
  char* buf = *buffer;

  if (!PrintAllDigits && val == 0) {
    *(buf++) = '0';
    *buffer = buf;
    return;
  }

  IntegralType powerToPrint = 1;
  for (IntegralType i = 1; i < DigitCount; ++i) {
    powerToPrint *= Base;
  }

  bool found = PrintAllDigits;
  while (powerToPrint) {
    if (found || powerToPrint <= val) {
      IntegralType value = IntegralType(val / powerToPrint);
      if (Base == 10 || value < 10) {
        value += '0';
      } else {
        value += ('a' - 10);
      }
      *(buf++) = char(value);
      val %= powerToPrint;
      found = true;
    }

    powerToPrint /= Base;
  }

  *buffer = buf;
}

constexpr const char* folly::detail::xlogStripFilenameMatchFound	(	const char *	filename,
		const char *	prefixes,
		size_t	prefixIdx,
		size_t	filenameIdx
	)

Definition at line 519 of file xlog.h.

References folly::xlogIsDirSeparator(), and xlogStripFilenameRecursive().

Referenced by xlogStripFilenameRecursive().

                        {
  return (filename[filenameIdx] == '\0')
      ? xlogStripFilenameRecursive(filename, prefixes, prefixIdx + 1, 0, true)
      : (xlogIsDirSeparator(filename[filenameIdx])
             ? xlogStripFilenameMatchFound(
                   filename, prefixes, prefixIdx, filenameIdx + 1)
             : (filename + filenameIdx));
}

constexpr const char * folly::detail::xlogStripFilenameRecursive	(	const char *	filename,
		const char *	prefixes,
		size_t	prefixIdx,
		size_t	filenameIdx,
		bool	match
	)

Definition at line 531 of file xlog.h.

References folly::xlogIsDirSeparator(), and xlogStripFilenameMatchFound().

Referenced by folly::xlogIsDirSeparator(), folly::xlogStripFilename(), and xlogStripFilenameMatchFound().

                {
  // This would be much easier to understand if written as a while loop.
  // However, in order to maintain compatibility with pre-C++14 compilers we
  // have implemented it recursively to adhere to C++11 restrictions for
  // constexpr functions.
  return (prefixes[prefixIdx] == ':' || prefixes[prefixIdx] == '\0')
      ? ((match && filenameIdx > 0 &&
          (xlogIsDirSeparator(prefixes[filenameIdx - 1]) ||
           xlogIsDirSeparator(filename[filenameIdx])))
             ? (xlogStripFilenameMatchFound(
                   filename, prefixes, prefixIdx, filenameIdx))
             : ((prefixes[prefixIdx] == '\0')
                    ? filename
                    : xlogStripFilenameRecursive(
                          filename, prefixes, prefixIdx + 1, 0, true)))
      : ((match && (prefixes[prefixIdx] == filename[filenameIdx]))
             ? xlogStripFilenameRecursive(
                   filename, prefixes, prefixIdx + 1, filenameIdx + 1, true)
             : xlogStripFilenameRecursive(
                   filename, prefixes, prefixIdx + 1, 0, false));
}

Variable Documentation

decltype(cEscapeTable) FOLLY_STORAGE_CONSTEXPR folly::detail::cEscapeTable

Initial value:

=
    make_array_with<256>(string_table_c_escape_make_item{})

Definition at line 116 of file String.cpp.

Referenced by folly::cEscape().

decltype(cUnescapeTable) FOLLY_STORAGE_CONSTEXPR folly::detail::cUnescapeTable

Initial value:

=
    make_array_with<256>(string_table_c_unescape_make_item{})

Definition at line 118 of file String.cpp.

Referenced by folly::cEscape(), and folly::cUnescape().

FOLLY_STORAGE_CONSTEXPR auto folly::detail::formatAlignTable

Initial value:

=
    make_array_with<256>(format_table_align_make_item{})

Definition at line 78 of file Format.cpp.

Referenced by folly::FormatArg::initSlow().

decltype(formatBinary) FOLLY_STORAGE_CONSTEXPR folly::detail::formatBinary

Initial value:

=
    make_array_with<256>(format_table_conv_make_item<2, 8>{})

Definition at line 88 of file Format.cpp.

Referenced by uintToBinary().

decltype(formatHexLower) FOLLY_STORAGE_CONSTEXPR folly::detail::formatHexLower

Initial value:

=
    make_array_with<256>(format_table_conv_make_item<16, 2, false>{})

Definition at line 82 of file Format.cpp.

decltype(formatHexUpper) FOLLY_STORAGE_CONSTEXPR folly::detail::formatHexUpper

Initial value:

=
    make_array_with<256>(format_table_conv_make_item<16, 2, true>{})

Definition at line 84 of file Format.cpp.

decltype(formatOctal) FOLLY_STORAGE_CONSTEXPR folly::detail::formatOctal

Initial value:

=
    make_array_with<512>(format_table_conv_make_item<8, 3>{})

Definition at line 86 of file Format.cpp.

Referenced by uintToOctal().

FOLLY_STORAGE_CONSTEXPR auto folly::detail::formatSignTable

Initial value:

=
    make_array_with<256>(format_table_sign_make_item{})

Definition at line 80 of file Format.cpp.

Referenced by folly::FormatArg::initSlow().

decltype(hexTable) FOLLY_STORAGE_CONSTEXPR folly::detail::hexTable

Initial value:

=
    make_array_with<256>(string_table_hex_make_item{})

Definition at line 120 of file String.cpp.

Referenced by folly::cEscape(), folly::cUnescape(), folly::MacAddress::parse(), folly::unhexlify(), and folly::uriUnescape().

template<typename T >

constexpr auto folly::detail::is_atomic< std::atomic< Integer > > = false

A simple trait to determine if the given type is an instantiation of std::atomic

Definition at line 67 of file AtomicUtil-inl.h.

constexpr double folly::detail::kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0

Definition at line 345 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

constexpr float folly::detail::kClampCastLowerBoundFloatToInt32F = -2147483520.0f

Definition at line 349 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

constexpr double folly::detail::kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0

Definition at line 346 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

constexpr double folly::detail::kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0

Definition at line 347 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

constexpr float folly::detail::kClampCastUpperBoundFloatToInt32F = 2147483520.0f

Definition at line 350 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

constexpr float folly::detail::kClampCastUpperBoundFloatToUInt32F = 4294967040.0f

Definition at line 351 of file ConstexprMath.h.

Referenced by folly::constexpr_clamp_cast().

const size_t folly::detail::kMaxBinaryLength = 8 * sizeof(uintmax_t)

Definition at line 53 of file Format-inl.h.

Referenced by compareBinary().

const size_t folly::detail::kMaxHexLength = 2 * sizeof(uintmax_t)

Definition at line 51 of file Format-inl.h.

Referenced by BENCHMARK_RELATIVE(), and compareHex().

const size_t folly::detail::kMaxOctalLength = 3 * sizeof(uintmax_t)

Definition at line 52 of file Format-inl.h.

Referenced by BENCHMARK_RELATIVE(), and compareOctal().

std::array< std::array< std::uint8_t, 256 >, 8 > const folly::detail::kSelectInByte

Initial value:

= makeSelectInByteArray(
        make_index_sequence<256>{},
        make_index_sequence<8>{})

Definition at line 57 of file Select64.cpp.

Referenced by folly::select64(), and TEST_F().

FOLLY_PUSH_WARNING RHS folly::detail::rhs

Definition at line 649 of file Traits.h.

Referenced by testing::internal::ArrayEq(), folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >::assignImpl(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::assignImpl(), BENCHMARK(), folly::BenchmarkSuspender::BenchmarkSuspender(), PreCalculatedPrimeTable::CalculatePrimesUpTo(), CheckedInt::CheckedInt(), testing::internal::CmpHelperEQ(), testing::internal::CmpHelperFloatingPointEQ(), testing::internal::RefMatcher< T & >::Impl< Super >::DescribeNegationTo(), testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), testing::DoubleEq(), testing::DoubleNear(), folly::detail::EmulatedFutexAtomic< T >::EmulatedFutexAtomic(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::exchange(), testing::FloatEq(), testing::internal::FloatingPointLE(), testing::FloatNear(), folly::exception_tracer::getExceptionStatistics(), folly::hazptr_holder< Atom >::hazptr_holder(), testing::UnitTest::impl(), folly::detail::IndexedMemPoolRecycler< Pool >::IndexedMemPoolRecycler(), folly::fbstring_core< char >::isShared(), folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr(), folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >::LockedPtrBase(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), folly::MPMCQueue< T, Atom, true >::MPMCQueue(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::MPMCQueueBase(), testing::NanSensitiveDoubleEq(), testing::NanSensitiveDoubleNear(), testing::NanSensitiveFloatEq(), testing::NanSensitiveFloatNear(), folly::f14::MoveOnlyTestInt::operator!=(), folly::f14::Counts::operator!=(), folly::AtomicUnorderedInsertMap< Key, Value, Hash, KeyEqual, SkipKeyValueDeletion, Atom, IndexType, Allocator >::ConstIterator::operator!=(), folly::f14::Tracked< 0 >::operator!=(), folly::detail::LifoSemHead::operator!=(), testing::Expectation::operator!=(), folly::f14::GenericAlloc< T >::operator!=(), testing::ExpectationSet::operator!=(), folly::operator!=(), folly::detail::DynamicKeyEqual::operator()(), folly::detail::TransparentRangeEqualTo< detail::ValueTypeForTransparentConversionToRange< T >::type >::operator()(), folly::f14::GenericEqual< T >::operator()(), folly::AsciiCaseSensitive::operator()(), folly::AsciiCaseInsensitive::operator()(), testing::internal::LessComparator::operator()(), folly::operator+(), folly::operator<=(), folly::hazptr_holder< Atom >::operator=(), folly::f14::MoveOnlyTestInt::operator=(), folly::BenchmarkSuspender::operator=(), folly::F14VectorSet< Key, Hasher, KeyEqual, Alloc >::operator=(), folly::F14VectorMap< Key, Mapped, Hasher, KeyEqual, Alloc >::operator=(), folly::f14::Tracked< 0 >::operator=(), folly::MPMCQueue< T, Atom, true >::operator=(), folly::Synchronized< std::vector< detail::folly::detail::TypeDescriptor >, folly::SharedMutexImpl >::operator=(), folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::operator=(), CheckedInt::operator=(), folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >::operator=(), folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::ReadHolder::operator=(), folly::LockedPtr< SynchronizedType, LockPolicy >::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::UpgradeHolder::operator=(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WriteHolder::operator=(), folly::detail::IteratorFacade< dynamic::const_key_iterator, dynamic const , std::forward_iterator_tag >::operator==(), folly::StringKeyedMap< Value, Compare, Alloc >::operator==(), folly::StringKeyedSetBase< Compare, Alloc >::operator==(), folly::operator>=(), folly::parseLeadingNumber(), testing::Pointwise(), folly::Range< unsigned char * >::Range(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::ReadHolder::ReadHolder(), testing::internal::ShouldRunTestCase(), folly::hazptr_holder< Atom >::swap(), folly::Expected< int, E >::swap(), folly::swap(), TEST(), testing::TEST(), testing::gmock_matchers_test::TEST(), folly::f14::Tracked< 0 >::Tracked(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::UpgradeHolder::UpgradeHolder(), folly::SharedMutexImpl< ReaderPriority, Tag_, Atom, BlockImmediately, AnnotateForThreadSanitizer >::WriteHolder::WriteHolder(), and folly::fibers::TimedMutex::~TimedMutex().

struct folly::detail::LastElementImpl folly::detail::sizeof

FOLLY_TLS uint32_t folly::detail::tls_lastCpuBufferSlot = 0

static

Definition at line 28 of file DigestBuilder-defs.h.

Referenced by folly::detail::DigestBuilder< DigestT >::append().

decltype(uriEscapeTable) FOLLY_STORAGE_CONSTEXPR folly::detail::uriEscapeTable

Initial value:

=
    make_array_with<256>(string_table_uri_escape_make_item{})

Definition at line 122 of file String.cpp.

Referenced by folly::cUnescape(), and folly::uriEscape().