Namespaces
	__swap_test_detail

	Detail

	double_conversion

	ExpectedDetail

	Internal

	LEBDecoder

	Persistence

	seconds_literals

	Unicode

Classes
struct	__all_copy_assignable

struct	__all_copy_assignable< _Head, _Rest... >

struct	__all_copy_assignable<>

struct	__all_copy_constructible

struct	__all_copy_constructible< _Head, _Rest... >

struct	__all_copy_constructible<>

struct	__all_indices

struct	__all_indices_helper

struct	__all_indices_helper< _Offset, __index_sequence< _Indices... >, _Type, _Type, _Rest... >

struct	__all_indices_helper< _Offset, _CurrentSequence, _Type >

struct	__all_indices_helper< _Offset, _CurrentSequence, _Type, _Head, _Rest... >

struct	__all_move_assignable

struct	__all_move_assignable< _Head, _Rest... >

struct	__all_move_assignable<>

struct	__all_move_constructible

struct	__all_move_constructible< _Head, _Rest... >

struct	__all_move_constructible<>

struct	__all_swappable

struct	__all_swappable< _Head, _Rest... >

struct	__all_swappable<>

struct	__all_trivially_destructible

struct	__all_trivially_destructible< _Head, _Rest... >

struct	__all_trivially_destructible< _Type >

struct	__all_trivially_destructible<>

struct	__any_backup_storage_required

struct	__any_backup_storage_required< Variant< _Types... > >

struct	__any_backup_storage_required_impl

struct	__any_backup_storage_required_impl< _Index, 0, _Types... >

struct	__arg_selector_t

struct	__arg_selector_t< 0, _Head, _Rest... >

struct	__arg_selector_t< _Index, _Head, _Rest... >

struct	__backup_storage

struct	__backup_storage_op_table

struct	__backup_storage_op_table< _MaskIndex, _Storage, __index_sequence< _Indices... > >

struct	__backup_storage_ops

struct	__backup_storage_ops< _Index, _Index, _Storage >

struct	__backup_storage_required

struct	__combine_sequences

struct	__combine_sequences< __index_sequence< _Indices1... >, __index_sequence< _Indices2... > >

struct	__combine_sequences< _Sequence, _Rest... >

struct	__constructible_matches

struct	__constructible_matches_helper

struct	__constructible_matches_helper< _Offset, _CurrentSequence, _Type, _Head, _Rest... >

struct	__constructible_matches_helper< _Offset, _Sequence, _Type >

struct	__copy_assign_op_table

struct	__copy_assign_op_table< _Variant, __index_sequence< _Indices... > >

struct	__copy_construct_op_table

struct	__copy_construct_op_table< _Variant, __index_sequence< _Indices... > >

struct	__destroy_op_table

struct	__destroy_op_table< _Variant, __index_sequence< _Indices... > >

struct	__discriminator_type

struct	__discriminator_type< __count, true, false, false >

struct	__discriminator_type< __count, true, true, false >

struct	__discriminator_type< __count, true, true, true >

struct	__equality_op_table

struct	__equality_op_table< _Variant, __index_sequence< _Indices... > >

struct	__first_index

struct	__first_index< __index_sequence< _FirstIndex, _Rest... > >

struct	__hash_visitor

struct	__in_place_private

struct	__index_sequence

struct	__indexed_type

struct	__indexed_type< 0, _Head, _Rest... >

struct	__indexed_type< _Index, _Head, _Rest... >

struct	__indexed_type<-1, _Head, _Rest... >

struct	__is_swappable

struct	__less_than_op_table

struct	__less_than_op_table< _Variant, __index_sequence< _Indices... > >

struct	__move_assign_op_table

struct	__move_assign_op_table< _Variant, __index_sequence< _Indices... > >

struct	__move_construct_op_table

struct	__move_construct_op_table< _Variant, __index_sequence< _Indices... > >

struct	__multi_visitor_return_type

struct	__next_index

struct	__noexcept_variant_const_copy_construct

struct	__noexcept_variant_const_copy_construct_impl

struct	__noexcept_variant_const_copy_construct_impl< true >

struct	__noexcept_variant_const_copy_construct_impl< true, _Head, _Rest... >

struct	__noexcept_variant_move_assign

struct	__noexcept_variant_move_assign_impl

struct	__noexcept_variant_move_assign_impl< true >

struct	__noexcept_variant_move_assign_impl< true, _Head, _Rest... >

struct	__noexcept_variant_move_construct

struct	__noexcept_variant_move_construct_impl

struct	__noexcept_variant_move_construct_impl< true >

struct	__noexcept_variant_move_construct_impl< true, _Head, _Rest... >

struct	__noexcept_variant_non_const_copy_construct

struct	__noexcept_variant_non_const_copy_construct_impl

struct	__noexcept_variant_non_const_copy_construct_impl< true >

struct	__noexcept_variant_non_const_copy_construct_impl< true, _Head, _Rest... >

struct	__noexcept_variant_swap

struct	__noexcept_variant_swap_impl

struct	__noexcept_variant_swap_impl< true >

struct	__noexcept_variant_swap_impl< true, _Head, _Rest... >

struct	__other_storage_nothrow_move_constructible

struct	__other_storage_nothrow_move_constructible< 0, _Head, _Rest... >

struct	__other_storage_nothrow_move_constructible< _Index, _Head, _Rest... >

struct	__other_storage_nothrow_move_constructible<-1, _Head, _Rest... >

struct	__replace_construct_helper

struct	__sequence_or_empty

struct	__sequence_or_empty< true, _Entry >

struct	__storage_nothrow_constructible

struct	__storage_nothrow_move_constructible

struct	__storage_nothrow_move_constructible< _Head, _Rest... >

struct	__storage_nothrow_move_constructible< _Type >

struct	__storage_nothrow_move_constructible<>

struct	__storage_wrapper

struct	__storage_wrapper< _Type & >

struct	__stored_type

struct	__stored_type< _Type & >

struct	__swap_op_table

struct	__swap_op_table< _Variant, __index_sequence< _Indices... > >

struct	__type_index

struct	__type_index_helper

struct	__type_index_helper< _Offset, _Type, _Head, _Rest... >

struct	__type_index_helper< _Offset, _Type, _Type, _Rest... >

struct	__type_index_to_construct

struct	__type_indices

struct	__type_indices< _Type >

struct	__type_indices< _Type, _Rest... >

struct	__type_indices<>

struct	__variant_accessor

struct	__variant_base

struct	__variant_base< _Derived, true >

union	__variant_data

union	__variant_data< _Head, _Rest... >

union	__variant_data< _Type & >

union	__variant_data< _Type && >

union	__variant_data< _Type >

union	__variant_data<>

struct	__variant_indices

struct	__variant_indices< Variant< _Types... > >

struct	__variant_storage

struct	__variant_storage< _Type &&, __b >

struct	__variant_storage< _Type &, __b >

struct	__variant_storage< _Type, false >

struct	__variant_storage_type

struct	__variant_type_count

struct	__variant_type_count< _Variant & >

struct	__variant_type_count< _Variant const & >

struct	__variant_type_count< Variant< _Types... > >

struct	__visit_helper

struct	__visit_helper2

struct	__visit_helper2<-1, _VariantIndex, _Indices... >

struct	__visit_helper< 0, __index_sequence< _Indices... > >

struct	__visit_helper< _VariantIndex, __index_sequence< _Indices... > >

struct	__visitor_return_type

struct	__visitor_return_type< _Visitor >

struct	__visitor_return_type< _Visitor, _Head, _Rest... >

struct	__visitor_table

class	AbstractLocker

struct	AlreadyHashed

struct	ArithmeticOperations

struct	ArithmeticOperations< int, unsigned, ResultType, true, false >

struct	ArithmeticOperations< LHS, RHS, ResultType, false, false >

struct	ArithmeticOperations< LHS, RHS, ResultType, true, true >

struct	ArithmeticOperations< unsigned, int, ResultType, false, true >

class	ASCIICaseInsensitiveHash

class	ASCIILiteral

struct	Atomic

class	AtomicString

struct	AtomicStringHash

class	AtomicStringImpl

class	AtomicStringTable

class	AtomicStringTableLocker

class	AutodrainedPool

class	AutomaticThread

class	AutomaticThreadCondition

class	BackwardsGraph

class	bad_variant_access

class	Bag

class	BasicRawSentinelNode

struct	BigInt

class	BinarySemaphore

class	Bitmap

class	BitVector

struct	BitVectorHash

class	BlockPtr

class	BlockPtr< R(Args...)>

class	BlockStack

class	BloomFilter

struct	BoundsChecker< Target, Source, false, false, false >

struct	BoundsChecker< Target, Source, false, false, true >

struct	BoundsChecker< Target, Source, false, true, false >

struct	BoundsChecker< Target, Source, false, true, true >

struct	BoundsChecker< Target, Source, true, false, false >

struct	BoundsChecker< Target, Source, true, false, true >

struct	BoundsChecker< Target, Source, true, true, false >

struct	BoundsChecker< Target, Source, true, true, true >

class	Box

class	BumpPointerAllocator

class	BumpPointerPool

class	CachedTextBreakIterator

struct	CFTypeTrait

struct	CharBufferFromLiteralDataTranslator

class	Checked

class	Collator

struct	ColorHash

class	CommaPrinter

class	CompilationScope

class	Condition

struct	ConditionBase

class	ConstSignedOrUnsignedCharVectorAdapter

struct	Consumed

class	CopierRefCountedTest

class	CopierThreadSafeRefCountedTest

class	CountingBloomFilter

class	CrashOnOverflow

struct	CrossThreadCopier

struct	CrossThreadCopierBase

struct	CrossThreadCopierBase< false, false, PassRefPtr< T > >

struct	CrossThreadCopierBase< false, false, RefPtr< T > >

struct	CrossThreadCopierBase< false, false, std::chrono::system_clock::time_point >

struct	CrossThreadCopierBase< false, false, T * >

struct	CrossThreadCopierBase< false, false, T >

struct	CrossThreadCopierBase< false, false, Vector< T > >

struct	CrossThreadCopierBase< false, false, WebCore::SessionID >

struct	CrossThreadCopierBase< false, false, WebCore::ThreadSafeDataBuffer >

struct	CrossThreadCopierBase< false, false, WTF::ASCIILiteral >

struct	CrossThreadCopierBase< false, true, T >

struct	CrossThreadCopierBase< true, false, T >

struct	CrossThreadCopierBaseHelper

struct	CrossThreadCopierPassThrough

class	CrossThreadQueue

class	CrossThreadTask

class	CString

class	CStringBuffer

struct	CStringHash

struct	CStringTranslator

struct	CustomHashTraits

class	DecimalNumber

struct	DefaultHash

struct	DefaultHash< AtomicString >

struct	DefaultHash< BitVector >

struct	DefaultHash< bool >

struct	DefaultHash< COMPtr< P > >

struct	DefaultHash< CString >

struct	DefaultHash< DeletedAddressOfOperator >

struct	DefaultHash< double >

struct	DefaultHash< float >

struct	DefaultHash< int >

struct	DefaultHash< IPC::StringReference >

struct	DefaultHash< JSC::BasicBlockKey >

struct	DefaultHash< JSC::CallVariant >

struct	DefaultHash< JSC::CodeOrigin >

struct	DefaultHash< JSC::DFG::CompilationKey >

struct	DefaultHash< JSC::DFG::MinifiedID >

struct	DefaultHash< JSC::ICEvent >

struct	DefaultHash< JSC::LazyOperandValueProfileKey >

struct	DefaultHash< JSC::MacroAssemblerCodePtr >

struct	DefaultHash< JSC::MarkedBlock * >

struct	DefaultHash< JSC::ObjectPropertyCondition >

struct	DefaultHash< JSC::Profiler::Origin >

struct	DefaultHash< JSC::Profiler::OriginStack >

struct	DefaultHash< JSC::Profiler::UID >

struct	DefaultHash< JSC::PropertyCondition >

struct	DefaultHash< JSC::QueryKey >

struct	DefaultHash< JSC::RegExpKey >

struct	DefaultHash< JSC::TemplateRegistryKey >

struct	DefaultHash< JSC::VarOffset >

struct	DefaultHash< JSC::VisitRaceKey >

struct	DefaultHash< long >

struct	DefaultHash< long long >

struct	DefaultHash< MoveOnly >

struct	DefaultHash< P * >

struct	DefaultHash< Ref< P > >

struct	DefaultHash< RefPtr< P > >

struct	DefaultHash< RefPtr< StringImpl > >

struct	DefaultHash< RefPtr< WebCore::SecurityOrigin > >

struct	DefaultHash< short >

struct	DefaultHash< std::pair< int, int > >

struct	DefaultHash< std::pair< int, short > >

struct	DefaultHash< std::pair< int, unsigned > >

struct	DefaultHash< std::pair< int, unsigned short > >

struct	DefaultHash< std::pair< short, int > >

struct	DefaultHash< std::pair< short, short > >

struct	DefaultHash< std::pair< short, unsigned > >

struct	DefaultHash< std::pair< short, unsigned short > >

struct	DefaultHash< std::pair< T, U > >

struct	DefaultHash< std::pair< unsigned short, int > >

struct	DefaultHash< std::pair< unsigned short, short > >

struct	DefaultHash< std::pair< unsigned short, unsigned > >

struct	DefaultHash< std::pair< unsigned short, unsigned short > >

struct	DefaultHash< std::pair< unsigned, int > >

struct	DefaultHash< std::pair< unsigned, short > >

struct	DefaultHash< std::pair< unsigned, unsigned > >

struct	DefaultHash< std::pair< unsigned, unsigned short > >

struct	DefaultHash< std::tuple< Types... > >

struct	DefaultHash< std::unique_ptr< P, Deleter > >

struct	DefaultHash< String >

struct	DefaultHash< StringImpl * >

struct	DefaultHash< SymbolRegistryKey >

struct	DefaultHash< unsigned >

struct	DefaultHash< unsigned long >

struct	DefaultHash< unsigned long long >

struct	DefaultHash< unsigned short >

struct	DefaultHash< WebCore::Color >

struct	DefaultHash< WebCore::ContentSecurityPolicyDigest >

struct	DefaultHash< WebCore::ContentSecurityPolicyHashAlgorithm >

struct	DefaultHash< WebCore::Cookie >

struct	DefaultHash< WebCore::CSSParserContext >

struct	DefaultHash< WebCore::CSSPropertyID >

struct	DefaultHash< WebCore::FloatSize >

struct	DefaultHash< WebCore::IntPoint >

struct	DefaultHash< WebCore::IntRect >

struct	DefaultHash< WebCore::IntSize >

struct	DefaultHash< WebCore::ProtectionSpace >

struct	DefaultHash< WebCore::QualifiedName >

struct	DefaultHash< WebCore::SecurityOriginData >

struct	DefaultHash< WebCore::SessionID >

struct	DefaultHash< WebCore::URL >

struct	DefaultHash< WebKit::DownloadID >

struct	DefaultHash< WKRetainPtr< P > >

class	DeferrableRefCounted

class	DeferrableRefCountedBase

class	Deque

class	DequeConstIterator

class	DequeIterator

class	DequeIteratorBase

class	DispatchAfterContext

class	Dominators

class	DoublyLinkedList

class	DoublyLinkedListNode

struct	DownloadIDHash

struct	EnumTraits

struct	EnumTraits< IPC::NSType >

struct	EnumTraits< TestEnum >

struct	EnumTraits< WebCore::ColorSpace >

struct	EnumTraits< WebCore::HasInsecureContent >

struct	EnumTraits< WebCore::ShouldSample >

struct	EnumTraits< WebKit::LayerHostingMode >

struct	EnumValueChecker

struct	EnumValueChecker< T, EnumValues< E > >

struct	EnumValueChecker< T, EnumValues< E, e, es... > >

struct	EnumValues

class	Expected

class	Expected< void, E >

class	ExtendedGraphNodeWorklist

class	FastBitVector

class	FastBitVectorAndWords

class	FastBitVectorImpl

class	FastBitVectorNotWords

class	FastBitVectorOrWords

class	FastBitVectorWordOwner

class	FastBitVectorWordView

struct	FastMallocStatistics

class	FilePrintStream

class	FilterIterator

struct	FloatHash

struct	FloatHash< WebCore::FloatSize >

struct	FloatHashTraits

class	FormatImpl

struct	FormatImplUnpacker

struct	FormatImplUnpacker< 0, Types... >

class	FormattedNumber

class	Function

class	Function< Out(In...)>

class	FunctionDispatcher

class	GDIObject

struct	GenericHashTraits

struct	GenericHashTraitsBase

struct	GenericHashTraitsBase< false, T >

struct	GenericHashTraitsBase< true, T >

struct	GetPtrHelper

struct	GetPtrHelper< Ref< T > >

struct	GetPtrHelper< std::unique_ptr< T, Deleter > >

struct	GetPtrHelperBase

struct	GetPtrHelperBase< T, false >

struct	GetPtrHelperBase< T, true >

struct	GraphNodeWith

struct	GraphNodeWithOrder

class	GraphNodeWorklist

class	GregorianDateTime

struct	HashAndCharacters

struct	HashAndCharactersTranslator

struct	HashAndUTF8Characters

struct	HashAndUTF8CharactersTranslator

class	HashCountedSet

class	HashMap

struct	HashMapEnsureTranslator

struct	HashMapTranslator

struct	HashMapTranslatorAdapter

struct	HashMethod

class	HashSet

struct	HashSetTranslator

struct	HashSetTranslatorAdapter

class	HashTable

struct	HashTableAddResult

struct	HashTableBucketInitializer

struct	HashTableBucketInitializer< false >

struct	HashTableBucketInitializer< true >

struct	HashTableCapacityForSize

struct	HashTableCapacityForSizeSplitter

struct	HashTableCapacityForSizeSplitter< size, false >

struct	HashTableCapacityForSizeSplitter< size, true >

class	HashTableConstIterator

struct	HashTableConstIteratorAdapter

struct	HashTableConstIteratorAdapter< HashTableType, KeyValuePair< KeyType, MappedType > >

struct	HashTableConstKeysIterator

struct	HashTableConstValuesIterator

class	HashTableIterator

struct	HashTableIteratorAdapter

struct	HashTableIteratorAdapter< HashTableType, KeyValuePair< KeyType, MappedType > >

struct	HashTableKeysIterator

struct	HashTableValuesIterator

struct	HashTraitHasCustomDelete

struct	HashTraits

struct	HashTraits< BitVector >

struct	HashTraits< COMPtr< P > >

struct	HashTraits< CString >

struct	HashTraits< DeletedAddressOfOperator >

struct	HashTraits< double >

struct	HashTraits< float >

struct	HashTraits< IPC::StringReference >

struct	HashTraits< JSC::BasicBlockKey >

struct	HashTraits< JSC::CallVariant >

struct	HashTraits< JSC::CodeOrigin >

struct	HashTraits< JSC::DFG::CompilationKey >

struct	HashTraits< JSC::DFG::MinifiedID >

struct	HashTraits< JSC::ICEvent >

struct	HashTraits< JSC::LazyOperandValueProfileKey >

struct	HashTraits< JSC::MacroAssemblerCodePtr >

struct	HashTraits< JSC::ObjectPropertyCondition >

struct	HashTraits< JSC::Profiler::Origin >

struct	HashTraits< JSC::Profiler::OriginStack >

struct	HashTraits< JSC::Profiler::UID >

struct	HashTraits< JSC::PropertyCondition >

struct	HashTraits< JSC::QueryKey >

struct	HashTraits< JSC::RegExpKey >

struct	HashTraits< JSC::Strong< P > >

struct	HashTraits< JSC::TemplateRegistryKey >

struct	HashTraits< JSC::VarOffset >

struct	HashTraits< JSC::VisitRaceKey >

struct	HashTraits< JSC::Weak< T > >

struct	HashTraits< KeyValuePair< Key, Value > >

struct	HashTraits< MoveOnly >

struct	HashTraits< P * >

struct	HashTraits< Ref< P > >

struct	HashTraits< RefPtr< P > >

struct	HashTraits< std::pair< First, Second > >

struct	HashTraits< std::tuple< Traits... > >

struct	HashTraits< std::unique_ptr< T, Deleter > >

struct	HashTraits< String >

struct	HashTraits< SymbolRegistryKey >

struct	HashTraits< WebCore::Color >

struct	HashTraits< WebCore::ContentSecurityPolicyHashAlgorithm >

struct	HashTraits< WebCore::CSSParserContext >

struct	HashTraits< WebCore::CSSPropertyID >

struct	HashTraits< WebCore::FloatSize >

struct	HashTraits< WebCore::IntPoint >

struct	HashTraits< WebCore::IntRect >

struct	HashTraits< WebCore::IntSize >

struct	HashTraits< WebCore::ProtectionSpace >

struct	HashTraits< WebCore::QualifiedName >

struct	HashTraits< WebCore::RenderPtr< T > >

struct	HashTraits< WebCore::SecurityOriginData >

struct	HashTraits< WebCore::SessionID >

struct	HashTraits< WebCore::URL >

struct	HashTraits< WebKit::DownloadID >

struct	HashTraits< WKRetainPtr< P > >

struct	HashTraits< WTF::AtomicString >

struct	HashTraitsEmptyValueChecker

struct	HashTraitsEmptyValueChecker< Traits, false >

struct	HashTraitsEmptyValueChecker< Traits, true >

struct	HashTranslatorCharBuffer

struct	IdentityExtractor

class	IdentityHashTranslator

struct	in_place_tag

class	Indenter

class	IndexedContainerIterator

class	IndexMap

class	IndexSet

class	IndexSparseSet

class	Insertion

class	IntegerHasher

struct	IntegerToStringConversionTrait

struct	IntegerToStringConversionTrait< AtomicString >

struct	IntegerToStringConversionTrait< String >

struct	IntegerToStringConversionTrait< StringBuilder >

struct	IntHash

struct	IntHash< WebCore::IntRect >

struct	IntHash< WebCore::IntSize >

struct	IntPairHash

struct	IntPointHash

struct	IntTypes

struct	IntTypes< 1 >

struct	IntTypes< 2 >

struct	IntTypes< 4 >

struct	IntTypes< 8 >

struct	IsBaseOfTemplate

struct	IsSmartPtr

struct	IsSmartPtr< COMPtr< P > >

struct	IsSmartPtr< PassRefPtr< T > >

struct	IsSmartPtr< Ref< T > >

struct	IsSmartPtr< RefPtr< T > >

struct	IsSmartPtr< std::unique_ptr< T, Deleter > >

struct	IsSmartPtr< WKRetainPtr< T > >

struct	IsTemplate

class	IteratorRange

struct	KeyValuePair

struct	KeyValuePairHashTraits

struct	KeyValuePairKeyExtractor

struct	KnownZone

class	LazyLineBreakIterator

class	LazyNeverDestroyed

struct	LCharBufferTranslator

class	LineBreakIteratorPool

class	ListDump

class	ListDumpInContext

class	ListHashSet

class	ListHashSetConstIterator

class	ListHashSetIterator

struct	ListHashSetNode

struct	ListHashSetNodeHashFunctions

struct	ListHashSetTranslator

struct	ListHashSetTranslatorAdapter

struct	LocalTimeOffset

class	Lock

class	LockAlgorithm

struct	LockBase

class	LockedPrintStream

class	Locker

class	MainThreadDispatcher

class	MallocPtr

class	MapDump

struct	MarkedBlockHash

struct	match_constness

class	MD5

class	MediaTime

class	MemoryPressureHandler

class	MessageQueue

class	MetaAllocator

class	MetaAllocatorHandle

class	MetaAllocatorTracker

struct	Monostate

class	MonotonicTime

class	Mutex

class	NakedPtr

class	NeverDestroyed

struct	NewThreadContext

class	NoLock

struct	NonASCIIMask

struct	NonASCIIMask< 4, LChar >

struct	NonASCIIMask< 4, UChar >

struct	NonASCIIMask< 8, LChar >

struct	NonASCIIMask< 8, UChar >

class	NonSharedCharacterBreakIterator

struct	NullableHashTraits

class	NullTextBreakIterator

struct	OneifyLowBits

struct	OneifyLowBits< 0 >

class	Optional

class	OptionSet

class	OrderMaker

class	OrdinalNumber

class	OSAllocator

class	OSObjectPtr

struct	P5Node

class	PackedIntVector

class	PageAllocation

class	PageBlock

class	PageReservation

struct	PairHash

struct	PairHashTraits

class	ParallelHelperClient

class	ParallelHelperPool

class	ParallelJobs

class	ParallelVectorIterator

class	ParkingLot

class	PassRefPtr

class	PointerDump

class	PointerDumpInContext

class	PointerListDump

class	PostOrderGraphNodeWorklist

class	PrintStream

struct	PtrHash

struct	PtrHash< Ref< P > >

struct	PtrHashBase

struct	PtrHashBase< T, false >

struct	PtrHashBase< T, true >

class	RangeSet

class	RawPointer

class	RecordOverflow

class	RecursiveLockAdapter

class	RedBlackTree

class	Ref

class	RefCounted

class	RefCountedArray

class	RefCountedBase

struct	RefCountedLeakCounter

class	RefCounter

class	RefPtr

struct	RemoveChecked

struct	RemoveChecked< Checked< T, CrashOnOverflow > >

struct	RemoveChecked< Checked< T, RecordOverflow > >

struct	RemoveCVAndReference

struct	Result

struct	ResultBase

struct	ResultBase< U, U, false, true >

struct	ResultBase< U, V, false, false >

struct	ResultBase< U, V, false, true >

struct	ResultBase< U, V, true, false >

class	RetainPtr

class	RunLoop

class	RunLoopTimer

class	RunLoopTimerBase

struct	SameSizeAsRefCounted

struct	SameSizeAsVectorWithInlineCapacity

struct	SameSizeAsVectorWithInlineCapacity< T, 0 >

class	SchedulePair

struct	SchedulePairHash

class	ScopedLambda

class	ScopedLambda< ResultType(ArgumentTypes...)>

class	ScopedLambdaFunctor

class	ScopedLambdaFunctor< ResultType(ArgumentTypes...), Functor >

class	ScopedLambdaRefFunctor

class	ScopedLambdaRefFunctor< ResultType(ArgumentTypes...), Functor >

class	ScopeExit

class	Seconds

class	SegmentedVector

class	SegmentedVectorIterator

class	SentinelLinkedList

struct	SessionIDHash

class	SetForScope

class	SHA1

class	SharedTask

class	SharedTask< ResultType(ArgumentTypes...)>

class	SharedTaskFunctor

class	SharedTaskFunctor< ResultType(ArgumentTypes...), Functor >

struct	SignednessSelector

struct	SignednessSelector< U, V, false, false >

struct	SignednessSelector< U, V, false, true >

struct	SignednessSelector< U, V, true, false >

struct	SignednessSelector< U, V, true, true >

class	SignedOrUnsignedCharVectorAdapter

struct	SignedWithZeroKeyHashTraits

struct	SimpleClassHashTraits

struct	SimpleClassVectorTraits

class	SimpleStats

class	SinglyLinkedList

class	SmallPtrSet

class	SpaceOrNewlinePredicate

class	Spectrum

class	StackBounds

class	StackStats

class	Stopwatch

class	StreamBuffer

class	String

class	StringAppend

class	StringBuffer

class	StringBuilder

struct	StringHash

class	StringHashDumpContext

class	StringHasher

class	StringImpl

class	StringPrintStream

class	StringTypeAdapter

class	StringTypeAdapter< ASCIILiteral >

class	StringTypeAdapter< AtomicString >

class	StringTypeAdapter< char * >

class	StringTypeAdapter< char >

class	StringTypeAdapter< const char * >

class	StringTypeAdapter< const LChar * >

class	StringTypeAdapter< const UChar * >

class	StringTypeAdapter< double >

class	StringTypeAdapter< float >

class	StringTypeAdapter< FormattedNumber >

class	StringTypeAdapter< int >

class	StringTypeAdapter< String >

class	StringTypeAdapter< StringAppend< StringType1, StringType2 > >

class	StringTypeAdapter< StringView >

class	StringTypeAdapter< UChar >

class	StringTypeAdapter< unsigned >

class	StringTypeAdapter< Vector< char > >

class	StringView

struct	StrongEnumHashTraits

struct	SubstringLocation

struct	SubstringTranslator

struct	SubstringTranslator16

struct	SubstringTranslator8

class	SymbolImpl

class	SymbolRegistry

class	SymbolRegistryKey

class	SynchronizedFixedQueue

class	TextBreakIterator

class	TextBreakIteratorCache

class	TextBreakIteratorCF

class	TextBreakIteratorICU

class	TextPosition

class	ThreadCondition

struct	ThreadFunctionInvocation

class	ThreadIdentifierData

class	ThreadSafeRefCounted

class	ThreadSafeRefCountedBase

class	ThreadSpecific

struct	TimerContext

class	TimeWithDynamicClockType

class	TinyLRUCache

struct	TinyLRUCachePolicy

class	TinyLRUCachePolicy< AtomicString, RetainPtr< CFLocaleRef > >

class	TinyPtrSet

class	TransformIterator

class	TryMallocReturnValue

struct	TupleHash

struct	TupleHashTraits

struct	TypeCastTraits

class	TypeCastTraits< const WebCore::HTMLAnchorElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLAppletElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLAreaElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLAttachmentElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLBaseElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLBDIElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLBodyElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLBRElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLButtonElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLCanvasElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDataElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDataListElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDetailsElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDirectoryElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDivElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLDListElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLEmbedElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLFieldSetElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLFontElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLFormElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLFrameElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLFrameSetElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLHeadElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLHRElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLHtmlElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLIFrameElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLImageElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLInputElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLKeygenElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLLabelElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLLegendElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLLIElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLLinkElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLMapElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLMarqueeElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLMenuElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLMetaElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLMeterElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLObjectElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLOListElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLOptGroupElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLOptionElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLOutputElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLParagraphElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLParamElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLPictureElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLProgressElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLScriptElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLSelectElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLSlotElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLSourceElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLSpanElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLStyleElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLSummaryElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTableCaptionElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTableElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTableRowElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTemplateElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTextAreaElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTimeElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTitleElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLTrackElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLUListElement, ArgType, false >

class	TypeCastTraits< const WebCore::HTMLWBRElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLFractionElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLMathElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLMencloseElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLOperatorElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLPaddedElement, ArgType, false >

class	TypeCastTraits< const WebCore::MathMLSpaceElement, ArgType, false >

class	TypeCastTraits< const WebCore::RubyElement, ArgType, false >

class	TypeCastTraits< const WebCore::RubyTextElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAltGlyphDefElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAltGlyphElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAltGlyphItemElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAnimateColorElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAnimateElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAnimateMotionElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGAnimateTransformElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGCircleElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGClipPathElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGCursorElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGDefsElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGDescElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGEllipseElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEBlendElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEColorMatrixElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEComponentTransferElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFECompositeElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEConvolveMatrixElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEDiffuseLightingElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEDisplacementMapElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEDistantLightElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEDropShadowElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEFloodElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEFuncAElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEFuncBElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEFuncGElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEFuncRElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEGaussianBlurElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEImageElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEMergeElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEMergeNodeElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEMorphologyElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEOffsetElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFEPointLightElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFESpecularLightingElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFESpotLightElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFETileElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFETurbulenceElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFilterElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontFaceElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontFaceFormatElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontFaceNameElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontFaceSrcElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGFontFaceUriElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGForeignObjectElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGGElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGGlyphElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGGlyphRefElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGHKernElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGImageElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGLinearGradientElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGLineElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGMarkerElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGMaskElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGMetadataElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGMissingGlyphElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGMPathElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGPathElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGPatternElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGPolygonElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGPolylineElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGRadialGradientElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGRectElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGScriptElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGSetElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGStopElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGStyleElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGSVGElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGSwitchElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGSymbolElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGTextElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGTextPathElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGTitleElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGTRefElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGTSpanElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGUseElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGViewElement, ArgType, false >

class	TypeCastTraits< const WebCore::SVGVKernElement, ArgType, false >

struct	TypeCastTraits< ExpectedType, ArgType, true >

union	U

struct	UCharBufferTranslator

class	UCharPredicate

class	UnexpectedType

struct	UnexpectTag

class	UnionFind

class	UniquedStringImpl

class	UniqueRef

struct	UnsafeVectorOverflow

struct	UnsignedWithZeroKeyHashTraits

struct	UpperPowerOfTwoBound

struct	UTextWithBuffer

struct	ValueCheck

struct	ValueCheck< AtomicStringImpl * >

struct	ValueCheck< const AtomicStringImpl * >

struct	ValueCheck< const SymbolImpl * >

struct	ValueCheck< const UniquedStringImpl * >

struct	ValueCheck< P * >

struct	ValueCheck< StringImpl * >

struct	ValueCheck< SymbolImpl * >

struct	ValueCheck< UniquedStringImpl * >

struct	ValueCheck< Vector< T > >

struct	ValueCheck< WebCore::ImageLoader * >

class	ValueIgnoringContext

class	ValueInContext

class	Variant

class	Variant<>

struct	variant_alternative

struct	variant_alternative< _Index, const _Type >

struct	variant_alternative< _Index, Variant< _Types... > >

struct	variant_alternative< _Index, volatile _Type >

struct	variant_alternative< _Index, volatile const _Type >

struct	variant_size

struct	variant_size< const _Type >

struct	variant_size< const volatile _Type >

struct	variant_size< Variant< _Types... > >

struct	variant_size< volatile _Type >

class	Vector

class	VectorBuffer

class	VectorBuffer< T, 0 >

class	VectorBufferBase

struct	VectorComparer

struct	VectorComparer< false, T >

struct	VectorComparer< true, T >

struct	VectorCopier

struct	VectorCopier< false, T >

struct	VectorCopier< true, T >

struct	VectorDestructor

struct	VectorDestructor< false, T >

struct	VectorDestructor< true, T >

struct	VectorFiller

struct	VectorFiller< false, T >

struct	VectorFiller< true, T >

struct	VectorInitializer

struct	VectorInitializer< false, ignore, T >

struct	VectorInitializer< true, false, T >

struct	VectorInitializer< true, true, T >

struct	VectorMover

struct	VectorMover< false, T >

struct	VectorMover< true, T >

struct	VectorTraits

struct	VectorTraits< AtomicString >

struct	VectorTraits< JSC::Identifier >

struct	VectorTraits< JSC::Instruction >

struct	VectorTraits< JSC::Local< T > >

struct	VectorTraits< JSC::Register >

struct	VectorTraits< JSC::RegisterID >

struct	VectorTraits< JSC::Strong< T > >

struct	VectorTraits< JSC::Weak< T > >

struct	VectorTraits< Ref< P > >

struct	VectorTraits< RefPtr< P > >

struct	VectorTraits< std::pair< First, Second > >

struct	VectorTraits< std::unique_ptr< P > >

struct	VectorTraits< String >

struct	VectorTraits< WebCore::CSSProperty >

struct	VectorTraits< WebCore::HTMLConstructionSiteTask >

struct	VectorTraits< WebCore::RenderGeometryMapStep >

struct	VectorTraits< WebCore::RuleData >

struct	VectorTraitsBase

struct	VectorTraitsBase< false, T >

struct	VectorTraitsBase< true, T >

struct	VectorTypeOperations

struct	Visitor

struct	Visitor< A >

class	WallTime

class	WeakPtr

class	WeakPtrFactory

class	WeakRandom

class	WeakReference

class	Win32Handle

class	WordLock

struct	WordLockBase

class	WorkQueue

class	WTFThreadData

Typedefs
typedef size_t	ConsumeDependency

typedef Checked< int8_t, RecordOverflow >	CheckedInt8

typedef Checked< uint8_t, RecordOverflow >	CheckedUint8

typedef Checked< int16_t, RecordOverflow >	CheckedInt16

typedef Checked< uint16_t, RecordOverflow >	CheckedUint16

typedef Checked< int32_t, RecordOverflow >	CheckedInt32

typedef Checked< uint32_t, RecordOverflow >	CheckedUint32

typedef Checked< int64_t, RecordOverflow >	CheckedInt64

typedef Checked< uint64_t, RecordOverflow >	CheckedUint64

typedef Checked< size_t, RecordOverflow >	CheckedSize

typedef ConditionBase	StaticCondition

template<typename T >
using	DeprecatedOptional = WTF::Optional< T >

typedef char	DtoaBuffer[80]

typedef char	NumberToStringBuffer[NumberToStringBufferLength]

typedef LChar	NumberToLStringBuffer[NumberToStringBufferLength]

typedef unsigned long long	AllocAlignmentInteger

typedef LockAlgorithm< uint8_t, 1, 2 >	DefaultLockAlgorithm

typedef LockBase	StaticLock

typedef Locker< LockBase >	LockHolder

typedef uint32_t	ThreadIdentifier

typedef std::function< void(Critical, Synchronous)>	LowMemoryHandler

typedef Locker< NoLock >	NoLockLocker

typedef HashSet< RefPtr< SchedulePair >, SchedulePairHash >	SchedulePairHashSet

typedef uintptr_t	MachineWord

typedef bool(*	CharacterMatchFunctionPtr) (UChar)

typedef bool(*	IsWhiteSpaceFunctionPtr) (UChar)

using	CharacterMatchFunction = bool(*)(UChar)

typedef NullTextBreakIterator	TextBreakIteratorPlatform

typedef void(*	ThreadFunction) (void *argument)

typedef void *	PlatformMutex

typedef void *	PlatformCondition

typedef Locker< Mutex >	MutexLocker

using	in_place_t = in_place_tag(&)(__in_place_private &)

template<class _Type >
using	in_place_type_t = in_place_tag(&)(__in_place_private::__type_holder< _Type > &)

template<size_t _Index>
using	in_place_index_t = in_place_tag(&)(__in_place_private::__value_holder< _Index > &)

template<size_t _Index, typename _Type >
using	variant_alternative_t = typename variant_alternative< _Index, _Type >::type

typedef WordLockBase	StaticWordLock

typedef Locker< WordLockBase >	WordLockHolder

typedef void(*	AtomicStringTableDestructor) (AtomicStringTable *)

typedef HashCountedSet< const char , PtrHash< const char > >	ReasonSet

using	StringTableImpl = HashSet< StringImpl * >

typedef HashTranslatorCharBuffer< UChar >	UCharBuffer

typedef HashTranslatorCharBuffer< LChar >	LCharBuffer

typedef HashTranslatorCharBuffer< char >	CharBuffer

Enumerations
enum	CheckedState { CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow }

enum	ResultOverflowedTag { ResultOverflowed, ResultOverflowed, ResultOverflowed }

enum	ClockType { ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic }

enum	TimeType { UTCTime = 0, LocalTime, UTCTime = 0, LocalTime, UTCTime = 0, LocalTime }

enum	RoundingSignificantFiguresType { RoundingSignificantFigures, RoundingSignificantFigures, RoundingSignificantFigures }

enum	RoundingDecimalPlacesType { RoundingDecimalPlaces, RoundingDecimalPlaces, RoundingDecimalPlaces }

enum	HashTableDeletedValueType { HashTableDeletedValue, HashTableDeletedValue, HashTableDeletedValue }

enum	HashTableEmptyValueType { HashTableEmptyValue, HashTableEmptyValue, HashTableEmptyValue }

enum	GraphVisitOrder : uint8_t { GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post }

enum	HashItemKnownGoodTag { HashItemKnownGood, HashItemKnownGood, HashItemKnownGood }

enum	HexConversionMode { Lowercase, Uppercase, Lowercase, Uppercase, Lowercase, Uppercase }

enum	NoLockingNecessaryTag { NoLockingNecessary, NoLockingNecessary, NoLockingNecessary }

enum	GCThreadType { GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper }

enum	MemoryUsagePolicy { MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic }

enum	Critical { Critical::No, Critical::Yes, Critical::No, Critical::Yes, Critical::No, Critical::Yes }

enum	Synchronous { Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes }

enum	MessageQueueWaitResult { MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived }

enum	RefCounterEvent { RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment }

enum	SentinelTag { Sentinel, Sentinel, Sentinel }

enum	CheckMoveParameterTag { CheckMoveParameter, CheckMoveParameter, CheckMoveParameter }

enum	BinarySearchMode { KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent }

enum	Base64EncodePolicy { Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy }

enum	Base64DecodeOptions { Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1 }

enum	ConversionMode { LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD }

enum	UTextProviderContext { UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext }

enum	PositiveOrNegativeNumber { PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber }

enum	TextCaseSensitivity { TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive }

enum	LineBreakIteratorMode { LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict }

enum	TrailingZerosTruncatingPolicy { KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros }

enum	CanBeGCThread { CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True }

enum	TriState { FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState }

enum	CheckedState { CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow }

enum	ResultOverflowedTag { ResultOverflowed, ResultOverflowed, ResultOverflowed }

enum	ClockType { ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic }

enum	TimeType { UTCTime = 0, LocalTime, UTCTime = 0, LocalTime, UTCTime = 0, LocalTime }

enum	RoundingSignificantFiguresType { RoundingSignificantFigures, RoundingSignificantFigures, RoundingSignificantFigures }

enum	RoundingDecimalPlacesType { RoundingDecimalPlaces, RoundingDecimalPlaces, RoundingDecimalPlaces }

enum	HashTableDeletedValueType { HashTableDeletedValue, HashTableDeletedValue, HashTableDeletedValue }

enum	HashTableEmptyValueType { HashTableEmptyValue, HashTableEmptyValue, HashTableEmptyValue }

enum	GraphVisitOrder : uint8_t { GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post }

enum	HashItemKnownGoodTag { HashItemKnownGood, HashItemKnownGood, HashItemKnownGood }

enum	HexConversionMode { Lowercase, Uppercase, Lowercase, Uppercase, Lowercase, Uppercase }

enum	NoLockingNecessaryTag { NoLockingNecessary, NoLockingNecessary, NoLockingNecessary }

enum	GCThreadType { GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper }

enum	MemoryUsagePolicy { MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic }

enum	Critical { Critical::No, Critical::Yes, Critical::No, Critical::Yes, Critical::No, Critical::Yes }

enum	Synchronous { Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes }

enum	MessageQueueWaitResult { MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived }

enum	RefCounterEvent { RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment }

enum	SentinelTag { Sentinel, Sentinel, Sentinel }

enum	CheckMoveParameterTag { CheckMoveParameter, CheckMoveParameter, CheckMoveParameter }

enum	BinarySearchMode { KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent }

enum	Base64EncodePolicy { Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy }

enum	Base64DecodeOptions { Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1 }

enum	ConversionMode { LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD }

enum	UTextProviderContext { UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext }

enum	PositiveOrNegativeNumber { PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber }

enum	TextCaseSensitivity { TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive }

enum	LineBreakIteratorMode { LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict }

enum	TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk }

enum	TrailingZerosTruncatingPolicy { KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros }

enum	CanBeGCThread { CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True }

enum	TriState { FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState }

enum	CheckedState { CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow, CheckedState::DidOverflow, CheckedState::DidNotOverflow }

enum	ResultOverflowedTag { ResultOverflowed, ResultOverflowed, ResultOverflowed }

enum	ClockType { ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic, ClockType::Wall, ClockType::Monotonic }

enum	TimeType { UTCTime = 0, LocalTime, UTCTime = 0, LocalTime, UTCTime = 0, LocalTime }

enum	RoundingSignificantFiguresType { RoundingSignificantFigures, RoundingSignificantFigures, RoundingSignificantFigures }

enum	RoundingDecimalPlacesType { RoundingDecimalPlaces, RoundingDecimalPlaces, RoundingDecimalPlaces }

enum	HashTableDeletedValueType { HashTableDeletedValue, HashTableDeletedValue, HashTableDeletedValue }

enum	HashTableEmptyValueType { HashTableEmptyValue, HashTableEmptyValue, HashTableEmptyValue }

enum	GraphVisitOrder : uint8_t { GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post, GraphVisitOrder::Pre, GraphVisitOrder::Post }

enum	HashItemKnownGoodTag { HashItemKnownGood, HashItemKnownGood, HashItemKnownGood }

enum	HexConversionMode { Lowercase, Uppercase, Lowercase, Uppercase, Lowercase, Uppercase }

enum	NoLockingNecessaryTag { NoLockingNecessary, NoLockingNecessary, NoLockingNecessary }

enum	GCThreadType { GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper, GCThreadType::Main, GCThreadType::Helper }

enum	MemoryUsagePolicy { MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic, MemoryUsagePolicy::Unrestricted, MemoryUsagePolicy::Conservative, MemoryUsagePolicy::Strict, MemoryUsagePolicy::Panic }

enum	Critical { Critical::No, Critical::Yes, Critical::No, Critical::Yes, Critical::No, Critical::Yes }

enum	Synchronous { Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes, Synchronous::No, Synchronous::Yes }

enum	MessageQueueWaitResult { MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived, MessageQueueTerminated, MessageQueueTimeout, MessageQueueMessageReceived }

enum	RefCounterEvent { RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment, RefCounterEvent::Decrement, RefCounterEvent::Increment }

enum	SentinelTag { Sentinel, Sentinel, Sentinel }

enum	CheckMoveParameterTag { CheckMoveParameter, CheckMoveParameter, CheckMoveParameter }

enum	BinarySearchMode { KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent, KeyMustBePresentInArray, KeyMightNotBePresentInArray, ReturnAdjacentElementIfKeyIsNotPresent }

enum	Base64EncodePolicy { Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy, Base64DoNotInsertLFs, Base64InsertLFs, Base64URLPolicy }

enum	Base64DecodeOptions { Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1, Base64Default = 0, Base64ValidatePadding = 1 << 0, Base64IgnoreSpacesAndNewLines = 1 << 1 }

enum	ConversionMode { LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD, LenientConversion, StrictConversion, StrictConversionReplacingUnpairedSurrogatesWithFFFD }

enum	UTextProviderContext { UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext, UTextProviderContext::NoContext, UTextProviderContext::PriorContext, UTextProviderContext::PrimaryContext }

enum	PositiveOrNegativeNumber { PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber, PositiveNumber, NegativeNumber }

enum	TextCaseSensitivity { TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive, TextCaseSensitive, TextCaseInsensitive }

enum	LineBreakIteratorMode { LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict, LineBreakIteratorMode::Default, LineBreakIteratorMode::Loose, LineBreakIteratorMode::Normal, LineBreakIteratorMode::Strict }

enum	TrailingZerosTruncatingPolicy { KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros, KeepTrailingZeros, TruncateTrailingZeros }

enum	CanBeGCThread { CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True, CanBeGCThread::False, CanBeGCThread::True }

enum	TriState { FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState, FalseTriState, TrueTriState, MixedTriState }

Functions
JS_EXPORT_PRIVATE void	printInternal (PrintStream &, JSC::B3::Air::Opcode)

void	printInternal (PrintStream &out, JSC::ArrayBufferSharingMode mode)

void	printInternal (PrintStream &, JSC::CallMode)

void	printInternal (PrintStream &, JSC::CodeSpecializationKind)

void	printInternal (PrintStream &, JSC::CodeType)

void	printInternal (PrintStream &out, JSC::CollectionScope)

void	printInternal (PrintStream &, JSC::CollectorPhase)

void	printInternal (PrintStream &, JSC::CompilationResult)

void	printInternal (PrintStream &, JSC::ConstantMode)

void	printInternal (PrintStream &out, JSC::ConstraintVolatility volatility)

void	printInternal (PrintStream &, JSC::DataFormat)

void	printInternal (PrintStream &, JSC::DestructionMode)

void	printInternal (PrintStream &, JSC::DFG::CapabilityLevel)

void	printInternal (PrintStream &, JSC::DFG::CompilationMode)

void	printInternal (PrintStream &, JSC::ErrorType)

void	printInternal (PrintStream &, JSC::ExceptionEventLocation)

void	printInternal (PrintStream &, JSC::ExitingJITType)

void	printInternal (PrintStream &, JSC::ExitKind)

void	printInternal (PrintStream &out, JSC::FPRReg reg)

void	printInternal (PrintStream &, JSC::GCConductor)

void	printInternal (PrintStream &, JSC::GCLogging::Level)

void	printInternal (PrintStream &out, JSC::GPRReg reg)

void	printInternal (PrintStream &, JSC::HeapCell::Kind)

void	printInternal (PrintStream &, JSC::InferredType::Kind)

void	printInternal (PrintStream &, JSC::InlineCallFrame::Kind)

void	printInternal (PrintStream &, JSC::JITCode::JITType)

JS_EXPORT_PRIVATE void	printInternal (PrintStream &, JSC::TypedArrayMode)

void	printInternal (PrintStream &out, JSC::MarkedBlock::Handle::SweepMode)

void	printInternal (PrintStream &, JSC::MutatorState)

void	printInternal (PrintStream &out, JSC::ParserError::SyntaxErrorType type)

void	printInternal (PrintStream &out, JSC::ParserError::ErrorType type)

void	printInternal (PrintStream &, JSC::Profiler::CompilationKind)

void	printInternal (PrintStream &, JSC::Profiler::JettisonReason)

void	printInternal (PrintStream &, JSC::PropertyCondition::Kind)

void	printInternal (PrintStream &, JSC::PutByIdFlags)

void	printInternal (PrintStream &, JSC::TagRegistersMode)

void	printInternal (PrintStream &, JSC::ToThisStatus)

void	printInternal (PrintStream &, JSC::TypedArrayType)

void	printInternal (PrintStream &out, JSC::TypeofType)

void	printInternal (PrintStream &, JSC::VarKind)

template<typename CharacterType >
bool	isASCII (CharacterType)

template<typename CharacterType >
bool	isASCIIAlpha (CharacterType)

template<typename CharacterType >
bool	isASCIIAlphanumeric (CharacterType)

template<typename CharacterType >
bool	isASCIIBinaryDigit (CharacterType)

template<typename CharacterType >
bool	isASCIIDigit (CharacterType)

template<typename CharacterType >
bool	isASCIIHexDigit (CharacterType)

template<typename CharacterType >
bool	isASCIILower (CharacterType)

template<typename CharacterType >
bool	isASCIIOctalDigit (CharacterType)

template<typename CharacterType >
bool	isASCIIPrintable (CharacterType)

template<typename CharacterType >
bool	isASCIISpace (CharacterType)

template<typename CharacterType >
bool	isASCIIUpper (CharacterType)

template<typename CharacterType >
CharacterType	toASCIILower (CharacterType)

template<typename CharacterType >
CharacterType	toASCIIUpper (CharacterType)

template<typename CharacterType >
uint8_t	toASCIIHexValue (CharacterType)

template<typename CharacterType >
uint8_t	toASCIIHexValue (CharacterType firstCharacter, CharacterType secondCharacter)

char	lowerNibbleToASCIIHexDigit (uint8_t)

char	upperNibbleToASCIIHexDigit (uint8_t)

char	lowerNibbleToLowercaseASCIIHexDigit (uint8_t)

char	upperNibbleToLowercaseASCIIHexDigit (uint8_t)

template<typename CharacterType >
bool	isASCIIAlphaCaselessEqual (CharacterType, char expectedASCIILowercaseLetter)

template<typename CharacterType >
CharacterType	toASCIILowerUnchecked (CharacterType)

template<>
char	toASCIILower (char character)

template<>
LChar	toASCIILower (LChar character)

template<typename T >
T	atomicLoad (T *location, std::memory_order order=std::memory_order_seq_cst)

template<typename T >
void	atomicStore (T *location, T newValue, std::memory_order order=std::memory_order_seq_cst)

template<typename T >
bool	atomicCompareExchangeWeak (T *location, T expected, T newValue, std::memory_order order=std::memory_order_seq_cst)

template<typename T >
bool	atomicCompareExchangeWeakRelaxed (T *location, T expected, T newValue)

template<typename T >
T	atomicCompareExchangeStrong (T *location, T expected, T newValue, std::memory_order order=std::memory_order_seq_cst)

template<typename T , typename U >
T	atomicExchangeAdd (T *location, U operand, std::memory_order order=std::memory_order_seq_cst)

template<typename T , typename U >
T	atomicExchangeAnd (T *location, U operand, std::memory_order order=std::memory_order_seq_cst)

template<typename T , typename U >
T	atomicExchangeOr (T *location, U operand, std::memory_order order=std::memory_order_seq_cst)

template<typename T , typename U >
T	atomicExchangeSub (T *location, U operand, std::memory_order order=std::memory_order_seq_cst)

template<typename T , typename U >
T	atomicExchangeXor (T *location, U operand, std::memory_order order=std::memory_order_seq_cst)

template<typename T >
T	atomicExchange (T *location, T newValue, std::memory_order order=std::memory_order_seq_cst)

void	compilerFence ()

void	loadLoadFence ()

void	loadStoreFence ()

void	storeLoadFence ()

void	storeStoreFence ()

void	memoryBarrierAfterLock ()

void	memoryBarrierBeforeUnlock ()

void	crossModifyingCodeFence ()

template<typename T , typename std::enable_if< sizeof(T)==8 >::type * = nullptr>
ALWAYS_INLINE ConsumeDependency	zeroWithConsumeDependency (T value)

template<typename T >
ALWAYS_INLINE auto	consumeLoad (const T *location)

template<typename ElementType , typename KeyType , typename HashArg , typename KeyGetterFunctor >
void	toHashMap (Bag< ElementType > &bag, KeyGetterFunctor &getKey, HashMap< KeyType, ElementType *, HashArg > &result)

template<typename R , typename... Args>
BlockPtr< R(Args...)>	makeBlockPtr (R(^ block)(Args...))

template<typename IteratorType , typename LessThan >
void	bubbleSort (IteratorType begin, IteratorType end, const LessThan &lessThan)

template<typename IteratorType >
void	bubbleSort (IteratorType begin, IteratorType end)

	DECLARE_CF_TYPE_TRAIT (CFArray)

	DECLARE_CF_TYPE_TRAIT (CFBoolean)

	DECLARE_CF_TYPE_TRAIT (CFData)

	DECLARE_CF_TYPE_TRAIT (CFDictionary)

	DECLARE_CF_TYPE_TRAIT (CFNumber)

	DECLARE_CF_TYPE_TRAIT (CFString)

template<typename T >
T	dynamic_cf_cast (CFTypeRef object)

template<typename T >
T	checked_cf_cast (CFTypeRef object)

template<typename T , typename U >
Checked< T, RecordOverflow >	checkedSum (U value)

template<typename T , typename U , typename... Args>
Checked< T, RecordOverflow >	checkedSum (U value, Args... args)

template<typename T , typename... Args>
bool	sumOverflows (Args... args)

template<typename T , typename U >
bool	differenceOverflows (U left, U right)

template<typename T , typename U >
Checked< T, RecordOverflow >	checkedProduct (U value)

template<typename T , typename U , typename... Args>
Checked< T, RecordOverflow >	checkedProduct (U value, Args... args)

template<typename T , typename... Args>
bool	productOverflows (Args... args)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, ClockType)

WTF_EXPORT_PRIVATE bool	exchangeIsCompilationThread (bool newValue)

template<typename T >
T	crossThreadCopy (const T &t)

template<typename F , typename ArgsTuple , size_t... ArgsIndex>
void	callFunctionForCrossThreadTaskImpl (F function, ArgsTuple &&args, std::index_sequence< ArgsIndex... >)

template<typename F , typename ArgsTuple , typename ArgsIndices = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>
void	callFunctionForCrossThreadTask (F function, ArgsTuple &&args)

template<typename... Parameters, typename... Arguments>
CrossThreadTask	createCrossThreadTask (void(*method)(Parameters...), const Arguments &... arguments)

template<typename C , typename MF , typename ArgsTuple , size_t... ArgsIndex>
void	callMemberFunctionForCrossThreadTaskImpl (C *object, MF function, ArgsTuple &&args, std::index_sequence< ArgsIndex... >)

template<typename C , typename MF , typename ArgsTuple , typename ArgsIndicies = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>
void	callMemberFunctionForCrossThreadTask (C *object, MF function, ArgsTuple &&args)

template<typename T , typename... Parameters, typename... Arguments>
CrossThreadTask	createCrossThreadTask (T &callee, void(T::*method)(Parameters...), const Arguments &... arguments)

WTF_EXPORT_PRIVATE uint32_t	cryptographicallyRandomNumber ()

WTF_EXPORT_PRIVATE void	cryptographicallyRandomValues (void *buffer, size_t length)

WTF_EXPORT_PRIVATE int	constantTimeMemcmp (const void , const void , size_t length)

WTF_EXPORT_PRIVATE double	currentTime ()

double	currentTimeMS ()

WTF_EXPORT_PRIVATE double	monotonicallyIncreasingTime ()

double	monotonicallyIncreasingTimeMS ()

WTF_EXPORT_PRIVATE std::chrono::microseconds	currentCPUTime ()

WTF_EXPORT_PRIVATE void	sleep (double)

void	sleepMS (double value)

WTF_EXPORT_PRIVATE PrintStream &	dataFile ()

WTF_EXPORT_PRIVATE void	setDataFile (const char *path)

WTF_EXPORT_PRIVATE void	dataLogFV (const char *format, va_list) WTF_ATTRIBUTE_PRINTF(1

WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void	dataLogF (const char *format,...) WTF_ATTRIBUTE_PRINTF(1

WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void	dataLogFString (const char *)

template<typename... Types>
void	dataLog (const Types &... values)

template<typename... Types>
void	dataLogLn (const Types &... values)

template<typename... Types>
void	dataLogIf (bool shouldLog, const Types &... values)

template<typename... Types>
void	dataLogLnIf (bool shouldLog, const Types &... values)

void	initializeDates ()

int	equivalentYearForDST (int year)

WTF_EXPORT_PRIVATE double	parseES5DateFromNullTerminatedCharacters (const char *dateString)

WTF_EXPORT_PRIVATE double	parseDateFromNullTerminatedCharacters (const char *dateString)

WTF_EXPORT_PRIVATE double	parseDateFromNullTerminatedCharacters (const char *dateString, bool &haveTZ, int &offset)

WTF_EXPORT_PRIVATE double	timeClip (double)

String	makeRFC2822DateString (unsigned dayOfWeek, unsigned day, unsigned month, unsigned year, unsigned hours, unsigned minutes, unsigned seconds, int utcOffset)

double	jsCurrentTime ()

WTF_EXPORT_PRIVATE bool	isLeapYear (int year)

WTF_EXPORT_PRIVATE double	dateToDaysFrom1970 (int year, int month, int day)

WTF_EXPORT_PRIVATE int	msToYear (double ms)

WTF_EXPORT_PRIVATE double	msToDays (double ms)

WTF_EXPORT_PRIVATE int	msToMinutes (double ms)

WTF_EXPORT_PRIVATE int	msToHours (double ms)

WTF_EXPORT_PRIVATE int	dayInYear (int year, int month, int day)

WTF_EXPORT_PRIVATE int	dayInYear (double ms, int year)

WTF_EXPORT_PRIVATE int	monthFromDayInYear (int dayInYear, bool leapYear)

WTF_EXPORT_PRIVATE int	dayInMonthFromDayInYear (int dayInYear, bool leapYear)

WTF_EXPORT_PRIVATE LocalTimeOffset	calculateLocalTimeOffset (double utcInMilliseconds, TimeType=UTCTime)

WTF_EXPORT_PRIVATE void	dtoa (DtoaBuffer result, double dd, bool &sign, int &exponent, unsigned &precision)

WTF_EXPORT_PRIVATE void	dtoaRoundSF (DtoaBuffer result, double dd, int ndigits, bool &sign, int &exponent, unsigned &precision)

WTF_EXPORT_PRIVATE void	dtoaRoundDP (DtoaBuffer result, double dd, int ndigits, bool &sign, int &exponent, unsigned &precision)

WTF_EXPORT_PRIVATE const char *	numberToString (double, NumberToStringBuffer)

WTF_EXPORT_PRIVATE const char *	numberToFixedPrecisionString (double, unsigned significantFigures, NumberToStringBuffer, bool truncateTrailingZeros=false)

WTF_EXPORT_PRIVATE const char *	numberToFixedWidthString (double, unsigned decimalPlaces, NumberToStringBuffer)

double	parseDouble (const LChar *string, size_t length, size_t &parsedLength)

double	parseDouble (const UChar *string, size_t length, size_t &parsedLength)

double	parseDouble (StringView, size_t &parsedLength)

template<typename E , typename T >
constexpr auto	isValidEnum (T t) -> std::enable_if_t< std::is_enum< E >::value, bool >

template<class E >
constexpr bool	operator== (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr bool	operator!= (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr bool	operator< (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr bool	operator> (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr bool	operator<= (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr bool	operator>= (const UnexpectedType< E > &lhs, const UnexpectedType< E > &rhs)

template<class E >
constexpr UnexpectedType< std::decay_t< E > >	makeUnexpected (E &&v)

template<class T , class E >
constexpr bool	operator== (const Expected< T, E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator!= (const Expected< T, E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator< (const Expected< T, E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator> (const Expected< T, E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator<= (const Expected< T, E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator>= (const Expected< T, E > &x, const Expected< T, E > &y)

template<class E >
constexpr bool	operator== (const Expected< void, E > &x, const Expected< void, E > &y)

template<class E >
constexpr bool	operator< (const Expected< void, E > &x, const Expected< void, E > &y)

template<class T , class E >
constexpr bool	operator== (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator== (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator!= (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator!= (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator< (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator< (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator<= (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator<= (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator> (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator> (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator>= (const Expected< T, E > &x, const T &y)

template<class T , class E >
constexpr bool	operator>= (const T &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator== (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator== (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator!= (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator!= (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator< (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator< (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator<= (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator<= (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator> (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator> (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<class T , class E >
constexpr bool	operator>= (const Expected< T, E > &x, const UnexpectedType< E > &y)

template<class T , class E >
constexpr bool	operator>= (const UnexpectedType< E > &x, const Expected< T, E > &y)

template<typename T , typename E >
void	swap (Expected< T, E > &x, Expected< T, E > &y)

template<class T , class E = std::nullopt_t>
constexpr Expected< std::decay_t< T >, E >	makeExpected (T &&v)

template<class T , class E >
constexpr Expected< T, std::decay_t< E > >	makeExpectedFromError (E &&e)

template<class T , class E , class U >
constexpr Expected< T, E >	makeExpectedFromError (U &&u)

Expected< void, std::nullopt_t >	makeExpected ()

size_t	fastBitVectorArrayLength (size_t numBits)

WTF_EXPORT_PRIVATE void	fastSetMaxSingleAllocationSize (size_t)

WTF_EXPORT_PRIVATE bool	isFastMallocEnabled ()

WTF_EXPORT_PRIVATE void *	fastMalloc (size_t) RETURNS_NONNULL

WTF_EXPORT_PRIVATE void *	fastZeroedMalloc (size_t) RETURNS_NONNULL

WTF_EXPORT_PRIVATE void *	fastCalloc (size_t numElements, size_t elementSize) RETURNS_NONNULL

WTF_EXPORT_PRIVATE void *	fastRealloc (void *, size_t) RETURNS_NONNULL

WTF_EXPORT_PRIVATE char *	fastStrDup (const char *) RETURNS_NONNULL

WTF_EXPORT_PRIVATE TryMallocReturnValue	tryFastMalloc (size_t)

TryMallocReturnValue	tryFastZeroedMalloc (size_t)

WTF_EXPORT_PRIVATE TryMallocReturnValue	tryFastCalloc (size_t numElements, size_t elementSize)

WTF_EXPORT_PRIVATE void	fastFree (void *)

WTF_EXPORT_PRIVATE void *	fastAlignedMalloc (size_t alignment, size_t) RETURNS_NONNULL

WTF_EXPORT_PRIVATE void *	tryFastAlignedMalloc (size_t alignment, size_t)

WTF_EXPORT_PRIVATE void	fastAlignedFree (void *)

WTF_EXPORT_PRIVATE size_t	fastMallocSize (const void *)

WTF_EXPORT_PRIVATE size_t	fastMallocGoodSize (size_t)

WTF_EXPORT_PRIVATE void	releaseFastMallocFreeMemory ()

WTF_EXPORT_PRIVATE void	releaseFastMallocFreeMemoryForThisThread ()

WTF_EXPORT_PRIVATE FastMallocStatistics	fastMallocStatistics ()

bool	needToFlipBytesIfLittleEndian (bool littleEndian)

uint16_t	flipBytes (uint16_t value)

uint32_t	flipBytes (uint32_t value)

uint64_t	flipBytes (uint64_t value)

template<typename T >
T	flipBytes (T value)

template<typename T >
T	flipBytesIfLittleEndian (T value, bool littleEndian)

template<typename T >
T *	getPtr (T *p)

template<typename T >
GetPtrHelper< T >::PtrType	getPtr (T &p)

template<typename T >
GetPtrHelper< T >::PtrType	getPtr (const T &p)

template<typename Value , typename HashFunctions , typename Traits , typename VectorType >
void	copyToVector (const HashCountedSet< Value, HashFunctions, Traits > &collection, VectorType &vector)

template<typename Value , typename HashFunctions , typename Traits >
void	copyToVector (const HashCountedSet< Value, HashFunctions, Traits > &collection, Vector< Value > &vector)

unsigned	intHash (uint8_t key8)

unsigned	intHash (uint16_t key16)

unsigned	intHash (uint32_t key)

unsigned	intHash (uint64_t key)

unsigned	pairIntHash (unsigned key1, unsigned key2)

template<typename T , typename U , typename V >
bool	operator== (const HashTableConstKeysIterator< T, U, V > &a, const HashTableConstKeysIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator!= (const HashTableConstKeysIterator< T, U, V > &a, const HashTableConstKeysIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator== (const HashTableConstValuesIterator< T, U, V > &a, const HashTableConstValuesIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator!= (const HashTableConstValuesIterator< T, U, V > &a, const HashTableConstValuesIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator== (const HashTableKeysIterator< T, U, V > &a, const HashTableKeysIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator!= (const HashTableKeysIterator< T, U, V > &a, const HashTableKeysIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator== (const HashTableValuesIterator< T, U, V > &a, const HashTableValuesIterator< T, U, V > &b)

template<typename T , typename U , typename V >
bool	operator!= (const HashTableValuesIterator< T, U, V > &a, const HashTableValuesIterator< T, U, V > &b)

template<typename T , typename U , typename V , typename W , typename X >
bool	operator== (const HashMap< T, U, V, W, X > &a, const HashMap< T, U, V, W, X > &b)

template<typename T , typename U , typename V , typename W , typename X >
bool	operator!= (const HashMap< T, U, V, W, X > &a, const HashMap< T, U, V, W, X > &b)

template<typename T , typename U , typename V , typename W , typename X , typename Y >
void	copyToVector (const HashMap< T, U, V, W, X > &collection, Y &vector)

template<typename T , typename U , typename V , typename W , typename X , typename Y >
void	copyKeysToVector (const HashMap< T, U, V, W, X > &collection, Y &vector)

template<typename T , typename U , typename V , typename W , typename X , typename Y >
void	copyValuesToVector (const HashMap< T, U, V, W, X > &collection, Y &vector)

template<typename C , typename W >
void	copyToVector (const C &collection, W &vector)

template<typename Key , typename Value , typename Extractor , typename HashFunctions , typename Traits , typename KeyTraits >
void	addIterator (const HashTable< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > , HashTableConstIterator< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > )

template<typename Key , typename Value , typename Extractor , typename HashFunctions , typename Traits , typename KeyTraits >
void	removeIterator (HashTableConstIterator< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > *)

unsigned	doubleHash (unsigned key)

template<typename T , typename U >
bool	operator== (const HashTableConstIteratorAdapter< T, U > &a, const HashTableConstIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator!= (const HashTableConstIteratorAdapter< T, U > &a, const HashTableConstIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator== (const HashTableIteratorAdapter< T, U > &a, const HashTableIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator!= (const HashTableIteratorAdapter< T, U > &a, const HashTableIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator== (const HashTableConstIteratorAdapter< T, U > &a, const HashTableIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator!= (const HashTableConstIteratorAdapter< T, U > &a, const HashTableIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator== (const HashTableIteratorAdapter< T, U > &a, const HashTableConstIteratorAdapter< T, U > &b)

template<typename T , typename U >
bool	operator!= (const HashTableIteratorAdapter< T, U > &a, const HashTableConstIteratorAdapter< T, U > &b)

template<typename Traits , typename T >
bool	isHashTraitsEmptyValue (const T &value)

template<typename Traits , typename T >
std::enable_if< HashTraitHasCustomDelete< Traits, T >::value >::type	hashTraitsDeleteBucket (T &value)

template<typename Traits , typename T >
std::enable_if<!HashTraitHasCustomDelete< Traits, T >::value >::type	hashTraitsDeleteBucket (T &value)

template<typename T >
void	appendByteAsHex (unsigned char byte, T &destination, HexConversionMode mode=Uppercase)

template<typename T >
void	placeByteAsHexCompressIfPossible (unsigned char byte, T &destination, unsigned &index, HexConversionMode mode=Uppercase)

template<typename T >
void	placeByteAsHex (unsigned char byte, T &destination, HexConversionMode mode=Uppercase)

template<typename T >
void	appendUnsignedAsHex (unsigned number, T &destination, HexConversionMode mode=Uppercase)

template<typename T >
void	appendUnsigned64AsHex (uint64_t number, T &destination, HexConversionMode mode=Uppercase)

template<typename T >
void	appendUnsignedAsHexFixedSize (unsigned number, T &destination, unsigned desiredDigits, HexConversionMode mode=Uppercase)

template<typename TargetVectorType , typename InsertionVectorType >
size_t	executeInsertions (TargetVectorType &target, InsertionVectorType &insertions)

template<typename Predicate , typename Iterator >
FilterIterator< Predicate, Iterator >	makeFilterIterator (Predicate &&pred, Iterator &&begin, Iterator &&end)

template<typename Transform , typename Iterator >
TransformIterator< Transform, Iterator >	makeTransformIterator (Transform &&transform, Iterator &&iter)

template<typename Iterator >
IteratorRange< Iterator >	makeIteratorRange (Iterator &&begin, Iterator &&end)

template<typename T >
ListDump< T >	listDump (const T &list, const char *comma=", ")

template<typename T >
PointerListDump< T >	pointerListDump (const T &list, const char *comma=", ")

template<typename T , typename Comparator >
CString	sortedListDump (const T &list, const Comparator &comparator, const char *comma=", ")

template<typename T >
CString	sortedListDump (const T &list, const char *comma=", ")

template<typename T >
MapDump< T >	mapDump (const T &map, const char arrow="=>", const char comma=", ")

template<typename T , typename Comparator >
CString	sortedMapDump (const T &map, const Comparator &comparator, const char arrow="=>", const char comma=", ")

template<typename T , typename U >
ListDumpInContext< T, U >	listDumpInContext (const T &list, U context, const char comma=", ")

template<typename LockType >
Locker< LockType >	holdLock (LockType &lock)

template<typename LockType >
Locker< LockType >	tryHoldLock (LockType &lock)

WTF_EXPORT_PRIVATE void	resetAccumulatedLogs ()

WTF_EXPORT_PRIVATE String	getAndResetAccumulatedLogs ()

WTF_EXPORT_PRIVATE void	initializeMainThread ()

WTF_EXPORT_PRIVATE void	callOnMainThread (Function< void()> &&)

WTF_EXPORT_PRIVATE void	setMainThreadCallbacksPaused (bool paused)

WTF_EXPORT_PRIVATE bool	isMainThread ()

WTF_EXPORT_PRIVATE bool	canAccessThreadLocalDataForThread (ThreadIdentifier)

bool	isWebThread ()

bool	isUIThread ()

WTF_EXPORT_PRIVATE void	initializeGCThreads ()

void	printInternal (PrintStream &, GCThreadType)

WTF_EXPORT_PRIVATE void	registerGCThread (GCThreadType)

WTF_EXPORT_PRIVATE std::optional< GCThreadType >	mayBeGCThread ()

WTF_EXPORT_PRIVATE bool	isMainThreadOrGCThread ()

void	initializeMainThreadPlatform ()

void	scheduleDispatchFunctionsOnMainThread ()

void	dispatchFunctionsFromMainThread ()

template<typename U >
MallocPtr< U >	adoptMallocPtr (U *ptr)

uint32_t	roundUpToPowerOfTwo (uint32_t v)

unsigned	fastLog2 (unsigned i)

unsigned	fastLog2 (uint64_t value)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	safeFPDivision (T u, T v)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, bool >::type	areEssentiallyEqual (T u, T v, T epsilon=std::numeric_limits< T >::epsilon())

template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	nanPropagatingMin (T a, T b)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	nanPropagatingMax (T a, T b)

bool	isIntegral (float value)

template<typename T >
void	incrementWithSaturation (T &value)

template<typename T >
T	leftShiftWithSaturation (T value, unsigned shiftAmount, T max=std::numeric_limits< T >::max())

template<typename T >
bool	nonEmptyRangesOverlap (T leftMin, T leftMax, T rightMin, T rightMax)

template<typename T >
bool	rangesOverlap (T leftMin, T leftMax, T rightMin, T rightMax)

MediaTime	operator* (int32_t lhs, const MediaTime &rhs)

WTF_EXPORT_PRIVATE MediaTime	abs (const MediaTime &rhs)

WTF_EXPORT_PRIVATE std::optional< size_t >	memoryFootprint ()

template<class T >
void	swap (NakedPtr< T > &a, NakedPtr< T > &b)

WTF_EXPORT_PRIVATE int	numberOfProcessorCores ()

template<class OptionalType , class Callback >
ALWAYS_INLINE auto	valueOrCompute (OptionalType optional, Callback callback) -> typename OptionalType::value_type

template<typename T >
OSObjectPtr< T >	adoptOSObject (T)

void	cryptographicallyRandomValuesFromOS (unsigned char *buffer, size_t length)

WTF_EXPORT_PRIVATE size_t	pageSize ()

WTF_EXPORT_PRIVATE size_t	pageMask ()

bool	isPageAligned (void *address)

bool	isPageAligned (size_t size)

bool	isPowerOfTwo (size_t size)

template<typename T >
ALWAYS_INLINE void	refIfNotNull (T *ptr)

template<typename T >
ALWAYS_INLINE void	derefIfNotNull (T *ptr)

template<typename T , typename U >
bool	operator== (const PassRefPtr< T > &a, const PassRefPtr< U > &b)

template<typename T , typename U >
bool	operator== (const PassRefPtr< T > &a, const RefPtr< U > &b)

template<typename T , typename U >
bool	operator== (const RefPtr< T > &a, const PassRefPtr< U > &b)

template<typename T , typename U >
bool	operator== (const PassRefPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator== (T *a, const PassRefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const PassRefPtr< T > &a, const PassRefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const PassRefPtr< T > &a, const RefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const RefPtr< T > &a, const PassRefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const PassRefPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator!= (T *a, const PassRefPtr< U > &b)

template<typename V , typename U >
PassRefPtr< V >	static_pointer_cast (const PassRefPtr< U > &p)

WTF_EXPORT_PRIVATE void	setPlatformUserPreferredLanguagesChangedCallback (void(*)())

WTF_EXPORT_PRIVATE Vector< String >	platformUserPreferredLanguages ()

template<typename T >
bool	arePointingToEqualData (const T &a, const T &b)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, const char *)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, const StringView &)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, const CString &)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, const String &)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, const StringImpl *)

void	printInternal (PrintStream &out, const AtomicStringImpl *value)

void	printInternal (PrintStream &out, const UniquedStringImpl *value)

void	printInternal (PrintStream &out, const UniquedStringImpl &value)

void	printInternal (PrintStream &out, char *value)

void	printInternal (PrintStream &out, CString &value)

void	printInternal (PrintStream &out, String &value)

void	printInternal (PrintStream &out, StringImpl *value)

void	printInternal (PrintStream &out, AtomicStringImpl *value)

void	printInternal (PrintStream &out, UniquedStringImpl *value)

void	printInternal (PrintStream &out, UniquedStringImpl &value)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, bool)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, signed char)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, unsigned char)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, short)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, int)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, long)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, unsigned long long)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, float)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, double)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, RawPointer)

template<typename T >
void	printInternal (PrintStream &out, const T &value)

WTF_EXPORT_PRIVATE void	dumpCharacter (PrintStream &, char)

	MAKE_PRINT_ADAPTOR (CharacterDump, char, dumpCharacter)

template<typename T >
PointerDump< T >	pointerDump (const T *ptr)

template<typename T >
void	printInternal (PrintStream &out, const std::unique_ptr< T > &value)

template<typename T >
void	printInternal (PrintStream &out, const RefPtr< T > &value)

template<typename T , typename U >
ValueInContext< T, U >	inContext (const T &value, U *context)

template<typename T , typename U >
PointerDumpInContext< T, U >	pointerDumpInContext (const T ptr, U context)

template<typename T , typename U >
ValueIgnoringContext< T, U >	ignoringContext (const U &value)

template<typename... Types>
FormatImpl< Types... >	format (Types... values)

template<typename T >
void	printInternal (PrintStream &out, const std::optional< T > &value)

int	getCurrentProcessID ()

WTF_EXPORT_PRIVATE size_t	ramSize ()

WTF_EXPORT_PRIVATE double	randomNumber ()

void	initializeRandomNumberGenerator ()

void	adopted (const void *)

template<typename T >
Ref< T >	adoptRef (T &)

template<typename T , typename U >
Ref< T >	static_reference_cast (Ref< U > &reference)

template<typename T , typename U >
Ref< T >	static_reference_cast (Ref< U > &&reference)

template<typename T , typename U >
Ref< T >	static_reference_cast (const Ref< U > &reference)

template<typename T >
Ref< T >	makeRef (T &reference)

template<typename ExpectedType , typename ArgType >
bool	is (Ref< ArgType > &source)

template<typename ExpectedType , typename ArgType >
bool	is (const Ref< ArgType > &source)

void	adopted (RefCountedBase *object)

template<typename T >
RefPtr< T >	adoptRef (T *)

template<class T >
void	swap (RefPtr< T > &a, RefPtr< T > &b)

template<typename T , typename U >
bool	operator== (const RefPtr< T > &a, const RefPtr< U > &b)

template<typename T , typename U >
bool	operator== (const RefPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator== (T *a, const RefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const RefPtr< T > &a, const RefPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const RefPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator!= (T *a, const RefPtr< U > &b)

template<typename T , typename U >
RefPtr< T >	static_pointer_cast (const RefPtr< U > &p)

template<typename T >
RefPtr< T >	makeRefPtr (T *pointer)

template<typename T >
RefPtr< T >	makeRefPtr (T &reference)

template<typename ExitFunction >
ScopeExit< ExitFunction >	makeScopeExit (ExitFunction &&exitFunction)

template<typename FunctionType , typename Functor >
ScopedLambdaFunctor< FunctionType, Functor >	scopedLambda (const Functor &functor)

template<typename FunctionType , typename Functor >
ScopedLambdaFunctor< FunctionType, Functor >	scopedLambda (Functor &&functor)

template<typename FunctionType , typename Functor >
ScopedLambdaRefFunctor< FunctionType, Functor >	scopedLambdaRef (const Functor &functor)

WTF_EXPORT_PRIVATE void	sleep (Seconds)

template<typename FunctionType , typename Functor >
Ref< SharedTask< FunctionType > >	createSharedTask (const Functor &functor)

template<typename FunctionType , typename Functor >
Ref< SharedTask< FunctionType > >	createSharedTask (Functor &&functor)

WTF_EXPORT_PRIVATE unsigned	sixCharacterHashStringToInteger (const char *)

WTF_EXPORT_PRIVATE std::array< char, 7 >	integerToSixCharacterHashString (unsigned)

bool	isPointerAligned (void *p)

bool	is8ByteAligned (void *p)

template<typename ToType , typename FromType >
ToType	bitwise_cast (FromType from)

template<typename ToType , typename FromType >
ToType	safeCast (FromType value)

size_t	bitCount (unsigned bits)

size_t	bitCount (uint64_t bits)

template<typename T , size_t Size>
char(&	ArrayLengthHelperFunction (T(&)[Size]))[Size]

ALWAYS_INLINE constexpr size_t	roundUpToMultipleOfImpl0 (size_t remainderMask, size_t x)

ALWAYS_INLINE constexpr size_t	roundUpToMultipleOfImpl (size_t divisor, size_t x)

size_t	roundUpToMultipleOf (size_t divisor, size_t x)

template<size_t divisor>
constexpr size_t	roundUpToMultipleOf (size_t x)

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey , BinarySearchMode mode>
ArrayElementType *	binarySearchImpl (ArrayType &array, size_t size, KeyType key, const ExtractKey &extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	binarySearch (ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	tryBinarySearch (ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	approximateBinarySearch (ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	binarySearch (const ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	tryBinarySearch (const ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >
ArrayElementType *	approximateBinarySearch (const ArrayType &array, size_t size, KeyType key, ExtractKey extractKey=ExtractKey())

template<typename VectorType , typename ElementType >
void	insertIntoBoundedVector (VectorType &vector, size_t size, const ElementType &element, size_t index)

WTF_EXPORT_PRIVATE bool	isCompilationThread ()

template<typename Func >
bool	isStatelessLambda ()

template<typename ResultType , typename Func , typename... ArgumentTypes>
ResultType	callStatelessLambda (ArgumentTypes &&... arguments)

template<typename T , typename U >
bool	checkAndSet (T &left, U right)

template<typename T >
bool	findBitInWord (T word, size_t &index, size_t endIndex, bool value)

template<class... F>
Visitor< F... >	makeVisitor (F... f)

template<typename... Types>
CString	toCString (const Types &... values)

template<typename... Types>
String	toString (const Types &... values)

template<uintptr_t mask>
bool	isAlignedTo (const void *pointer)

bool	isAlignedToMachineWord (const void *pointer)

template<typename T >
T *	alignToMachineWord (T *pointer)

template<typename CharacterType >
bool	isAllASCII (MachineWord word)

template<typename CharacterType >
bool	charactersAreAllASCII (const CharacterType *characters, size_t length)

void	copyLCharsFromUCharSource (LChar destination, const UChar source, size_t length)

bool	operator== (const AtomicString &a, const AtomicString &b)

bool	operator== (const AtomicString &, const LChar *)

bool	operator== (const AtomicString &a, const char *b)

bool	operator== (const AtomicString &a, const Vector< UChar > &b)

bool	operator== (const AtomicString &a, const String &b)

bool	operator== (const LChar *a, const AtomicString &b)

bool	operator== (const String &a, const AtomicString &b)

bool	operator== (const Vector< UChar > &a, const AtomicString &b)

bool	operator!= (const AtomicString &a, const AtomicString &b)

bool	operator!= (const AtomicString &a, const LChar *b)

bool	operator!= (const AtomicString &a, const char *b)

bool	operator!= (const AtomicString &a, const String &b)

bool	operator!= (const AtomicString &a, const Vector< UChar > &b)

bool	operator!= (const LChar *a, const AtomicString &b)

bool	operator!= (const String &a, const AtomicString &b)

bool	operator!= (const Vector< UChar > &a, const AtomicString &b)

bool	equalIgnoringASCIICase (const AtomicString &, const AtomicString &)

bool	equalIgnoringASCIICase (const AtomicString &, const String &)

bool	equalIgnoringASCIICase (const String &, const AtomicString &)

bool	equalIgnoringASCIICase (const AtomicString &, const char *)

template<unsigned length>
bool	equalLettersIgnoringASCIICase (const AtomicString &, const char(&lowercaseLetters)[length])

WTF_EXPORT_PRIVATE void	base64Encode (const void *, unsigned, Vector< char > &, Base64EncodePolicy=Base64DoNotInsertLFs)

void	base64Encode (ConstSignedOrUnsignedCharVectorAdapter, Vector< char > &, Base64EncodePolicy=Base64DoNotInsertLFs)

void	base64Encode (const CString &, Vector< char > &, Base64EncodePolicy=Base64DoNotInsertLFs)

WTF_EXPORT_PRIVATE String	base64Encode (const void *, unsigned, Base64EncodePolicy=Base64DoNotInsertLFs)

String	base64Encode (ConstSignedOrUnsignedCharVectorAdapter, Base64EncodePolicy=Base64DoNotInsertLFs)

String	base64Encode (const CString &, Base64EncodePolicy=Base64DoNotInsertLFs)

WTF_EXPORT_PRIVATE bool	base64Decode (const String &, SignedOrUnsignedCharVectorAdapter, unsigned options=Base64Default)

WTF_EXPORT_PRIVATE bool	base64Decode (const Vector< char > &, SignedOrUnsignedCharVectorAdapter, unsigned options=Base64Default)

WTF_EXPORT_PRIVATE bool	base64Decode (const char *, unsigned, SignedOrUnsignedCharVectorAdapter, unsigned options=Base64Default)

WTF_EXPORT_PRIVATE void	base64URLEncode (const void *, unsigned, Vector< char > &)

void	base64URLEncode (ConstSignedOrUnsignedCharVectorAdapter, Vector< char > &)

void	base64URLEncode (const CString &, Vector< char > &)

WTF_EXPORT_PRIVATE String	base64URLEncode (const void *, unsigned)

String	base64URLEncode (ConstSignedOrUnsignedCharVectorAdapter)

String	base64URLEncode (const CString &)

WTF_EXPORT_PRIVATE bool	base64URLDecode (const String &, SignedOrUnsignedCharVectorAdapter)

WTF_EXPORT_PRIVATE bool	base64URLDecode (const Vector< char > &, SignedOrUnsignedCharVectorAdapter)

WTF_EXPORT_PRIVATE bool	base64URLDecode (const char *, unsigned, SignedOrUnsignedCharVectorAdapter)

WTF_EXPORT_PRIVATE bool	operator== (const CString &a, const CString &b)

bool	operator!= (const CString &a, const CString &b)

WTF_EXPORT_PRIVATE bool	operator== (const CString &a, const char *b)

bool	operator!= (const CString &a, const char *b)

WTF_EXPORT_PRIVATE bool	operator< (const CString &a, const CString &b)

UTextProviderContext	uTextProviderContext (const UText *text, int64_t nativeIndex, UBool forward)

void	initializeContextAwareUTextProvider (UText text, const UTextFuncs funcs, const void string, unsigned length, const UChar priorContext, int priorContextLength)

UText *	uTextCloneImpl (UText destination, const UText source, UBool deep, UErrorCode *status)

int64_t	uTextAccessPinIndex (int64_t &index, int64_t limit)

bool	uTextAccessInChunkOrOutOfRange (UText *text, int64_t nativeIndex, int64_t nativeLength, UBool forward, UBool &isAccessible)

WTF_EXPORT UText *	openLatin1UTextProvider (UTextWithBuffer utWithBuffer, const LChar string, unsigned length, UErrorCode *status)

UText *	openLatin1ContextAwareUTextProvider (UTextWithBuffer utWithBuffer, const LChar string, unsigned length, const UChar priorContext, int priorContextLength, UErrorCode status)

UText *	openUTF16ContextAwareUTextProvider (UText , const UChar , unsigned length, const UChar priorContext, int priorContextLength, UErrorCode )

template<typename T , typename SignedIntegerType >
IntegerToStringConversionTrait< T >::ReturnType	numberToStringSigned (SignedIntegerType number, typename IntegerToStringConversionTrait< T >::AdditionalArgumentType *additionalArgument=nullptr)

template<typename T , typename UnsignedIntegerType >
IntegerToStringConversionTrait< T >::ReturnType	numberToStringUnsigned (UnsignedIntegerType number, typename IntegerToStringConversionTrait< T >::AdditionalArgumentType *additionalArgument=nullptr)

template<typename CharacterType , typename SignedIntegerType >
void	writeNumberToBufferSigned (SignedIntegerType number, CharacterType *destination)

template<typename CharacterType , typename UnsignedIntegerType >
void	writeNumberToBufferUnsigned (UnsignedIntegerType number, CharacterType *destination)

template<typename SignedIntegerType >
unsigned	lengthOfNumberAsStringSigned (SignedIntegerType number)

template<typename UnsignedIntegerType >
unsigned	lengthOfNumberAsStringUnsigned (UnsignedIntegerType number)

template<typename CharType >
bool	equal (const StringBuilder &s, const CharType *buffer, unsigned length)

template<typename StringType >
bool	equal (const StringBuilder &a, const StringType &b)

bool	operator== (const StringBuilder &a, const StringBuilder &b)

bool	operator!= (const StringBuilder &a, const StringBuilder &b)

bool	operator== (const StringBuilder &a, const String &b)

bool	operator!= (const StringBuilder &a, const String &b)

bool	operator== (const String &a, const StringBuilder &b)

bool	operator!= (const String &a, const StringBuilder &b)

template<typename CharacterTypeA , typename CharacterTypeB >
bool	equalIgnoringASCIICase (const CharacterTypeA , const CharacterTypeB , unsigned length)

template<typename CharacterTypeA , typename CharacterTypeB >
bool	equalIgnoringASCIICase (const CharacterTypeA , unsigned lengthA, const CharacterTypeB , unsigned lengthB)

template<typename StringClassA , typename StringClassB >
bool	equalIgnoringASCIICaseCommon (const StringClassA &, const StringClassB &)

template<typename CharacterType >
bool	equalLettersIgnoringASCIICase (const CharacterType , const char lowercaseLetters, unsigned length)

template<typename CharacterType , unsigned lowercaseLettersLength>
bool	equalLettersIgnoringASCIICase (const CharacterType *, unsigned charactersLength, const char(&lowercaseLetters)[lowercaseLettersLength])

template<typename StringClass , unsigned length>
bool	equalLettersIgnoringASCIICaseCommon (const StringClass &, const char(&lowercaseLetters)[length])

template<typename T >
T	loadUnaligned (const char *s)

ALWAYS_INLINE bool	equal (const LChar a, const LChar b, unsigned length)

ALWAYS_INLINE bool	equal (const UChar a, const UChar b, unsigned length)

ALWAYS_INLINE bool	equal (const LChar a, const UChar b, unsigned length)

ALWAYS_INLINE bool	equal (const UChar a, const LChar b, unsigned length)

template<typename StringClassA , typename StringClassB >
ALWAYS_INLINE bool	equalCommon (const StringClassA &a, const StringClassB &b)

template<typename StringClassA , typename StringClassB >
ALWAYS_INLINE bool	equalCommon (const StringClassA a, const StringClassB b)

template<typename StringClass , unsigned length>
bool	equal (const StringClass &a, const UChar(&codeUnits)[length])

template<typename StringClassA >
bool	equalIgnoringASCIICaseCommon (const StringClassA &a, const char *b)

template<typename StringClassA , typename StringClassB >
bool	startsWith (const StringClassA &reference, const StringClassB &prefix)

template<typename StringClassA , typename StringClassB >
bool	startsWithIgnoringASCIICase (const StringClassA &reference, const StringClassB &prefix)

template<typename StringClassA , typename StringClassB >
bool	endsWith (const StringClassA &reference, const StringClassB &suffix)

template<typename StringClassA , typename StringClassB >
bool	endsWithIgnoringASCIICase (const StringClassA &reference, const StringClassB &suffix)

template<typename SearchCharacterType , typename MatchCharacterType >
size_t	findIgnoringASCIICase (const SearchCharacterType source, const MatchCharacterType matchCharacters, unsigned startOffset, unsigned searchLength, unsigned matchLength)

template<typename StringClassA , typename StringClassB >
size_t	findIgnoringASCIICase (const StringClassA &source, const StringClassB &stringToFind, unsigned startOffset)

template<typename CharacterType >
size_t	find (const CharacterType *characters, unsigned length, CharacterType matchCharacter, unsigned index=0)

ALWAYS_INLINE size_t	find (const UChar *characters, unsigned length, LChar matchCharacter, unsigned index=0)

size_t	find (const LChar *characters, unsigned length, UChar matchCharacter, unsigned index=0)

template<typename StringClass >
size_t	findCommon (const StringClass &haystack, const StringClass &needle, unsigned start)

template<typename StringClass >
bool	hasPrefixWithLettersIgnoringASCIICaseCommon (const StringClass &string, const char *lowercaseLetters, unsigned length)

template<typename StringClass >
bool	equalLettersIgnoringASCIICaseCommonWithoutLength (const StringClass &string, const char *lowercaseLetters)

template<typename StringClass >
bool	startsWithLettersIgnoringASCIICaseCommonWithoutLength (const StringClass &string, const char *lowercaseLetters)

template<typename StringClass , unsigned length>
bool	startsWithLettersIgnoringASCIICaseCommon (const StringClass &string, const char(&lowercaseLetters)[length])

void	sumWithOverflow (bool &overflow, unsigned &total, unsigned addend)

template<typename... Unsigned>
void	sumWithOverflow (bool &overflow, unsigned &total, unsigned addend, Unsigned ...addends)

template<typename Adapter >
bool	are8Bit (Adapter adapter)

template<typename Adapter , typename... Adapters>
bool	are8Bit (Adapter adapter, Adapters ...adapters)

template<typename ResultType , typename Adapter >
void	makeStringAccumulator (ResultType *result, Adapter adapter)

template<typename ResultType , typename Adapter , typename... Adapters>
void	makeStringAccumulator (ResultType *result, Adapter adapter, Adapters ...adapters)

template<typename StringTypeAdapter , typename... StringTypeAdapters>
String	tryMakeStringFromAdapters (StringTypeAdapter adapter, StringTypeAdapters ...adapters)

template<typename... StringTypes>
String	tryMakeString (StringTypes ...strings)

template<typename StringType >
String	makeString (StringType string)

template<typename... StringTypes>
String	makeString (StringTypes... strings)

WTF_EXPORT_STRING_API bool	equal (const StringImpl , const StringImpl )

WTF_EXPORT_STRING_API bool	equal (const StringImpl , const LChar )

bool	equal (const StringImpl a, const char b)

WTF_EXPORT_STRING_API bool	equal (const StringImpl , const LChar , unsigned)

WTF_EXPORT_STRING_API bool	equal (const StringImpl , const UChar , unsigned)

bool	equal (const StringImpl a, const char b, unsigned length)

bool	equal (const LChar a, StringImpl b)

bool	equal (const char a, StringImpl b)

WTF_EXPORT_STRING_API bool	equal (const StringImpl &a, const StringImpl &b)

WTF_EXPORT_STRING_API bool	equalIgnoringNullity (StringImpl , StringImpl )

WTF_EXPORT_STRING_API bool	equalIgnoringNullity (const UChar , size_t length, StringImpl )

bool	equalIgnoringASCIICase (const StringImpl &, const StringImpl &)

WTF_EXPORT_STRING_API bool	equalIgnoringASCIICase (const StringImpl , const StringImpl )

bool	equalIgnoringASCIICase (const StringImpl &, const char *)

bool	equalIgnoringASCIICase (const StringImpl , const char )

WTF_EXPORT_STRING_API bool	equalIgnoringASCIICaseNonNull (const StringImpl , const StringImpl )

template<unsigned length>
bool	equalLettersIgnoringASCIICase (const StringImpl &, const char(&lowercaseLetters)[length])

template<unsigned length>
bool	equalLettersIgnoringASCIICase (const StringImpl *, const char(&lowercaseLetters)[length])

size_t	find (const LChar *characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index=0)

size_t	find (const UChar *characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index=0)

template<typename CharacterType >
size_t	reverseFindLineTerminator (const CharacterType *characters, unsigned length, unsigned index=UINT_MAX)

template<typename CharacterType >
size_t	reverseFind (const CharacterType *characters, unsigned length, CharacterType matchCharacter, unsigned index=UINT_MAX)

ALWAYS_INLINE size_t	reverseFind (const UChar *characters, unsigned length, LChar matchCharacter, unsigned index=UINT_MAX)

size_t	reverseFind (const LChar *characters, unsigned length, UChar matchCharacter, unsigned index=UINT_MAX)

template<size_t inlineCapacity>
bool	equalIgnoringNullity (const Vector< UChar, inlineCapacity > &a, StringImpl *b)

template<typename CharacterType1 , typename CharacterType2 >
int	codePointCompare (unsigned l1, unsigned l2, const CharacterType1 c1, const CharacterType2 c2)

int	codePointCompare8 (const StringImpl string1, const StringImpl string2)

int	codePointCompare16 (const StringImpl string1, const StringImpl string2)

int	codePointCompare8To16 (const StringImpl string1, const StringImpl string2)

int	codePointCompare (const StringImpl string1, const StringImpl string2)

bool	isSpaceOrNewline (UChar c)

template<typename CharacterType >
unsigned	lengthOfNullTerminatedString (const CharacterType *string)

template<unsigned length>
bool	startsWithLettersIgnoringASCIICase (const StringImpl &string, const char(&lowercaseLetters)[length])

template<unsigned length>
bool	startsWithLettersIgnoringASCIICase (const StringImpl *string, const char(&lowercaseLetters)[length])

StringAppend< const char *, String >	operator+ (const char *string1, const String &string2)

StringAppend< const char *, AtomicString >	operator+ (const char *string1, const AtomicString &string2)

template<typename U , typename V >
StringAppend< const char *, StringAppend< U, V > >	operator+ (const char *string1, const StringAppend< U, V > &string2)

StringAppend< const UChar *, String >	operator+ (const UChar *string1, const String &string2)

StringAppend< const UChar *, AtomicString >	operator+ (const UChar *string1, const AtomicString &string2)

template<typename U , typename V >
StringAppend< const UChar *, StringAppend< U, V > >	operator+ (const UChar *string1, const StringAppend< U, V > &string2)

StringAppend< ASCIILiteral, String >	operator+ (const ASCIILiteral &string1, const String &string2)

StringAppend< ASCIILiteral, AtomicString >	operator+ (const ASCIILiteral &string1, const AtomicString &string2)

template<typename U , typename V >
StringAppend< ASCIILiteral, StringAppend< U, V > >	operator+ (const ASCIILiteral &string1, const StringAppend< U, V > &string2)

template<typename T >
StringAppend< String, T >	operator+ (const String &string1, T string2)

template<typename U , typename V , typename W >
StringAppend< StringAppend< U, V >, W >	operator+ (const StringAppend< U, V > &string1, W string2)

template<typename CharacterType , size_t inlineCapacity>
void	append (Vector< CharacterType, inlineCapacity > &, StringView)

bool	equal (StringView, StringView)

bool	equal (StringView, const LChar *)

bool	equal (StringView, const char *)

bool	equalIgnoringASCIICase (StringView, StringView)

bool	equalIgnoringASCIICase (StringView, const char *)

template<unsigned length>
bool	equalLettersIgnoringASCIICase (StringView, const char(&lowercaseLetters)[length])

bool	operator== (StringView a, StringView b)

bool	operator== (StringView a, const LChar *b)

bool	operator== (StringView a, const char *b)

bool	operator== (const LChar *a, StringView b)

bool	operator== (const char *a, StringView b)

bool	operator!= (StringView a, StringView b)

bool	operator!= (StringView a, const LChar *b)

bool	operator!= (StringView a, const char *b)

bool	operator!= (const LChar *a, StringView b)

bool	operator!= (const char *a, StringView b)

WTF_EXPORT_PRIVATE UBreakIterator *	wordBreakIterator (StringView)

WTF_EXPORT_PRIVATE UBreakIterator *	sentenceBreakIterator (StringView)

WTF_EXPORT_PRIVATE UBreakIterator *	acquireLineBreakIterator (StringView, const AtomicString &locale, const UChar *priorContext, unsigned priorContextLength, LineBreakIteratorMode)

WTF_EXPORT_PRIVATE void	releaseLineBreakIterator (UBreakIterator *)

UBreakIterator *	openLineBreakIterator (const AtomicString &locale)

void	closeLineBreakIterator (UBreakIterator *&)

WTF_EXPORT_PRIVATE bool	isWordTextBreak (UBreakIterator *)

WTF_EXPORT_PRIVATE unsigned	numGraphemeClusters (StringView)

WTF_EXPORT_PRIVATE unsigned	numCharactersInGraphemeClusters (StringView, unsigned)

WTF_EXPORT_PRIVATE const char *	currentSearchLocaleID ()

WTF_EXPORT_PRIVATE const char *	currentTextBreakLocaleID ()

WTF_EXPORT_STRING_API int	charactersToIntStrict (const LChar , size_t, bool ok=nullptr, int base=10)

WTF_EXPORT_STRING_API int	charactersToIntStrict (const UChar , size_t, bool ok=nullptr, int base=10)

WTF_EXPORT_STRING_API unsigned	charactersToUIntStrict (const LChar , size_t, bool ok=nullptr, int base=10)

WTF_EXPORT_STRING_API unsigned	charactersToUIntStrict (const UChar , size_t, bool ok=nullptr, int base=10)

int64_t	charactersToInt64Strict (const LChar , size_t, bool ok=nullptr, int base=10)

int64_t	charactersToInt64Strict (const UChar , size_t, bool ok=nullptr, int base=10)

uint64_t	charactersToUInt64Strict (const LChar , size_t, bool ok=nullptr, int base=10)

uint64_t	charactersToUInt64Strict (const UChar , size_t, bool ok=nullptr, int base=10)

intptr_t	charactersToIntPtrStrict (const LChar , size_t, bool ok=nullptr, int base=10)

intptr_t	charactersToIntPtrStrict (const UChar , size_t, bool ok=nullptr, int base=10)

WTF_EXPORT_STRING_API int	charactersToInt (const LChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API int	charactersToInt (const UChar , size_t, bool ok=nullptr)

unsigned	charactersToUInt (const LChar , size_t, bool ok=nullptr)

unsigned	charactersToUInt (const UChar , size_t, bool ok=nullptr)

int64_t	charactersToInt64 (const LChar , size_t, bool ok=nullptr)

int64_t	charactersToInt64 (const UChar , size_t, bool ok=nullptr)

uint64_t	charactersToUInt64 (const LChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API uint64_t	charactersToUInt64 (const UChar , size_t, bool ok=nullptr)

intptr_t	charactersToIntPtr (const LChar , size_t, bool ok=nullptr)

intptr_t	charactersToIntPtr (const UChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API double	charactersToDouble (const LChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API double	charactersToDouble (const UChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API float	charactersToFloat (const LChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API float	charactersToFloat (const UChar , size_t, bool ok=nullptr)

WTF_EXPORT_STRING_API float	charactersToFloat (const LChar *, size_t, size_t &parsedLength)

WTF_EXPORT_STRING_API float	charactersToFloat (const UChar *, size_t, size_t &parsedLength)

template<bool isSpecialCharacter, typename CharacterType >
bool	isAllSpecialCharacters (const CharacterType *, size_t)

bool	operator== (const String &a, const String &b)

bool	operator== (const String &a, const LChar *b)

bool	operator== (const String &a, const char *b)

bool	operator== (const LChar *a, const String &b)

bool	operator== (const char *a, const String &b)

template<size_t inlineCapacity>
bool	operator== (const Vector< char, inlineCapacity > &a, const String &b)

template<size_t inlineCapacity>
bool	operator== (const String &a, const Vector< char, inlineCapacity > &b)

bool	operator!= (const String &a, const String &b)

bool	operator!= (const String &a, const LChar *b)

bool	operator!= (const String &a, const char *b)

bool	operator!= (const LChar *a, const String &b)

bool	operator!= (const char *a, const String &b)

template<size_t inlineCapacity>
bool	operator!= (const Vector< char, inlineCapacity > &a, const String &b)

template<size_t inlineCapacity>
bool	operator!= (const String &a, const Vector< char, inlineCapacity > &b)

bool	equalIgnoringASCIICase (const String &, const String &)

bool	equalIgnoringASCIICase (const String &, const char *)

template<unsigned length>
bool	equalLettersIgnoringASCIICase (const String &, const char(&lowercaseLetters)[length])

template<unsigned length>
bool	startsWithLettersIgnoringASCIICase (const String &, const char(&lowercaseLetters)[length])

bool	equalIgnoringNullity (const String &a, const String &b)

template<size_t inlineCapacity>
bool	equalIgnoringNullity (const Vector< UChar, inlineCapacity > &a, const String &b)

bool	operator! (const String &str)

void	swap (String &a, String &b)

WTF_EXPORT_STRING_API int	codePointCompare (const String &, const String &)

bool	codePointCompareLessThan (const String &a, const String &b)

template<typename CharacterType >
void	appendNumber (Vector< CharacterType > &vector, unsigned char number)

WTF_EXPORT_STRING_API const String &	emptyString ()

WTF_EXPORT_PRIVATE void	initializeThreading ()

WTF_EXPORT_PRIVATE ThreadIdentifier	createThread (const char *threadName, std::function< void()>)

WTF_EXPORT_PRIVATE void	setCurrentThreadIsUserInteractive (int relativePriority=0)

WTF_EXPORT_PRIVATE void	setCurrentThreadIsUserInitiated (int relativePriority=0)

WTF_EXPORT_PRIVATE ThreadIdentifier	currentThread ()

WTF_EXPORT_PRIVATE void	changeThreadPriority (ThreadIdentifier, int)

WTF_EXPORT_PRIVATE int	waitForThreadCompletion (ThreadIdentifier)

WTF_EXPORT_PRIVATE void	detachThread (ThreadIdentifier)

WTF_EXPORT_PRIVATE ThreadIdentifier	createThread (ThreadFunction, void , const char threadName)

ThreadIdentifier	createThreadInternal (ThreadFunction, void , const char threadName)

void	initializeCurrentThreadInternal (const char *threadName)

const char *	normalizeThreadName (const char *threadName)

WTF_EXPORT_PRIVATE void	sleep (const TimeWithDynamicClockType &)

WTF_EXPORT_PRIVATE bool	hasElapsed (const TimeWithDynamicClockType &)

TriState	triState (bool boolean)

template<typename ExpectedType , typename ArgType >
bool	is (ArgType &source)

template<typename ExpectedType , typename ArgType >
bool	is (ArgType *source)

template<typename Target , typename Source >
match_constness< Source, Target >::type &	downcast (Source &source)

template<typename Target , typename Source >
match_constness< Source, Target >::type *	downcast (Source *source)

WTF_EXPORT_PRIVATE UCharIterator	createIterator (StringView)

template<typename T , class... Args>
UniqueRef< T >	makeUniqueRef (Args &&... args)

bool	setCloseOnExec (int fileDescriptor)

int	dupCloseOnExec (int fileDescriptor)

int	closeWithRetry (int fileDescriptor)

in_place_tag	in_place (__in_place_private &)

template<class _Type >
in_place_tag	in_place (__in_place_private::__type_holder< _Type > &)

template<size_t _Index>
in_place_tag	in_place (__in_place_private::__value_holder< _Index > &)

template<typename T >
NO_RETURN_DUE_TO_CRASH T	__throw_bad_variant_access (const char *what_arg)

template<typename _Type , typename ... _Types>
constexpr _Type &	get (Variant< _Types... > &)

template<typename _Type , typename ... _Types>
constexpr _Type const &	get (Variant< _Types... > const &)

template<typename _Type , typename ... _Types>
constexpr _Type &&	get (Variant< _Types... > &&)

template<typename _Type , typename ... _Types>
constexpr const _Type &&	get (Variant< _Types... > const &&)

template<ptrdiff_t _Index, typename ... _Types>
constexpr __indexed_type< _Index, _Types... >::__type &	get (Variant< _Types... > &)

template<ptrdiff_t _Index, typename ... _Types>
constexpr __indexed_type< _Index, _Types... >::__type &&	get (Variant< _Types... > &&)

template<ptrdiff_t _Index, typename ... _Types>
constexpr __indexed_type< _Index, _Types... >::__type const &	get (Variant< _Types... > const &)

template<ptrdiff_t _Index, typename... _Types>
constexpr const __indexed_type< _Index, _Types... >::__type &&	get (Variant< _Types... > const &&)

template<typename _Type , typename ... _Types>
constexpr std::add_pointer_t< _Type >	get_if (Variant< _Types... > &)

template<typename _Type , typename ... _Types>
constexpr std::add_pointer_t< _Type const >	get_if (Variant< _Types... > const &)

template<ptrdiff_t _Index, typename ... _Types>
constexpr std::add_pointer_t< typename __indexed_type< _Index, _Types... >::__type >	get_if (Variant< _Types... > &)

template<ptrdiff_t _Index, typename ... _Types>
constexpr std::add_pointer_t< typename __indexed_type< _Index, _Types... >::__type const >	get_if (Variant< _Types... > const &)

template<typename... _Types>
std::enable_if< __all_swappable< _Types... >::value &&__all_move_constructible< _Types... >::value, void >::type	swap (Variant< _Types... > &__lhs, Variant< _Types... > &__rhs) __NOEXCEPT_(__noexcept_variant_swap< _Types... >

template<typename _Type , typename ... _Types>
constexpr bool	holds_alternative (Variant< _Types... > const &__v) __NOEXCEPT

template<typename _Visitor , typename ... _Types>
constexpr __visitor_return_type< _Visitor, _Types... >::__type	visit (_Visitor &&__visitor, Variant< _Types... > &__v)

template<size_t _Index, typename ... _Args>
constexpr __arg_selector_t< _Index, _Args... >::__type &&	__arg_selector (_Args &&... __args)

template<typename _Visitor , typename ... _Variants>
constexpr __multi_visitor_return_type< _Visitor, _Variants... >::__type	visit (_Visitor &&__visitor, _Variants &&... __v)

template<typename ... _Types>
constexpr bool	operator== (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

template<typename ... _Types>
constexpr bool	operator!= (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

template<typename ... _Types>
constexpr bool	operator< (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

template<typename ... _Types>
constexpr bool	operator> (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

template<typename ... _Types>
constexpr bool	operator>= (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

template<typename ... _Types>
constexpr bool	operator<= (Variant< _Types... > const &__lhs, Variant< _Types... > const &__rhs)

constexpr bool	operator== (Monostate const &, Monostate const &)

constexpr bool	operator!= (Monostate const &, Monostate const &)

constexpr bool	operator>= (Monostate const &, Monostate const &)

constexpr bool	operator<= (Monostate const &, Monostate const &)

constexpr bool	operator> (Monostate const &, Monostate const &)

constexpr bool	operator< (Monostate const &, Monostate const &)

template<class V , class... F>
auto	switchOn (V &&v, F &&... f) -> decltype(visit(makeVisitor(std::forward< F >(f)...), std::forward< V >(v)))

bool	typelessPointersAreEqual (const void a, const void b)

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>
void	swap (Vector< T, inlineCapacity, OverflowHandler, minCapacity > &a, Vector< T, inlineCapacity, OverflowHandler, minCapacity > &b)

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>
bool	operator== (const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &a, const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &b)

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>
bool	operator!= (const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &a, const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &b)

WTF_EXPORT_PRIVATE void	sleep (WallTime)

template<typename T , typename U >
bool	operator== (const WeakPtr< T > &a, const WeakPtr< U > &b)

template<typename T , typename U >
bool	operator== (const WeakPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator== (T *a, const WeakPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const WeakPtr< T > &a, const WeakPtr< U > &b)

template<typename T , typename U >
bool	operator!= (const WeakPtr< T > &a, U *b)

template<typename T , typename U >
bool	operator!= (T *a, const WeakPtr< U > &b)

template<typename T >
void	deleteObject (T)

template<typename T >
GDIObject< T >	adoptGDIObject (T object)

template<typename T >
void	swap (GDIObject< T > &a, GDIObject< T > &b)

template<>
void	deleteObject< HDC > (HDC hdc)

WTFThreadData &	wtfThreadData ()

void	printInternal (PrintStream &out, const ArithProfile &profile)

void	printInternal (PrintStream &out, const JSC::ObservedType &observedType)

void	printInternal (PrintStream &out, OpcodeID opcode)

void	printInternal (PrintStream &out, JSC::Variable::VariableKind kind)

void	printInternal (PrintStream &out, ICEvent::Kind kind)

template<>
GtkTargetList *	refGPtr (GtkTargetList *ptr)

template<>
void	derefGPtr (GtkTargetList *ptr)

template<>
GtkWidgetPath *	refGPtr (GtkWidgetPath *ptr)

template<>
void	derefGPtr (GtkWidgetPath *ptr)

template<>
SoupBuffer *	refGPtr (SoupBuffer *ptr)

template<>
void	derefGPtr (SoupBuffer *ptr)

	COMPILE_ASSERT ((std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< PassRefPtr< CopierThreadSafeRefCountedTest >>::Type >::value), PassRefPtrTest)

	COMPILE_ASSERT ((std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< RefPtr< CopierThreadSafeRefCountedTest >>::Type >::value), RefPtrTest)

	COMPILE_ASSERT ((std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< CopierThreadSafeRefCountedTest *>::Type >::value), RawPointerTest)

template<bool roundingNone, bool roundingSignificantFigures, bool roundingDecimalPlaces, bool leftright>
void	dtoa (DtoaBuffer result, double dd, int ndigits, bool &signOut, int &exponentOut, unsigned &precisionOut)

void	initializeMainThreadToProcessMainThreadPlatform ()

void	callOnWebThreadOrDispatchAsyncOnMainThread (void(^ block)())

void	printInternal (PrintStream &out, unsigned short value)

void	printInternal (PrintStream &out, long value)

void	printInternal (PrintStream &out, unsigned long value)

WTF_EXPORT_PRIVATE void	printInternal (PrintStream &, unsigned)

template<typename CharType >
bool	equalInternal (const StringImpl a, const CharType b, unsigned length)

WTF_EXPORTDATA	DEFINE_GLOBAL (AtomicString, nullAtom) WTF_EXPORTDATA DEFINE_GLOBAL(AtomicString

WTF_EXPORTDATA emptyAtom WTF_EXPORTDATA	DEFINE_GLOBAL (AtomicString, starAtom) WTF_EXPORTDATA DEFINE_GLOBAL(AtomicString

WTF_EXPORTDATA emptyAtom WTF_EXPORTDATA xmlAtom WTF_EXPORTDATA	DEFINE_GLOBAL (AtomicString, xmlnsAtom) NEVER_INLINE unsigned StringImpl

LRESULT CALLBACK	ThreadingWindowWndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

template<class E >
std::ostream &	operator<< (std::ostream &os, const UnexpectedType< E > &u)

template<class T , class E >
std::ostream &	operator<< (std::ostream &os, const Expected< T, E > &e)

template<class E >
std::ostream &	operator<< (std::ostream &os, const Expected< void, E > &e)

std::ostream &	operator<< (std::ostream &out, const MediaTime &val)

std::basic_ostream< char > &	operator<< (std::basic_ostream< char > &out, Seconds value)

std::basic_ostream< char > &	operator<< (std::basic_ostream< char > &out, WallTime value)

std::basic_ostream< char > &	operator<< (std::basic_ostream< char > &out, MonotonicTime value)

std::basic_ostream< char > &	operator<< (std::basic_ostream< char > &out, TimeWithDynamicClockType value)

std::ostream &	operator<< (std::ostream &os, const String &string)

Variables
const unsigned char	asciiCaseFoldTable [256]

void *	_NSConcreteMallocBlock [32]

template<typename Target , typename Source , bool isTargetBigger = sizeof(Target)>
bool	targetSigned = std::numeric_limits<Target>::is_signed

template<typename Target , typename Source , bool isTargetBigger = sizeof(Target)>
bool bool	sourceSigned = std::numeric_limits<Source>::is_signed> struct BoundsChecker

const char *const	weekdayName [7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" }

const char *const	monthName [12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }

const char *const	monthFullName [12] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }

const double	hoursPerDay = 24.0

const double	minutesPerHour = 60.0

const double	secondsPerMinute = 60.0

const double	msPerSecond = 1000.0

const double	msPerMonth = 2592000000.0

const double	secondsPerHour = secondsPerMinute * minutesPerHour

const double	secondsPerDay = secondsPerHour * hoursPerDay

const double	msPerMinute = msPerSecond * secondsPerMinute

const double	msPerHour = msPerSecond * secondsPerHour

const double	msPerDay = msPerSecond * secondsPerDay

const unsigned	NumberToStringBufferLength = 96

constexpr UnexpectTag	Unexpect { }

WTFLogChannel	LogMemoryPressure = { WTFLogChannelOn, "MemoryPressure", LOG_CHANNEL_WEBKIT_SUBSYSTEM, OS_LOG_DEFAULT }

const uintptr_t	machineWordAlignmentMask = sizeof(MachineWord) - 1

const WTF_EXPORTDATA AtomicString	nullAtom

const WTF_EXPORTDATA AtomicString	emptyAtom

const WTF_EXPORTDATA AtomicString	starAtom

const WTF_EXPORTDATA AtomicString	xmlAtom

const WTF_EXPORTDATA AtomicString	xmlnsAtom

const int	UTextWithBufferInlineCapacity = 16

constexpr size_t	variant_npos =-1

const size_t	notFound = static_cast<size_t>(-1)

const char	nonAlphabet = -1

const LPCWSTR	kThreadingWindowClassName = L"ThreadingWindowClass"

Typedef Documentation

◆ AllocAlignmentInteger

typedef unsigned long long WTF::AllocAlignmentInteger

◆ AtomicStringTableDestructor

typedef void(* WTF::AtomicStringTableDestructor)(AtomicStringTable *)

◆ CharacterMatchFunction

typedef bool(* WTF::CharacterMatchFunction)(UChar)

◆ CharacterMatchFunctionPtr

typedef bool(* WTF::CharacterMatchFunctionPtr)(UChar)

◆ CharBuffer

typedef HashTranslatorCharBuffer<char> WTF::CharBuffer

◆ CheckedInt16

typedef Checked< int16_t, RecordOverflow > WTF::CheckedInt16

◆ CheckedInt32

typedef Checked< int32_t, RecordOverflow > WTF::CheckedInt32

◆ CheckedInt64

typedef Checked< int64_t, RecordOverflow > WTF::CheckedInt64

◆ CheckedInt8

typedef Checked< int8_t, RecordOverflow > WTF::CheckedInt8

◆ CheckedSize

typedef Checked< size_t, RecordOverflow > WTF::CheckedSize

◆ CheckedUint16

typedef Checked< uint16_t, RecordOverflow > WTF::CheckedUint16

◆ CheckedUint32

typedef Checked< uint32_t, RecordOverflow > WTF::CheckedUint32

◆ CheckedUint64

typedef Checked< uint64_t, RecordOverflow > WTF::CheckedUint64

◆ CheckedUint8

typedef Checked< uint8_t, RecordOverflow > WTF::CheckedUint8

◆ ConsumeDependency

typedef size_t WTF::ConsumeDependency

◆ DefaultLockAlgorithm

typedef LockAlgorithm< uint8_t, 1, 2 > WTF::DefaultLockAlgorithm

◆ DeprecatedOptional

template<typename T >

using WTF::DeprecatedOptional = typedef WTF::Optional<T>

◆ DtoaBuffer

typedef char WTF::DtoaBuffer

◆ in_place_index_t

template<size_t _Index>

using WTF::in_place_index_t = typedef in_place_tag(&)(__in_place_private::__value_holder<_Index>&)

◆ in_place_t

using WTF::in_place_t = typedef in_place_tag(&)(__in_place_private&)

◆ in_place_type_t

template<class _Type >

using WTF::in_place_type_t = typedef in_place_tag(&)(__in_place_private::__type_holder<_Type>&)

◆ IsWhiteSpaceFunctionPtr

typedef bool(* WTF::IsWhiteSpaceFunctionPtr)(UChar)

◆ LCharBuffer

typedef HashTranslatorCharBuffer<LChar> WTF::LCharBuffer

◆ LockHolder

typedef Locker< LockBase > WTF::LockHolder

◆ LowMemoryHandler

typedef std::function< void(Critical, Synchronous)> WTF::LowMemoryHandler

◆ MachineWord

typedef uintptr_t WTF::MachineWord

◆ MutexLocker

typedef Locker< Mutex > WTF::MutexLocker

◆ NoLockLocker

typedef Locker< NoLock > WTF::NoLockLocker

◆ NumberToLStringBuffer

typedef LChar WTF::NumberToLStringBuffer

◆ NumberToStringBuffer

typedef char WTF::NumberToStringBuffer

◆ PlatformCondition

typedef void * WTF::PlatformCondition

◆ PlatformMutex

typedef void * WTF::PlatformMutex

◆ ReasonSet

typedef HashCountedSet<const char*, PtrHash<const char*> > WTF::ReasonSet

◆ SchedulePairHashSet

typedef HashSet< RefPtr< SchedulePair >, SchedulePairHash > WTF::SchedulePairHashSet

◆ StaticCondition

typedef ConditionBase WTF::StaticCondition

◆ StaticLock

typedef LockBase WTF::StaticLock

◆ StaticWordLock

typedef WordLockBase WTF::StaticWordLock

◆ StringTableImpl

using WTF::StringTableImpl = typedef HashSet<StringImpl*>

◆ TextBreakIteratorPlatform

typedef NullTextBreakIterator WTF::TextBreakIteratorPlatform

◆ ThreadFunction

typedef void(* WTF::ThreadFunction)(void *argument)

◆ ThreadIdentifier

typedef uint32_t WTF::ThreadIdentifier

◆ UCharBuffer

typedef HashTranslatorCharBuffer<UChar> WTF::UCharBuffer

◆ variant_alternative_t

template<size_t _Index, typename _Type >

using WTF::variant_alternative_t = typedef typename variant_alternative<_Index,_Type>::type

◆ WordLockHolder

typedef Locker< WordLockBase > WTF::WordLockHolder

Enumeration Type Documentation

◆ Base64DecodeOptions [1/3]

enum WTF::Base64DecodeOptions

Enumerator
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines

◆ Base64DecodeOptions [2/3]

enum WTF::Base64DecodeOptions

Enumerator
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines

◆ Base64DecodeOptions [3/3]

enum WTF::Base64DecodeOptions

Enumerator
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines
Base64Default
Base64ValidatePadding
Base64IgnoreSpacesAndNewLines

◆ Base64EncodePolicy [1/3]

enum WTF::Base64EncodePolicy

Enumerator
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy

◆ Base64EncodePolicy [2/3]

enum WTF::Base64EncodePolicy

Enumerator
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy

◆ Base64EncodePolicy [3/3]

enum WTF::Base64EncodePolicy

Enumerator
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy
Base64DoNotInsertLFs
Base64InsertLFs
Base64URLPolicy

◆ BinarySearchMode [1/3]

enum WTF::BinarySearchMode

Enumerator
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent

◆ BinarySearchMode [2/3]

enum WTF::BinarySearchMode

Enumerator
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent

◆ BinarySearchMode [3/3]

enum WTF::BinarySearchMode

Enumerator
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent
KeyMustBePresentInArray
KeyMightNotBePresentInArray
ReturnAdjacentElementIfKeyIsNotPresent

◆ CanBeGCThread [1/3]

enum WTF::CanBeGCThread

strong

Enumerator
False
True
False
True
False
True

◆ CanBeGCThread [2/3]

enum WTF::CanBeGCThread

strong

Enumerator
False
True
False
True
False
True

◆ CanBeGCThread [3/3]

enum WTF::CanBeGCThread

strong

Enumerator
False
True
False
True
False
True

◆ CheckedState [1/3]

enum WTF::CheckedState

strong

Enumerator
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow

◆ CheckedState [2/3]

enum WTF::CheckedState

strong

Enumerator
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow

◆ CheckedState [3/3]

enum WTF::CheckedState

strong

Enumerator
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow
DidOverflow
DidNotOverflow

◆ CheckMoveParameterTag [1/3]

enum WTF::CheckMoveParameterTag

Enumerator
CheckMoveParameter
CheckMoveParameter
CheckMoveParameter

◆ CheckMoveParameterTag [2/3]

enum WTF::CheckMoveParameterTag

Enumerator
CheckMoveParameter
CheckMoveParameter
CheckMoveParameter

◆ CheckMoveParameterTag [3/3]

enum WTF::CheckMoveParameterTag

Enumerator
CheckMoveParameter
CheckMoveParameter
CheckMoveParameter

◆ ClockType [1/3]

enum WTF::ClockType

strong

Enumerator
Wall
Monotonic
Wall
Monotonic
Wall
Monotonic

◆ ClockType [2/3]

enum WTF::ClockType

strong

Enumerator
Wall
Monotonic
Wall
Monotonic
Wall
Monotonic

◆ ClockType [3/3]

enum WTF::ClockType

strong

Enumerator
Wall
Monotonic
Wall
Monotonic
Wall
Monotonic

◆ ConversionMode [1/3]

enum WTF::ConversionMode

Enumerator
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD

◆ ConversionMode [2/3]

enum WTF::ConversionMode

Enumerator
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD

◆ ConversionMode [3/3]

enum WTF::ConversionMode

Enumerator
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD
LenientConversion
StrictConversion
StrictConversionReplacingUnpairedSurrogatesWithFFFD

◆ Critical [1/3]

enum WTF::Critical

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ Critical [2/3]

enum WTF::Critical

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ Critical [3/3]

enum WTF::Critical

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ GCThreadType [1/3]

enum WTF::GCThreadType

strong

Enumerator
Main
Helper
Main
Helper
Main
Helper

◆ GCThreadType [2/3]

enum WTF::GCThreadType

strong

Enumerator
Main
Helper
Main
Helper
Main
Helper

◆ GCThreadType [3/3]

enum WTF::GCThreadType

strong

Enumerator
Main
Helper
Main
Helper
Main
Helper

◆ GraphVisitOrder [1/3]

enum WTF::GraphVisitOrder : uint8_t

strong

Enumerator
Pre
Post
Pre
Post
Pre
Post

◆ GraphVisitOrder [2/3]

enum WTF::GraphVisitOrder : uint8_t

strong

Enumerator
Pre
Post
Pre
Post
Pre
Post

◆ GraphVisitOrder [3/3]

enum WTF::GraphVisitOrder : uint8_t

strong

Enumerator
Pre
Post
Pre
Post
Pre
Post

◆ HashItemKnownGoodTag [1/3]

enum WTF::HashItemKnownGoodTag

Enumerator
HashItemKnownGood
HashItemKnownGood
HashItemKnownGood

◆ HashItemKnownGoodTag [2/3]

enum WTF::HashItemKnownGoodTag

Enumerator
HashItemKnownGood
HashItemKnownGood
HashItemKnownGood

◆ HashItemKnownGoodTag [3/3]

enum WTF::HashItemKnownGoodTag

Enumerator
HashItemKnownGood
HashItemKnownGood
HashItemKnownGood

◆ HashTableDeletedValueType [1/3]

enum WTF::HashTableDeletedValueType

Enumerator
HashTableDeletedValue
HashTableDeletedValue
HashTableDeletedValue

◆ HashTableDeletedValueType [2/3]

enum WTF::HashTableDeletedValueType

Enumerator
HashTableDeletedValue
HashTableDeletedValue
HashTableDeletedValue

◆ HashTableDeletedValueType [3/3]

enum WTF::HashTableDeletedValueType

Enumerator
HashTableDeletedValue
HashTableDeletedValue
HashTableDeletedValue

◆ HashTableEmptyValueType [1/3]

enum WTF::HashTableEmptyValueType

Enumerator
HashTableEmptyValue
HashTableEmptyValue
HashTableEmptyValue

◆ HashTableEmptyValueType [2/3]

enum WTF::HashTableEmptyValueType

Enumerator
HashTableEmptyValue
HashTableEmptyValue
HashTableEmptyValue

◆ HashTableEmptyValueType [3/3]

enum WTF::HashTableEmptyValueType

Enumerator
HashTableEmptyValue
HashTableEmptyValue
HashTableEmptyValue

◆ HexConversionMode [1/3]

enum WTF::HexConversionMode

Enumerator
Lowercase
Uppercase
Lowercase
Uppercase
Lowercase
Uppercase

◆ HexConversionMode [2/3]

enum WTF::HexConversionMode

Enumerator
Lowercase
Uppercase
Lowercase
Uppercase
Lowercase
Uppercase

◆ HexConversionMode [3/3]

enum WTF::HexConversionMode

Enumerator
Lowercase
Uppercase
Lowercase
Uppercase
Lowercase
Uppercase

◆ LineBreakIteratorMode [1/3]

enum WTF::LineBreakIteratorMode

strong

Enumerator
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict

◆ LineBreakIteratorMode [2/3]

enum WTF::LineBreakIteratorMode

strong

Enumerator
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict

◆ LineBreakIteratorMode [3/3]

enum WTF::LineBreakIteratorMode

strong

Enumerator
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict
Default
Loose
Normal
Strict

◆ MemoryUsagePolicy [1/3]

enum WTF::MemoryUsagePolicy

strong

Enumerator
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic

◆ MemoryUsagePolicy [2/3]

enum WTF::MemoryUsagePolicy

strong

Enumerator
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic

◆ MemoryUsagePolicy [3/3]

enum WTF::MemoryUsagePolicy

strong

Enumerator
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic
Unrestricted
Conservative
Strict
Panic

◆ MessageQueueWaitResult [1/3]

enum WTF::MessageQueueWaitResult

Enumerator
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived

◆ MessageQueueWaitResult [2/3]

enum WTF::MessageQueueWaitResult

Enumerator
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived

◆ MessageQueueWaitResult [3/3]

enum WTF::MessageQueueWaitResult

Enumerator
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived
MessageQueueTerminated
MessageQueueTimeout
MessageQueueMessageReceived

◆ NoLockingNecessaryTag [1/3]

enum WTF::NoLockingNecessaryTag

Enumerator
NoLockingNecessary
NoLockingNecessary
NoLockingNecessary

◆ NoLockingNecessaryTag [2/3]

enum WTF::NoLockingNecessaryTag

Enumerator
NoLockingNecessary
NoLockingNecessary
NoLockingNecessary

◆ NoLockingNecessaryTag [3/3]

enum WTF::NoLockingNecessaryTag

Enumerator
NoLockingNecessary
NoLockingNecessary
NoLockingNecessary

◆ PositiveOrNegativeNumber [1/3]

enum WTF::PositiveOrNegativeNumber

Enumerator
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber

◆ PositiveOrNegativeNumber [2/3]

enum WTF::PositiveOrNegativeNumber

Enumerator
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber

◆ PositiveOrNegativeNumber [3/3]

enum WTF::PositiveOrNegativeNumber

Enumerator
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber
PositiveNumber
NegativeNumber

◆ RefCounterEvent [1/3]

enum WTF::RefCounterEvent

strong

Enumerator
Decrement
Increment
Decrement
Increment
Decrement
Increment

◆ RefCounterEvent [2/3]

enum WTF::RefCounterEvent

strong

Enumerator
Decrement
Increment
Decrement
Increment
Decrement
Increment

◆ RefCounterEvent [3/3]

enum WTF::RefCounterEvent

strong

Enumerator
Decrement
Increment
Decrement
Increment
Decrement
Increment

◆ ResultOverflowedTag [1/3]

enum WTF::ResultOverflowedTag

Enumerator
ResultOverflowed
ResultOverflowed
ResultOverflowed

◆ ResultOverflowedTag [2/3]

enum WTF::ResultOverflowedTag

Enumerator
ResultOverflowed
ResultOverflowed
ResultOverflowed

◆ ResultOverflowedTag [3/3]

enum WTF::ResultOverflowedTag

Enumerator
ResultOverflowed
ResultOverflowed
ResultOverflowed

◆ RoundingDecimalPlacesType [1/3]

enum WTF::RoundingDecimalPlacesType

Enumerator
RoundingDecimalPlaces
RoundingDecimalPlaces
RoundingDecimalPlaces

◆ RoundingDecimalPlacesType [2/3]

enum WTF::RoundingDecimalPlacesType

Enumerator
RoundingDecimalPlaces
RoundingDecimalPlaces
RoundingDecimalPlaces

◆ RoundingDecimalPlacesType [3/3]

enum WTF::RoundingDecimalPlacesType

Enumerator
RoundingDecimalPlaces
RoundingDecimalPlaces
RoundingDecimalPlaces

◆ RoundingSignificantFiguresType [1/3]

enum WTF::RoundingSignificantFiguresType

Enumerator
RoundingSignificantFigures
RoundingSignificantFigures
RoundingSignificantFigures

◆ RoundingSignificantFiguresType [2/3]

enum WTF::RoundingSignificantFiguresType

Enumerator
RoundingSignificantFigures
RoundingSignificantFigures
RoundingSignificantFigures

◆ RoundingSignificantFiguresType [3/3]

enum WTF::RoundingSignificantFiguresType

Enumerator
RoundingSignificantFigures
RoundingSignificantFigures
RoundingSignificantFigures

◆ SentinelTag [1/3]

enum WTF::SentinelTag

Enumerator
Sentinel
Sentinel
Sentinel

◆ SentinelTag [2/3]

enum WTF::SentinelTag

Enumerator
Sentinel
Sentinel
Sentinel

◆ SentinelTag [3/3]

enum WTF::SentinelTag

Enumerator
Sentinel
Sentinel
Sentinel

◆ Synchronous [1/3]

enum WTF::Synchronous

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ Synchronous [2/3]

enum WTF::Synchronous

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ Synchronous [3/3]

enum WTF::Synchronous

strong

Enumerator
No
Yes
No
Yes
No
Yes

◆ TextCaseSensitivity [1/3]

enum WTF::TextCaseSensitivity

Enumerator
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive

◆ TextCaseSensitivity [2/3]

enum WTF::TextCaseSensitivity

Enumerator
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive

◆ TextCaseSensitivity [3/3]

enum WTF::TextCaseSensitivity

Enumerator
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive
TextCaseSensitive
TextCaseInsensitive

◆ TimeType [1/3]

enum WTF::TimeType

Enumerator
UTCTime
LocalTime
UTCTime
LocalTime
UTCTime
LocalTime

◆ TimeType [2/3]

enum WTF::TimeType

Enumerator
UTCTime
LocalTime
UTCTime
LocalTime
UTCTime
LocalTime

◆ TimeType [3/3]

enum WTF::TimeType

Enumerator
UTCTime
LocalTime
UTCTime
LocalTime
UTCTime
LocalTime

◆ TrailingJunkPolicy

enum WTF::TrailingJunkPolicy

Enumerator
DisallowTrailingJunk
AllowTrailingJunk

◆ TrailingZerosTruncatingPolicy [1/3]

enum WTF::TrailingZerosTruncatingPolicy

Enumerator
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros

◆ TrailingZerosTruncatingPolicy [2/3]

enum WTF::TrailingZerosTruncatingPolicy

Enumerator
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros

◆ TrailingZerosTruncatingPolicy [3/3]

enum WTF::TrailingZerosTruncatingPolicy

Enumerator
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros
KeepTrailingZeros
TruncateTrailingZeros

◆ TriState [1/3]

enum WTF::TriState

Enumerator
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState

◆ TriState [2/3]

enum WTF::TriState

Enumerator
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState

◆ TriState [3/3]

enum WTF::TriState

Enumerator
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState
FalseTriState
TrueTriState
MixedTriState

◆ UTextProviderContext [1/3]

enum WTF::UTextProviderContext

strong

Enumerator
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext

◆ UTextProviderContext [2/3]

enum WTF::UTextProviderContext

strong

Enumerator
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext

◆ UTextProviderContext [3/3]

enum WTF::UTextProviderContext

strong

Enumerator
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext
NoContext
PriorContext
PrimaryContext

Function Documentation

◆ __arg_selector()

template<size_t _Index, typename ... _Args>

constexpr __arg_selector_t< _Index, _Args... >::__type && WTF::__arg_selector ( _Args &&... __args )

◆ __throw_bad_variant_access()

template<typename T >

NO_RETURN_DUE_TO_CRASH T WTF::__throw_bad_variant_access ( const char * what_arg )

inline

◆ abs()

WTF_EXPORT_PRIVATE MediaTime WTF::abs ( const MediaTime & rhs )

◆ acquireLineBreakIterator()

WTF_EXPORT_PRIVATE UBreakIterator * WTF::acquireLineBreakIterator	(	StringView	,
		const AtomicString &	locale,
		const UChar *	priorContext,
		unsigned	priorContextLength,
		LineBreakIteratorMode
	)

◆ addIterator()

template<typename Key , typename Value , typename Extractor , typename HashFunctions , typename Traits , typename KeyTraits >

void WTF::addIterator	(	const HashTable< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > *	table,
		HashTableConstIterator< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > *	it
	)

◆ adopted() [1/2]

void WTF::adopted ( const void * )

inline

◆ adopted() [2/2]

void WTF::adopted ( RefCountedBase * object )

inline

◆ adoptGDIObject()

template<typename T >

GDIObject< T > WTF::adoptGDIObject ( T object )

inline

◆ adoptMallocPtr()

template<typename U >

MallocPtr WTF::adoptMallocPtr ( U * ptr )

◆ adoptOSObject()

template<typename T >

OSObjectPtr< T > WTF::adoptOSObject ( T ptr )

inline

◆ adoptRef() [1/2]

template<typename T >

RefPtr< T > WTF::adoptRef ( T * p )

inline

◆ adoptRef() [2/2]

template<typename T >

Ref< T > WTF::adoptRef ( T & reference )

inline

◆ alignToMachineWord()

template<typename T >

T * WTF::alignToMachineWord ( T * pointer )

inline

◆ append()

template<typename CharacterType , size_t inlineCapacity>

void WTF::append	(	Vector< CharacterType, inlineCapacity > &	buffer,
		StringView	string
	)

◆ appendByteAsHex()

template<typename T >

void WTF::appendByteAsHex	(	unsigned char	byte,
		T &	destination,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ appendNumber()

template<typename CharacterType >

void WTF::appendNumber	(	Vector< CharacterType > &	vector,
		unsigned char	number
	)

inline

◆ appendUnsigned64AsHex()

template<typename T >

void WTF::appendUnsigned64AsHex	(	uint64_t	number,
		T &	destination,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ appendUnsignedAsHex()

template<typename T >

void WTF::appendUnsignedAsHex	(	unsigned	number,
		T &	destination,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ appendUnsignedAsHexFixedSize()

template<typename T >

void WTF::appendUnsignedAsHexFixedSize	(	unsigned	number,
		T &	destination,
		unsigned	desiredDigits,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ approximateBinarySearch() [1/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::approximateBinarySearch	(	ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ approximateBinarySearch() [2/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::approximateBinarySearch	(	const ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ are8Bit() [1/2]

template<typename Adapter >

bool WTF::are8Bit ( Adapter adapter )

inline

◆ are8Bit() [2/2]

template<typename Adapter , typename... Adapters>

bool WTF::are8Bit	(	Adapter	adapter,
		Adapters ...	adapters
	)

inline

◆ areEssentiallyEqual()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, bool >::type WTF::areEssentiallyEqual	(	T	u,
		T	v,
		T	epsilon = `std::numeric_limits<T>::epsilon()`
	)

inline

◆ arePointingToEqualData()

template<typename T >

bool WTF::arePointingToEqualData	(	const T &	a,
		const T &	b
	)

inline

◆ ArrayLengthHelperFunction()

template<typename T , size_t Size>

char(& WTF::ArrayLengthHelperFunction ( T(&) [Size] ) )[Size]

◆ atomicCompareExchangeStrong()

template<typename T >

T WTF::atomicCompareExchangeStrong	(	T *	location,
		T	expected,
		T	newValue,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicCompareExchangeWeak()

template<typename T >

bool WTF::atomicCompareExchangeWeak	(	T *	location,
		T	expected,
		T	newValue,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicCompareExchangeWeakRelaxed()

template<typename T >

bool WTF::atomicCompareExchangeWeakRelaxed	(	T *	location,
		T	expected,
		T	newValue
	)

inline

◆ atomicExchange()

template<typename T >

T WTF::atomicExchange	(	T *	location,
		T	newValue,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicExchangeAdd()

template<typename T , typename U >

T WTF::atomicExchangeAdd	(	T *	location,
		U	operand,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicExchangeAnd()

template<typename T , typename U >

T WTF::atomicExchangeAnd	(	T *	location,
		U	operand,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicExchangeOr()

template<typename T , typename U >

T WTF::atomicExchangeOr	(	T *	location,
		U	operand,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicExchangeSub()

template<typename T , typename U >

T WTF::atomicExchangeSub	(	T *	location,
		U	operand,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicExchangeXor()

template<typename T , typename U >

T WTF::atomicExchangeXor	(	T *	location,
		U	operand,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicLoad()

template<typename T >

T WTF::atomicLoad	(	T *	location,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ atomicStore()

template<typename T >

void WTF::atomicStore	(	T *	location,
		T	newValue,
		std::memory_order	order = `std::memory_order_seq_cst`
	)

inline

◆ base64Decode() [1/3]

WTF_EXPORT_PRIVATE bool WTF::base64Decode	(	const String &	,
		SignedOrUnsignedCharVectorAdapter	,
		unsigned	options = `Base64Default`
	)

◆ base64Decode() [2/3]

WTF_EXPORT_PRIVATE bool WTF::base64Decode	(	const Vector< char > &	,
		SignedOrUnsignedCharVectorAdapter	,
		unsigned	options = `Base64Default`
	)

◆ base64Decode() [3/3]

WTF_EXPORT_PRIVATE bool WTF::base64Decode	(	const char *	,
		unsigned	,
		SignedOrUnsignedCharVectorAdapter	,
		unsigned	options = `Base64Default`
	)

◆ base64Encode() [1/6]

WTF_EXPORT_PRIVATE void WTF::base64Encode	(	const void *	,
		unsigned	,
		Vector< char > &	,
		Base64EncodePolicy	= `Base64DoNotInsertLFs`
	)

◆ base64Encode() [2/6]

void WTF::base64Encode	(	ConstSignedOrUnsignedCharVectorAdapter	in,
		Vector< char > &	out,
		Base64EncodePolicy	policy = `Base64DoNotInsertLFs`
	)

inline

◆ base64Encode() [3/6]

void WTF::base64Encode	(	const CString &	in,
		Vector< char > &	out,
		Base64EncodePolicy	policy = `Base64DoNotInsertLFs`
	)

inline

◆ base64Encode() [4/6]

WTF_EXPORT_PRIVATE String WTF::base64Encode	(	const void *	,
		unsigned	,
		Base64EncodePolicy	= `Base64DoNotInsertLFs`
	)

◆ base64Encode() [5/6]

String WTF::base64Encode	(	ConstSignedOrUnsignedCharVectorAdapter	in,
		Base64EncodePolicy	policy = `Base64DoNotInsertLFs`
	)

inline

◆ base64Encode() [6/6]

String WTF::base64Encode	(	const CString &	in,
		Base64EncodePolicy	policy = `Base64DoNotInsertLFs`
	)

inline

◆ base64URLDecode() [1/3]

WTF_EXPORT_PRIVATE bool WTF::base64URLDecode	(	const String &	,
		SignedOrUnsignedCharVectorAdapter
	)

◆ base64URLDecode() [2/3]

WTF_EXPORT_PRIVATE bool WTF::base64URLDecode	(	const Vector< char > &	,
		SignedOrUnsignedCharVectorAdapter
	)

◆ base64URLDecode() [3/3]

WTF_EXPORT_PRIVATE bool WTF::base64URLDecode	(	const char *	,
		unsigned	,
		SignedOrUnsignedCharVectorAdapter
	)

◆ base64URLEncode() [1/6]

WTF_EXPORT_PRIVATE void WTF::base64URLEncode	(	const void *	,
		unsigned	,
		Vector< char > &
	)

◆ base64URLEncode() [2/6]

void WTF::base64URLEncode	(	ConstSignedOrUnsignedCharVectorAdapter	in,
		Vector< char > &	out
	)

inline

◆ base64URLEncode() [3/6]

void WTF::base64URLEncode	(	const CString &	in,
		Vector< char > &	out
	)

inline

◆ base64URLEncode() [4/6]

WTF_EXPORT_PRIVATE String WTF::base64URLEncode	(	const void *	,
		unsigned
	)

◆ base64URLEncode() [5/6]

String WTF::base64URLEncode ( ConstSignedOrUnsignedCharVectorAdapter in )

inline

◆ base64URLEncode() [6/6]

String WTF::base64URLEncode ( const CString & in )

inline

◆ binarySearch() [1/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::binarySearch	(	ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ binarySearch() [2/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::binarySearch	(	const ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ binarySearchImpl()

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey , BinarySearchMode mode>

ArrayElementType * WTF::binarySearchImpl	(	ArrayType &	array,
		size_t	size,
		KeyType	key,
		const ExtractKey &	extractKey = `ExtractKey()`
	)

inline

◆ bitCount() [1/2]

size_t WTF::bitCount ( unsigned bits )

inline

◆ bitCount() [2/2]

size_t WTF::bitCount ( uint64_t bits )

inline

◆ bitwise_cast()

template<typename ToType , typename FromType >

ToType WTF::bitwise_cast ( FromType from )

inline

◆ bubbleSort() [1/2]

template<typename IteratorType , typename LessThan >

void WTF::bubbleSort	(	IteratorType	begin,
		IteratorType	end,
		const LessThan &	lessThan
	)

◆ bubbleSort() [2/2]

template<typename IteratorType >

void WTF::bubbleSort	(	IteratorType	begin,
		IteratorType	end
	)

◆ calculateLocalTimeOffset()

WTF_EXPORT_PRIVATE LocalTimeOffset WTF::calculateLocalTimeOffset	(	double	utcInMilliseconds,
		TimeType	= `UTCTime`
	)

◆ callFunctionForCrossThreadTask()

template<typename F , typename ArgsTuple , typename ArgsIndices = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>

void WTF::callFunctionForCrossThreadTask	(	F	function,
		ArgsTuple &&	args
	)

◆ callFunctionForCrossThreadTaskImpl()

template<typename F , typename ArgsTuple , size_t... ArgsIndex>

void WTF::callFunctionForCrossThreadTaskImpl	(	F	function,
		ArgsTuple &&	args,
		std::index_sequence< ArgsIndex... >
	)

◆ callMemberFunctionForCrossThreadTask()

template<typename C , typename MF , typename ArgsTuple , typename ArgsIndicies = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>

void WTF::callMemberFunctionForCrossThreadTask	(	C *	object,
		MF	function,
		ArgsTuple &&	args
	)

◆ callMemberFunctionForCrossThreadTaskImpl()

template<typename C , typename MF , typename ArgsTuple , size_t... ArgsIndex>

void WTF::callMemberFunctionForCrossThreadTaskImpl	(	C *	object,
		MF	function,
		ArgsTuple &&	args,
		std::index_sequence< ArgsIndex... >
	)

◆ callOnMainThread()

WTF_EXPORT_PRIVATE void WTF::callOnMainThread ( Function< void()> && )

◆ callOnWebThreadOrDispatchAsyncOnMainThread()

void WTF::callOnWebThreadOrDispatchAsyncOnMainThread ( void(^)() block )

◆ callStatelessLambda()

template<typename ResultType , typename Func , typename... ArgumentTypes>

ResultType WTF::callStatelessLambda ( ArgumentTypes &&... arguments )

◆ canAccessThreadLocalDataForThread()

WTF_EXPORT_PRIVATE bool WTF::canAccessThreadLocalDataForThread ( ThreadIdentifier )

◆ changeThreadPriority()

WTF_EXPORT_PRIVATE void WTF::changeThreadPriority	(	ThreadIdentifier	,
		int
	)

◆ charactersAreAllASCII()

template<typename CharacterType >

bool WTF::charactersAreAllASCII	(	const CharacterType *	characters,
		size_t	length
	)

inline

◆ charactersToDouble() [1/2]

WTF_EXPORT_STRING_API double WTF::charactersToDouble	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToDouble() [2/2]

WTF_EXPORT_STRING_API double WTF::charactersToDouble	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToFloat() [1/4]

WTF_EXPORT_STRING_API float WTF::charactersToFloat	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToFloat() [2/4]

WTF_EXPORT_STRING_API float WTF::charactersToFloat	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToFloat() [3/4]

WTF_EXPORT_STRING_API float WTF::charactersToFloat	(	const LChar *	,
		size_t	,
		size_t &	parsedLength
	)

◆ charactersToFloat() [4/4]

WTF_EXPORT_STRING_API float WTF::charactersToFloat	(	const UChar *	,
		size_t	,
		size_t &	parsedLength
	)

◆ charactersToInt() [1/2]

WTF_EXPORT_STRING_API int WTF::charactersToInt	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToInt() [2/2]

WTF_EXPORT_STRING_API int WTF::charactersToInt	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToInt64() [1/2]

int64_t WTF::charactersToInt64	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToInt64() [2/2]

int64_t WTF::charactersToInt64	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToInt64Strict() [1/2]

int64_t WTF::charactersToInt64Strict	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToInt64Strict() [2/2]

int64_t WTF::charactersToInt64Strict	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToIntPtr() [1/2]

intptr_t WTF::charactersToIntPtr	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToIntPtr() [2/2]

intptr_t WTF::charactersToIntPtr	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToIntPtrStrict() [1/2]

intptr_t WTF::charactersToIntPtrStrict	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToIntPtrStrict() [2/2]

intptr_t WTF::charactersToIntPtrStrict	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToIntStrict() [1/2]

WTF_EXPORT_STRING_API int WTF::charactersToIntStrict	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToIntStrict() [2/2]

WTF_EXPORT_STRING_API int WTF::charactersToIntStrict	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToUInt() [1/2]

unsigned WTF::charactersToUInt	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToUInt() [2/2]

unsigned WTF::charactersToUInt	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToUInt64() [1/2]

uint64_t WTF::charactersToUInt64	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToUInt64() [2/2]

WTF_EXPORT_STRING_API uint64_t WTF::charactersToUInt64	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`
	)

◆ charactersToUInt64Strict() [1/2]

uint64_t WTF::charactersToUInt64Strict	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToUInt64Strict() [2/2]

uint64_t WTF::charactersToUInt64Strict	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToUIntStrict() [1/2]

WTF_EXPORT_STRING_API unsigned WTF::charactersToUIntStrict	(	const LChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ charactersToUIntStrict() [2/2]

WTF_EXPORT_STRING_API unsigned WTF::charactersToUIntStrict	(	const UChar *	,
		size_t	,
		bool *	ok = `nullptr`,
		int	base = `10`
	)

◆ checkAndSet()

template<typename T , typename U >

bool WTF::checkAndSet	(	T &	left,
		U	right
	)

◆ checked_cf_cast()

template<typename T >

T WTF::checked_cf_cast ( CFTypeRef object )

◆ checkedProduct() [1/2]

template<typename T , typename U >

Checked< T, RecordOverflow > WTF::checkedProduct ( U value )

◆ checkedProduct() [2/2]

template<typename T , typename U , typename... Args>

Checked< T, RecordOverflow > WTF::checkedProduct	(	U	value,
		Args...	args
	)

◆ checkedSum() [1/2]

template<typename T , typename U >

Checked< T, RecordOverflow > WTF::checkedSum ( U value )

◆ checkedSum() [2/2]

template<typename T , typename U , typename... Args>

Checked< T, RecordOverflow > WTF::checkedSum	(	U	value,
		Args...	args
	)

◆ closeLineBreakIterator()

void WTF::closeLineBreakIterator ( UBreakIterator *& )

◆ closeWithRetry()

int WTF::closeWithRetry ( int fileDescriptor )

inline

◆ codePointCompare() [1/3]

WTF_EXPORT_STRING_API int WTF::codePointCompare	(	const String &	,
		const String &
	)

◆ codePointCompare() [2/3]

template<typename CharacterType1 , typename CharacterType2 >

int WTF::codePointCompare	(	unsigned	l1,
		unsigned	l2,
		const CharacterType1 *	c1,
		const CharacterType2 *	c2
	)

inline

◆ codePointCompare() [3/3]

int WTF::codePointCompare	(	const StringImpl *	string1,
		const StringImpl *	string2
	)

inline

◆ codePointCompare16()

int WTF::codePointCompare16	(	const StringImpl *	string1,
		const StringImpl *	string2
	)

inline

◆ codePointCompare8()

int WTF::codePointCompare8	(	const StringImpl *	string1,
		const StringImpl *	string2
	)

inline

◆ codePointCompare8To16()

int WTF::codePointCompare8To16	(	const StringImpl *	string1,
		const StringImpl *	string2
	)

inline

◆ codePointCompareLessThan()

bool WTF::codePointCompareLessThan	(	const String &	a,
		const String &	b
	)

inline

◆ COMPILE_ASSERT() [1/3]

WTF::COMPILE_ASSERT	(	(std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< PassRefPtr< CopierThreadSafeRefCountedTest >>::Type >::value)	,
		PassRefPtrTest
	)

◆ COMPILE_ASSERT() [2/3]

WTF::COMPILE_ASSERT	(	(std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< RefPtr< CopierThreadSafeRefCountedTest >>::Type >::value)	,
		RefPtrTest
	)

◆ COMPILE_ASSERT() [3/3]

WTF::COMPILE_ASSERT	(	(std::is_same< PassRefPtr< CopierThreadSafeRefCountedTest >, CrossThreadCopier< CopierThreadSafeRefCountedTest * >::Type >::value)	,
		RawPointerTest
	)

◆ compilerFence()

void WTF::compilerFence ( )

inline

◆ constantTimeMemcmp()

WTF_EXPORT_PRIVATE int WTF::constantTimeMemcmp	(	const void *	,
		const void *	,
		size_t	length
	)

◆ consumeLoad()

template<typename T >

ALWAYS_INLINE auto WTF::consumeLoad ( const T * location )

◆ copyKeysToVector()

template<typename T , typename U , typename V , typename W , typename X , typename Y >

void WTF::copyKeysToVector	(	const HashMap< T, U, V, W, X > &	collection,
		Y &	vector
	)

inline

◆ copyLCharsFromUCharSource()

void WTF::copyLCharsFromUCharSource	(	LChar *	destination,
		const UChar *	source,
		size_t	length
	)

inline

◆ copyToVector() [1/4]

template<typename Value , typename HashFunctions , typename Traits , typename VectorType >

void WTF::copyToVector	(	const HashCountedSet< Value, HashFunctions, Traits > &	collection,
		VectorType &	vector
	)

inline

◆ copyToVector() [2/4]

template<typename Value , typename HashFunctions , typename Traits >

void WTF::copyToVector	(	const HashCountedSet< Value, HashFunctions, Traits > &	collection,
		Vector< Value > &	vector
	)

inline

◆ copyToVector() [3/4]

template<typename C , typename W >

void WTF::copyToVector	(	const C &	collection,
		W &	vector
	)

inline

◆ copyToVector() [4/4]

template<typename T , typename U , typename V , typename W , typename X , typename Y >

void WTF::copyToVector	(	const HashMap< T, U, V, W, X > &	collection,
		Y &	vector
	)

inline

◆ copyValuesToVector()

template<typename T , typename U , typename V , typename W , typename X , typename Y >

void WTF::copyValuesToVector	(	const HashMap< T, U, V, W, X > &	collection,
		Y &	vector
	)

inline

◆ createCrossThreadTask() [1/2]

template<typename... Parameters, typename... Arguments>

CrossThreadTask WTF::createCrossThreadTask	(	void(*)(Parameters...)	method,
		const Arguments &...	arguments
	)

◆ createCrossThreadTask() [2/2]

template<typename T , typename... Parameters, typename... Arguments>

CrossThreadTask WTF::createCrossThreadTask	(	T &	callee,
		void(T::*)(Parameters...)	method,
		const Arguments &...	arguments
	)

◆ createIterator()

WTF_EXPORT_PRIVATE UCharIterator WTF::createIterator ( StringView )

◆ createSharedTask() [1/2]

template<typename FunctionType , typename Functor >

Ref< SharedTask< FunctionType > > WTF::createSharedTask ( const Functor & functor )

◆ createSharedTask() [2/2]

template<typename FunctionType , typename Functor >

Ref< SharedTask< FunctionType > > WTF::createSharedTask ( Functor && functor )

◆ createThread() [1/2]

WTF_EXPORT_PRIVATE ThreadIdentifier WTF::createThread	(	const char *	threadName,
		std::function< void()>
	)

◆ createThread() [2/2]

WTF_EXPORT_PRIVATE ThreadIdentifier WTF::createThread	(	ThreadFunction	,
		void *	,
		const char *	threadName
	)

◆ createThreadInternal()

ThreadIdentifier WTF::createThreadInternal	(	ThreadFunction	,
		void *	,
		const char *	threadName
	)

◆ crossModifyingCodeFence()

void WTF::crossModifyingCodeFence ( )

inline

◆ crossThreadCopy()

template<typename T >

T WTF::crossThreadCopy ( const T & t )

◆ cryptographicallyRandomNumber()

WTF_EXPORT_PRIVATE uint32_t WTF::cryptographicallyRandomNumber ( )

◆ cryptographicallyRandomValues()

WTF_EXPORT_PRIVATE void WTF::cryptographicallyRandomValues	(	void *	buffer,
		size_t	length
	)

◆ cryptographicallyRandomValuesFromOS()

void WTF::cryptographicallyRandomValuesFromOS	(	unsigned char *	buffer,
		size_t	length
	)

◆ currentCPUTime()

WTF_EXPORT_PRIVATE std::chrono::microseconds WTF::currentCPUTime ( )

◆ currentSearchLocaleID()

WTF_EXPORT_PRIVATE const char * WTF::currentSearchLocaleID ( )

◆ currentTextBreakLocaleID()

WTF_EXPORT_PRIVATE const char * WTF::currentTextBreakLocaleID ( )

◆ currentThread()

WTF_EXPORT_PRIVATE ThreadIdentifier WTF::currentThread ( )

◆ currentTime()

WTF_EXPORT_PRIVATE double WTF::currentTime ( )

◆ currentTimeMS()

double WTF::currentTimeMS ( )

inline

◆ dataFile()

WTF_EXPORT_PRIVATE PrintStream & WTF::dataFile ( )

◆ dataLog()

template<typename... Types>

void WTF::dataLog ( const Types &... values )

◆ dataLogF()

WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void WTF::dataLogF	(	const char *	format,
			...
	)

◆ dataLogFString()

WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void WTF_EXPORT_PRIVATE void WTF::dataLogFString ( const char * )

◆ dataLogFV()

WTF_EXPORT_PRIVATE void WTF::dataLogFV	(	const char *	format,
		va_list	argList
	)

◆ dataLogIf()

template<typename... Types>

void WTF::dataLogIf	(	bool	shouldLog,
		const Types &...	values
	)

◆ dataLogLn()

template<typename... Types>

void WTF::dataLogLn ( const Types &... values )

◆ dataLogLnIf()

template<typename... Types>

void WTF::dataLogLnIf	(	bool	shouldLog,
		const Types &...	values
	)

◆ dateToDaysFrom1970()

WTF_EXPORT_PRIVATE double WTF::dateToDaysFrom1970	(	int	year,
		int	month,
		int	day
	)

◆ dayInMonthFromDayInYear()

WTF_EXPORT_PRIVATE int WTF::dayInMonthFromDayInYear	(	int	dayInYear,
		bool	leapYear
	)

◆ dayInYear() [1/2]

WTF_EXPORT_PRIVATE int WTF::dayInYear	(	int	year,
		int	month,
		int	day
	)

◆ dayInYear() [2/2]

WTF_EXPORT_PRIVATE int WTF::dayInYear	(	double	ms,
		int	year
	)

◆ DECLARE_CF_TYPE_TRAIT() [1/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFArray )

◆ DECLARE_CF_TYPE_TRAIT() [2/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFBoolean )

◆ DECLARE_CF_TYPE_TRAIT() [3/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFData )

◆ DECLARE_CF_TYPE_TRAIT() [4/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFDictionary )

◆ DECLARE_CF_TYPE_TRAIT() [5/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFNumber )

◆ DECLARE_CF_TYPE_TRAIT() [6/6]

WTF::DECLARE_CF_TYPE_TRAIT ( CFString )

◆ DEFINE_GLOBAL() [1/3]

WTF_EXPORTDATA WTF::DEFINE_GLOBAL	(	AtomicString	,
		nullAtom
	)

◆ DEFINE_GLOBAL() [2/3]

WTF_EXPORTDATA emptyAtom WTF_EXPORTDATA WTF::DEFINE_GLOBAL	(	AtomicString	,
		starAtom
	)

◆ DEFINE_GLOBAL() [3/3]

WTF_EXPORTDATA emptyAtom WTF_EXPORTDATA xmlAtom WTF_EXPORTDATA WTF::DEFINE_GLOBAL	(	AtomicString	,
		xmlnsAtom
	)

◆ deleteObject()

template<typename T >

void WTF::deleteObject ( T object )

inline

◆ deleteObject< HDC >()

template<>

void WTF::deleteObject< HDC > ( HDC hdc )

inline

◆ derefGPtr() [1/3]

template<>

void WTF::derefGPtr ( SoupBuffer * ptr )

◆ derefGPtr() [2/3]

template<>

void WTF::derefGPtr ( GtkTargetList * ptr )

◆ derefGPtr() [3/3]

template<>

void WTF::derefGPtr ( GtkWidgetPath * ptr )

◆ derefIfNotNull()

template<typename T >

ALWAYS_INLINE void WTF::derefIfNotNull ( T * ptr )

◆ detachThread()

WTF_EXPORT_PRIVATE void WTF::detachThread ( ThreadIdentifier )

◆ differenceOverflows()

template<typename T , typename U >

bool WTF::differenceOverflows	(	U	left,
		U	right
	)

◆ dispatchFunctionsFromMainThread()

void WTF::dispatchFunctionsFromMainThread ( )

◆ doubleHash()

unsigned WTF::doubleHash ( unsigned key )

inline

◆ downcast() [1/2]

template<typename Target , typename Source >

match_constness< Source, Target >::type & WTF::downcast ( Source & source )

inline

◆ downcast() [2/2]

template<typename Target , typename Source >

match_constness< Source, Target >::type * WTF::downcast ( Source * source )

inline

◆ dtoa() [1/2]

WTF_EXPORT_PRIVATE void WTF::dtoa	(	DtoaBuffer	result,
		double	dd,
		bool &	sign,
		int &	exponent,
		unsigned &	precision
	)

◆ dtoa() [2/2]

template<bool roundingNone, bool roundingSignificantFigures, bool roundingDecimalPlaces, bool leftright>

void WTF::dtoa	(	DtoaBuffer	result,
		double	dd,
		int	ndigits,
		bool &	signOut,
		int &	exponentOut,
		unsigned &	precisionOut
	)

◆ dtoaRoundDP()

WTF_EXPORT_PRIVATE void WTF::dtoaRoundDP	(	DtoaBuffer	result,
		double	dd,
		int	ndigits,
		bool &	sign,
		int &	exponent,
		unsigned &	precision
	)

◆ dtoaRoundSF()

WTF_EXPORT_PRIVATE void WTF::dtoaRoundSF	(	DtoaBuffer	result,
		double	dd,
		int	ndigits,
		bool &	sign,
		int &	exponent,
		unsigned &	precision
	)

◆ dumpCharacter()

WTF_EXPORT_PRIVATE void WTF::dumpCharacter	(	PrintStream &	,
		char
	)

◆ dupCloseOnExec()

int WTF::dupCloseOnExec ( int fileDescriptor )

◆ dynamic_cf_cast()

template<typename T >

T WTF::dynamic_cf_cast ( CFTypeRef object )

◆ emptyString()

WTF_EXPORT_STRING_API const String & WTF::emptyString ( )

◆ endsWith()

template<typename StringClassA , typename StringClassB >

bool WTF::endsWith	(	const StringClassA &	reference,
		const StringClassB &	suffix
	)

◆ endsWithIgnoringASCIICase()

template<typename StringClassA , typename StringClassB >

bool WTF::endsWithIgnoringASCIICase	(	const StringClassA &	reference,
		const StringClassB &	suffix
	)

◆ equal() [1/19]

bool WTF::equal	(	StringView	a,
		StringView	b
	)

inline

◆ equal() [2/19]

bool WTF::equal	(	StringView	a,
		const LChar *	b
	)

inline

◆ equal() [3/19]

bool WTF::equal	(	StringView	a,
		const char *	b
	)

inline

◆ equal() [4/19]

ALWAYS_INLINE bool WTF::equal	(	const LChar *	a,
		const LChar *	b,
		unsigned	length
	)

◆ equal() [5/19]

ALWAYS_INLINE bool WTF::equal	(	const UChar *	a,
		const UChar *	b,
		unsigned	length
	)

◆ equal() [6/19]

ALWAYS_INLINE bool WTF::equal	(	const LChar *	a,
		const UChar *	b,
		unsigned	length
	)

◆ equal() [7/19]

ALWAYS_INLINE bool WTF::equal	(	const UChar *	a,
		const LChar *	b,
		unsigned	length
	)

◆ equal() [8/19]

template<typename StringClass , unsigned length>

bool WTF::equal	(	const StringClass &	a,
		const UChar(&)	codeUnits[length]
	)

◆ equal() [9/19]

template<typename CharType >

bool WTF::equal	(	const StringBuilder &	s,
		const CharType *	buffer,
		unsigned	length
	)

◆ equal() [10/19]

template<typename StringType >

bool WTF::equal	(	const StringBuilder &	a,
		const StringType &	b
	)

◆ equal() [11/19]

WTF_EXPORT_STRING_API bool WTF::equal	(	const StringImpl *	,
		const StringImpl *
	)

◆ equal() [12/19]

WTF_EXPORT_STRING_API bool WTF::equal	(	const StringImpl *	,
		const LChar *
	)

◆ equal() [13/19]

bool WTF::equal	(	const StringImpl *	a,
		const char *	b
	)

inline

◆ equal() [14/19]

WTF_EXPORT_STRING_API bool WTF::equal	(	const StringImpl *	,
		const LChar *	,
		unsigned
	)

◆ equal() [15/19]

WTF_EXPORT_STRING_API bool WTF::equal	(	const StringImpl *	,
		const UChar *	,
		unsigned
	)

◆ equal() [16/19]

bool WTF::equal	(	const StringImpl *	a,
		const char *	b,
		unsigned	length
	)

inline

◆ equal() [17/19]

bool WTF::equal	(	const LChar *	a,
		StringImpl *	b
	)

inline

◆ equal() [18/19]

bool WTF::equal	(	const char *	a,
		StringImpl *	b
	)

inline

◆ equal() [19/19]

WTF_EXPORT_STRING_API bool WTF::equal	(	const StringImpl &	a,
		const StringImpl &	b
	)

◆ equalCommon() [1/2]

template<typename StringClassA , typename StringClassB >

ALWAYS_INLINE bool WTF::equalCommon	(	const StringClassA &	a,
		const StringClassB &	b
	)

◆ equalCommon() [2/2]

template<typename StringClassA , typename StringClassB >

ALWAYS_INLINE bool WTF::equalCommon	(	const StringClassA *	a,
		const StringClassB *	b
	)

◆ equalIgnoringASCIICase() [1/14]

template<typename CharacterTypeA , typename CharacterTypeB >

bool WTF::equalIgnoringASCIICase	(	const CharacterTypeA *	a,
		const CharacterTypeB *	b,
		unsigned	length
	)

inline

◆ equalIgnoringASCIICase() [2/14]

template<typename CharacterTypeA , typename CharacterTypeB >

bool WTF::equalIgnoringASCIICase	(	const CharacterTypeA *	a,
		unsigned	lengthA,
		const CharacterTypeB *	b,
		unsigned	lengthB
	)

inline

◆ equalIgnoringASCIICase() [3/14]

bool WTF::equalIgnoringASCIICase	(	StringView	a,
		StringView	b
	)

inline

◆ equalIgnoringASCIICase() [4/14]

bool WTF::equalIgnoringASCIICase	(	StringView	a,
		const char *	b
	)

inline

◆ equalIgnoringASCIICase() [5/14]

bool WTF::equalIgnoringASCIICase	(	const AtomicString &	a,
		const AtomicString &	b
	)

inline

◆ equalIgnoringASCIICase() [6/14]

bool WTF::equalIgnoringASCIICase	(	const AtomicString &	a,
		const String &	b
	)

inline

◆ equalIgnoringASCIICase() [7/14]

bool WTF::equalIgnoringASCIICase	(	const String &	a,
		const AtomicString &	b
	)

inline

◆ equalIgnoringASCIICase() [8/14]

bool WTF::equalIgnoringASCIICase	(	const AtomicString &	a,
		const char *	b
	)

inline

◆ equalIgnoringASCIICase() [9/14]

bool WTF::equalIgnoringASCIICase	(	const String &	a,
		const String &	b
	)

inline

◆ equalIgnoringASCIICase() [10/14]

bool WTF::equalIgnoringASCIICase	(	const String &	a,
		const char *	b
	)

inline

◆ equalIgnoringASCIICase() [11/14]

bool WTF::equalIgnoringASCIICase	(	const StringImpl &	a,
		const StringImpl &	b
	)

inline

◆ equalIgnoringASCIICase() [12/14]

WTF_EXPORT_STRING_API bool WTF::equalIgnoringASCIICase	(	const StringImpl *	,
		const StringImpl *
	)

◆ equalIgnoringASCIICase() [13/14]

bool WTF::equalIgnoringASCIICase	(	const StringImpl &	a,
		const char *	b
	)

inline

◆ equalIgnoringASCIICase() [14/14]

bool WTF::equalIgnoringASCIICase	(	const StringImpl *	a,
		const char *	b
	)

inline

◆ equalIgnoringASCIICaseCommon() [1/2]

template<typename StringClassA , typename StringClassB >

bool WTF::equalIgnoringASCIICaseCommon	(	const StringClassA &	a,
		const StringClassB &	b
	)

◆ equalIgnoringASCIICaseCommon() [2/2]

template<typename StringClassA >

bool WTF::equalIgnoringASCIICaseCommon	(	const StringClassA &	a,
		const char *	b
	)

◆ equalIgnoringASCIICaseNonNull()

WTF_EXPORT_STRING_API bool WTF::equalIgnoringASCIICaseNonNull	(	const StringImpl *	,
		const StringImpl *
	)

◆ equalIgnoringNullity() [1/5]

bool WTF::equalIgnoringNullity	(	const String &	a,
		const String &	b
	)

inline

◆ equalIgnoringNullity() [2/5]

template<size_t inlineCapacity>

bool WTF::equalIgnoringNullity	(	const Vector< UChar, inlineCapacity > &	a,
		const String &	b
	)

inline

◆ equalIgnoringNullity() [3/5]

WTF_EXPORT_STRING_API bool WTF::equalIgnoringNullity	(	StringImpl *	,
		StringImpl *
	)

◆ equalIgnoringNullity() [4/5]

WTF_EXPORT_STRING_API bool WTF::equalIgnoringNullity	(	const UChar *	,
		size_t	length,
		StringImpl *
	)

◆ equalIgnoringNullity() [5/5]

template<size_t inlineCapacity>

bool WTF::equalIgnoringNullity	(	const Vector< UChar, inlineCapacity > &	a,
		StringImpl *	b
	)

inline

◆ equalInternal()

template<typename CharType >

bool WTF::equalInternal	(	const StringImpl *	a,
		const CharType *	b,
		unsigned	length
	)

inline

◆ equalLettersIgnoringASCIICase() [1/7]

template<typename CharacterType >

bool WTF::equalLettersIgnoringASCIICase	(	const CharacterType *	characters,
		const char *	lowercaseLetters,
		unsigned	length
	)

inline

◆ equalLettersIgnoringASCIICase() [2/7]

template<typename CharacterType , unsigned lowercaseLettersLength>

bool WTF::equalLettersIgnoringASCIICase	(	const CharacterType *	characters,
		unsigned	charactersLength,
		const char(&)	lowercaseLetters[lowercaseLettersLength]
	)

inline

◆ equalLettersIgnoringASCIICase() [3/7]

template<unsigned length>

bool WTF::equalLettersIgnoringASCIICase	(	StringView	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICase() [4/7]

template<unsigned length>

bool WTF::equalLettersIgnoringASCIICase	(	const AtomicString &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICase() [5/7]

template<unsigned length>

bool WTF::equalLettersIgnoringASCIICase	(	const String &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICase() [6/7]

template<unsigned length>

bool WTF::equalLettersIgnoringASCIICase	(	const StringImpl &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICase() [7/7]

template<unsigned length>

bool WTF::equalLettersIgnoringASCIICase	(	const StringImpl *	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICaseCommon()

template<typename StringClass , unsigned length>

bool WTF::equalLettersIgnoringASCIICaseCommon	(	const StringClass &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ equalLettersIgnoringASCIICaseCommonWithoutLength()

template<typename StringClass >

bool WTF::equalLettersIgnoringASCIICaseCommonWithoutLength	(	const StringClass &	string,
		const char *	lowercaseLetters
	)

◆ equivalentYearForDST()

int WTF::equivalentYearForDST ( int year )

◆ exchangeIsCompilationThread()

WTF_EXPORT_PRIVATE bool WTF::exchangeIsCompilationThread ( bool newValue )

◆ executeInsertions()

template<typename TargetVectorType , typename InsertionVectorType >

size_t WTF::executeInsertions	(	TargetVectorType &	target,
		InsertionVectorType &	insertions
	)

◆ fastAlignedFree()

WTF_EXPORT_PRIVATE void WTF::fastAlignedFree ( void * )

◆ fastAlignedMalloc()

WTF_EXPORT_PRIVATE void * WTF::fastAlignedMalloc	(	size_t	alignment,
		size_t
	)

◆ fastBitVectorArrayLength()

size_t WTF::fastBitVectorArrayLength ( size_t numBits )

inline

◆ fastCalloc()

WTF_EXPORT_PRIVATE void * WTF::fastCalloc	(	size_t	numElements,
		size_t	elementSize
	)

◆ fastFree()

WTF_EXPORT_PRIVATE void WTF::fastFree ( void * )

◆ fastLog2() [1/2]

unsigned WTF::fastLog2 ( unsigned i )

inline

◆ fastLog2() [2/2]

unsigned WTF::fastLog2 ( uint64_t value )

inline

◆ fastMalloc()

WTF_EXPORT_PRIVATE void * WTF::fastMalloc ( size_t )

◆ fastMallocGoodSize()

WTF_EXPORT_PRIVATE size_t WTF::fastMallocGoodSize ( size_t )

◆ fastMallocSize()

WTF_EXPORT_PRIVATE size_t WTF::fastMallocSize ( const void * )

◆ fastMallocStatistics()

WTF_EXPORT_PRIVATE FastMallocStatistics WTF::fastMallocStatistics ( )

◆ fastRealloc()

WTF_EXPORT_PRIVATE void * WTF::fastRealloc	(	void *	,
		size_t
	)

◆ fastSetMaxSingleAllocationSize()

WTF_EXPORT_PRIVATE void WTF::fastSetMaxSingleAllocationSize ( size_t )

◆ fastStrDup()

WTF_EXPORT_PRIVATE char * WTF::fastStrDup ( const char * )

◆ fastZeroedMalloc()

WTF_EXPORT_PRIVATE void * WTF::fastZeroedMalloc ( size_t )

◆ find() [1/5]

template<typename CharacterType >

size_t WTF::find	(	const CharacterType *	characters,
		unsigned	length,
		CharacterType	matchCharacter,
		unsigned	index = `0`
	)

inline

◆ find() [2/5]

ALWAYS_INLINE size_t WTF::find	(	const UChar *	characters,
		unsigned	length,
		LChar	matchCharacter,
		unsigned	index = `0`
	)

◆ find() [3/5]

size_t WTF::find	(	const LChar *	characters,
		unsigned	length,
		UChar	matchCharacter,
		unsigned	index = `0`
	)

inline

◆ find() [4/5]

size_t WTF::find	(	const LChar *	characters,
		unsigned	length,
		CharacterMatchFunctionPtr	matchFunction,
		unsigned	index = `0`
	)

inline

◆ find() [5/5]

size_t WTF::find	(	const UChar *	characters,
		unsigned	length,
		CharacterMatchFunctionPtr	matchFunction,
		unsigned	index = `0`
	)

inline

◆ findBitInWord()

template<typename T >

bool WTF::findBitInWord	(	T	word,
		size_t &	index,
		size_t	endIndex,
		bool	value
	)

◆ findCommon()

template<typename StringClass >

size_t WTF::findCommon	(	const StringClass &	haystack,
		const StringClass &	needle,
		unsigned	start
	)

◆ findIgnoringASCIICase() [1/2]

template<typename SearchCharacterType , typename MatchCharacterType >

size_t WTF::findIgnoringASCIICase	(	const SearchCharacterType *	source,
		const MatchCharacterType *	matchCharacters,
		unsigned	startOffset,
		unsigned	searchLength,
		unsigned	matchLength
	)

◆ findIgnoringASCIICase() [2/2]

template<typename StringClassA , typename StringClassB >

size_t WTF::findIgnoringASCIICase	(	const StringClassA &	source,
		const StringClassB &	stringToFind,
		unsigned	startOffset
	)

◆ flipBytes() [1/4]

uint16_t WTF::flipBytes ( uint16_t value )

inline

◆ flipBytes() [2/4]

T WTF::flipBytes ( uint32_t value )

inline

◆ flipBytes() [3/4]

uint64_t WTF::flipBytes ( uint64_t value )

inline

◆ flipBytes() [4/4]

template<typename T >

T WTF::flipBytes ( T value )

inline

◆ flipBytesIfLittleEndian()

template<typename T >

T WTF::flipBytesIfLittleEndian	(	T	value,
		bool	littleEndian
	)

inline

◆ format()

template<typename... Types>

FormatImpl< Types... > WTF::format ( Types... values )

◆ get() [1/8]

template<typename _Type , typename ... _Types>

constexpr _Type & WTF::get ( Variant< _Types... > & __v )

◆ get() [2/8]

template<typename _Type , typename ... _Types>

constexpr _Type const & WTF::get ( Variant< _Types... > const & __v )

◆ get() [3/8]

template<typename _Type , typename ... _Types>

constexpr _Type && WTF::get ( Variant< _Types... > && __v )

◆ get() [4/8]

template<typename _Type , typename ... _Types>

constexpr const _Type && WTF::get ( Variant< _Types... > const && __v )

◆ get() [5/8]

template<ptrdiff_t _Index, typename ... _Types>

constexpr __indexed_type< _Index, _Types... >::__type & WTF::get ( Variant< _Types... > & __v )

◆ get() [6/8]

template<ptrdiff_t _Index, typename ... _Types>

constexpr __indexed_type< _Index, _Types... >::__type && WTF::get ( Variant< _Types... > && __v )

◆ get() [7/8]

template<ptrdiff_t _Index, typename ... _Types>

constexpr __indexed_type< _Index, _Types... >::__type const & WTF::get ( Variant< _Types... > const & __v )

◆ get() [8/8]

template<ptrdiff_t _Index, typename... _Types>

constexpr const __indexed_type< _Index, _Types... >::__type && WTF::get ( Variant< _Types... > const && __v )

◆ get_if() [1/4]

template<typename _Type , typename ... _Types>

constexpr std::add_pointer_t< _Type > WTF::get_if ( Variant< _Types... > & __v )

◆ get_if() [2/4]

template<typename _Type , typename ... _Types>

constexpr std::add_pointer_t< _Type const > WTF::get_if ( Variant< _Types... > const & __v )

◆ get_if() [3/4]

template<ptrdiff_t _Index, typename ... _Types>

constexpr std::add_pointer_t< typename __indexed_type< _Index, _Types... >::__type > WTF::get_if ( Variant< _Types... > & __v )

◆ get_if() [4/4]

template<ptrdiff_t _Index, typename ... _Types>

constexpr std::add_pointer_t< typename __indexed_type< _Index, _Types... >::__type const > WTF::get_if ( Variant< _Types... > const & __v )

◆ getAndResetAccumulatedLogs()

WTF_EXPORT_PRIVATE String WTF::getAndResetAccumulatedLogs ( )

◆ getCurrentProcessID()

int WTF::getCurrentProcessID ( )

inline

◆ getPtr() [1/3]

template<typename T >

T * WTF::getPtr ( T * p )

inline

◆ getPtr() [2/3]

template<typename T >

GetPtrHelper< T >::PtrType WTF::getPtr ( T & p )

inline

◆ getPtr() [3/3]

template<typename T >

GetPtrHelper< T >::PtrType WTF::getPtr ( const T & p )

inline

◆ hasElapsed()

WTF_EXPORT_PRIVATE bool WTF::hasElapsed ( const TimeWithDynamicClockType & )

◆ hashTraitsDeleteBucket() [1/2]

template<typename Traits , typename T >

std::enable_if< HashTraitHasCustomDelete< Traits, T >::value >::type WTF::hashTraitsDeleteBucket ( T & value )

◆ hashTraitsDeleteBucket() [2/2]

template<typename Traits , typename T >

std::enable_if<!HashTraitHasCustomDelete< Traits, T >::value >::type WTF::hashTraitsDeleteBucket ( T & value )

◆ hasPrefixWithLettersIgnoringASCIICaseCommon()

template<typename StringClass >

bool WTF::hasPrefixWithLettersIgnoringASCIICaseCommon	(	const StringClass &	string,
		const char *	lowercaseLetters,
		unsigned	length
	)

inline

◆ holdLock()

template<typename LockType >

Locker< LockType > WTF::holdLock ( LockType & lock )

◆ holds_alternative()

template<typename _Type , typename ... _Types>

constexpr bool WTF::holds_alternative ( Variant< _Types... > const & __v )

◆ ignoringContext()

template<typename T , typename U >

ValueIgnoringContext< T, U > WTF::ignoringContext ( const U & value )

◆ in_place() [1/3]

in_place_tag WTF::in_place ( __in_place_private & )

◆ in_place() [2/3]

template<class _Type >

in_place_tag WTF::in_place ( __in_place_private::__type_holder< _Type > & )

◆ in_place() [3/3]

template<size_t _Index>

in_place_tag WTF::in_place ( __in_place_private::__value_holder< _Index > & )

◆ inContext()

template<typename T , typename U >

ValueInContext< T, U > WTF::inContext	(	const T &	value,
		U *	context
	)

◆ incrementWithSaturation()

template<typename T >

void WTF::incrementWithSaturation ( T & value )

inline

◆ initializeContextAwareUTextProvider()

void WTF::initializeContextAwareUTextProvider	(	UText *	text,
		const UTextFuncs *	funcs,
		const void *	string,
		unsigned	length,
		const UChar *	priorContext,
		int	priorContextLength
	)

inline

◆ initializeCurrentThreadInternal()

void WTF::initializeCurrentThreadInternal ( const char * threadName )

◆ initializeDates()

void WTF::initializeDates ( )

◆ initializeGCThreads()

WTF_EXPORT_PRIVATE void WTF::initializeGCThreads ( )

◆ initializeMainThread()

WTF_EXPORT_PRIVATE void WTF::initializeMainThread ( )

◆ initializeMainThreadPlatform()

void WTF::initializeMainThreadPlatform ( )

◆ initializeMainThreadToProcessMainThreadPlatform()

void WTF::initializeMainThreadToProcessMainThreadPlatform ( )

◆ initializeRandomNumberGenerator()

void WTF::initializeRandomNumberGenerator ( )

inline

◆ initializeThreading()

WTF_EXPORT_PRIVATE void WTF::initializeThreading ( )

◆ insertIntoBoundedVector()

template<typename VectorType , typename ElementType >

void WTF::insertIntoBoundedVector	(	VectorType &	vector,
		size_t	size,
		const ElementType &	element,
		size_t	index
	)

inline

◆ integerToSixCharacterHashString()

WTF_EXPORT_PRIVATE std::array< char, 7 > WTF::integerToSixCharacterHashString ( unsigned )

◆ intHash() [1/4]

unsigned WTF::intHash ( uint8_t key8 )

inline

◆ intHash() [2/4]

unsigned WTF::intHash ( uint16_t key16 )

inline

◆ intHash() [3/4]

unsigned WTF::intHash ( uint32_t key )

inline

◆ intHash() [4/4]

unsigned WTF::intHash ( uint64_t key )

inline

◆ is() [1/4]

template<typename ExpectedType , typename ArgType >

bool WTF::is ( ArgType & source )

inline

◆ is() [2/4]

template<typename ExpectedType , typename ArgType >

bool WTF::is ( ArgType * source )

inline

◆ is() [3/4]

template<typename ExpectedType , typename ArgType >

bool WTF::is ( Ref< ArgType > & source )

inline

◆ is() [4/4]

template<typename ExpectedType , typename ArgType >

bool WTF::is ( const Ref< ArgType > & source )

inline

◆ is8ByteAligned()

bool WTF::is8ByteAligned ( void * p )

inline

◆ isAlignedTo()

template<uintptr_t mask>

bool WTF::isAlignedTo ( const void * pointer )

inline

◆ isAlignedToMachineWord()

bool WTF::isAlignedToMachineWord ( const void * pointer )

inline

◆ isAllASCII()

template<typename CharacterType >

bool WTF::isAllASCII ( MachineWord word )

inline

◆ isAllSpecialCharacters()

template<bool isSpecialCharacter, typename CharacterType >

bool WTF::isAllSpecialCharacters	(	const CharacterType *	characters,
		size_t	length
	)

inline

◆ isASCII()

template<typename CharacterType >

bool WTF::isASCII ( CharacterType character )

inline

◆ isASCIIAlpha()

template<typename CharacterType >

bool WTF::isASCIIAlpha ( CharacterType character )

inline

◆ isASCIIAlphaCaselessEqual()

template<typename CharacterType >

bool WTF::isASCIIAlphaCaselessEqual	(	CharacterType	inputCharacter,
		char	expectedASCIILowercaseLetter
	)

inline

◆ isASCIIAlphanumeric()

template<typename CharacterType >

bool WTF::isASCIIAlphanumeric ( CharacterType character )

inline

◆ isASCIIBinaryDigit()

template<typename CharacterType >

bool WTF::isASCIIBinaryDigit ( CharacterType character )

inline

◆ isASCIIDigit()

template<typename CharacterType >

bool WTF::isASCIIDigit ( CharacterType character )

inline

◆ isASCIIHexDigit()

template<typename CharacterType >

bool WTF::isASCIIHexDigit ( CharacterType character )

inline

◆ isASCIILower()

template<typename CharacterType >

bool WTF::isASCIILower ( CharacterType character )

inline

◆ isASCIIOctalDigit()

template<typename CharacterType >

bool WTF::isASCIIOctalDigit ( CharacterType character )

inline

◆ isASCIIPrintable()

template<typename CharacterType >

bool WTF::isASCIIPrintable ( CharacterType character )

inline

◆ isASCIISpace()

template<typename CharacterType >

bool WTF::isASCIISpace ( CharacterType character )

inline

◆ isASCIIUpper()

template<typename CharacterType >

bool WTF::isASCIIUpper ( CharacterType character )

inline

◆ isCompilationThread()

WTF_EXPORT_PRIVATE bool WTF::isCompilationThread ( )

◆ isFastMallocEnabled()

WTF_EXPORT_PRIVATE bool WTF::isFastMallocEnabled ( )

◆ isHashTraitsEmptyValue()

template<typename Traits , typename T >

bool WTF::isHashTraitsEmptyValue ( const T & value )

inline

◆ isIntegral()

bool WTF::isIntegral ( float value )

inline

◆ isLeapYear()

WTF_EXPORT_PRIVATE bool WTF::isLeapYear ( int year )

◆ isMainThread()

WTF_EXPORT_PRIVATE bool WTF::isMainThread ( )

◆ isMainThreadOrGCThread()

WTF_EXPORT_PRIVATE bool WTF::isMainThreadOrGCThread ( )

◆ isPageAligned() [1/2]

bool WTF::isPageAligned ( void * address )

inline

◆ isPageAligned() [2/2]

bool WTF::isPageAligned ( size_t size )

inline

◆ isPointerAligned()

bool WTF::isPointerAligned ( void * p )

inline

◆ isPowerOfTwo()

bool WTF::isPowerOfTwo ( size_t size )

inline

◆ isSpaceOrNewline()

bool WTF::isSpaceOrNewline ( UChar c )

inline

◆ isStatelessLambda()

template<typename Func >

bool WTF::isStatelessLambda ( )

◆ isUIThread()

bool WTF::isUIThread ( )

inline

◆ isValidEnum()

template<typename E , typename T >

constexpr auto WTF::isValidEnum ( T t ) -> std::enable_if_t<std::is_enum<E>::value, bool>

◆ isWebThread()

bool WTF::isWebThread ( )

inline

◆ isWordTextBreak()

WTF_EXPORT_PRIVATE bool WTF::isWordTextBreak ( UBreakIterator * )

◆ jsCurrentTime()

double WTF::jsCurrentTime ( )

inline

◆ leftShiftWithSaturation()

template<typename T >

T WTF::leftShiftWithSaturation	(	T	value,
		unsigned	shiftAmount,
		T	max = `std::numeric_limits<T>::max()`
	)

inline

◆ lengthOfNullTerminatedString()

template<typename CharacterType >

unsigned WTF::lengthOfNullTerminatedString ( const CharacterType * string )

inline

◆ lengthOfNumberAsStringSigned()

template<typename SignedIntegerType >

unsigned WTF::lengthOfNumberAsStringSigned ( SignedIntegerType number )

inline

◆ lengthOfNumberAsStringUnsigned()

template<typename UnsignedIntegerType >

unsigned WTF::lengthOfNumberAsStringUnsigned ( UnsignedIntegerType number )

inline

◆ listDump()

template<typename T >

ListDump< T > WTF::listDump	(	const T &	list,
		const char *	comma = `", "`
	)

◆ listDumpInContext()

template<typename T , typename U >

ListDumpInContext< T, U > WTF::listDumpInContext	(	const T &	list,
		U *	context,
		const char *	comma = `", "`
	)

◆ loadLoadFence()

void WTF::loadLoadFence ( )

inline

◆ loadStoreFence()

void WTF::loadStoreFence ( )

inline

◆ loadUnaligned()

template<typename T >

T WTF::loadUnaligned ( const char * s )

inline

◆ lowerNibbleToASCIIHexDigit()

char WTF::lowerNibbleToASCIIHexDigit ( uint8_t value )

inline

◆ lowerNibbleToLowercaseASCIIHexDigit()

char WTF::lowerNibbleToLowercaseASCIIHexDigit ( uint8_t value )

inline

◆ MAKE_PRINT_ADAPTOR()

WTF::MAKE_PRINT_ADAPTOR	(	CharacterDump	,
		char	,
		dumpCharacter
	)

◆ makeBlockPtr()

template<typename R , typename... Args>

BlockPtr< R(Args...)> WTF::makeBlockPtr ( R(^)(Args...) block )

inline

◆ makeExpected() [1/2]

template<class T , class E = std::nullopt_t>

constexpr Expected< std::decay_t< T >, E > WTF::makeExpected ( T && v )

◆ makeExpected() [2/2]

Expected< void, std::nullopt_t > WTF::makeExpected ( )

inline

◆ makeExpectedFromError() [1/2]

template<class T , class E >

constexpr Expected< T, std::decay_t< E > > WTF::makeExpectedFromError ( E && e )

◆ makeExpectedFromError() [2/2]

template<class T , class E , class U >

constexpr Expected< T, E > WTF::makeExpectedFromError ( U && u )

◆ makeFilterIterator()

template<typename Predicate , typename Iterator >

FilterIterator< Predicate, Iterator > WTF::makeFilterIterator	(	Predicate &&	pred,
		Iterator &&	begin,
		Iterator &&	end
	)

inline

◆ makeIteratorRange()

template<typename Iterator >

IteratorRange< Iterator > WTF::makeIteratorRange	(	Iterator &&	begin,
		Iterator &&	end
	)

◆ makeRef()

template<typename T >

Ref< T > WTF::makeRef ( T & reference )

inline

◆ makeRefPtr() [1/2]

template<typename T >

RefPtr< T > WTF::makeRefPtr ( T * pointer )

inline

◆ makeRefPtr() [2/2]

template<typename T >

RefPtr< T > WTF::makeRefPtr ( T & reference )

inline

◆ makeRFC2822DateString()

String WTF::makeRFC2822DateString	(	unsigned	dayOfWeek,
		unsigned	day,
		unsigned	month,
		unsigned	year,
		unsigned	hours,
		unsigned	minutes,
		unsigned	seconds,
		int	utcOffset
	)

◆ makeScopeExit()

template<typename ExitFunction >

ScopeExit< ExitFunction > WTF::makeScopeExit ( ExitFunction && exitFunction )

◆ makeString() [1/2]

template<typename StringType >

String WTF::makeString ( StringType string )

◆ makeString() [2/2]

template<typename... StringTypes>

String WTF::makeString ( StringTypes... strings )

◆ makeStringAccumulator() [1/2]

template<typename ResultType , typename Adapter >

void WTF::makeStringAccumulator	(	ResultType *	result,
		Adapter	adapter
	)

inline

◆ makeStringAccumulator() [2/2]

template<typename ResultType , typename Adapter , typename... Adapters>

void WTF::makeStringAccumulator	(	ResultType *	result,
		Adapter	adapter,
		Adapters ...	adapters
	)

inline

◆ makeTransformIterator()

template<typename Transform , typename Iterator >

TransformIterator< Transform, Iterator > WTF::makeTransformIterator	(	Transform &&	transform,
		Iterator &&	iter
	)

inline

◆ makeUnexpected()

template<class E >

constexpr UnexpectedType< std::decay_t< E > > WTF::makeUnexpected ( E && v )

◆ makeUniqueRef()

template<typename T , class... Args>

UniqueRef< T > WTF::makeUniqueRef ( Args &&... args )

◆ makeVisitor()

template<class... F>

Visitor< F... > WTF::makeVisitor ( F... f )

◆ mapDump()

template<typename T >

MapDump< T > WTF::mapDump	(	const T &	map,
		const char *	arrow = `"=>"`,
		const char *	comma = `", "`
	)

◆ mayBeGCThread()

WTF_EXPORT_PRIVATE std::optional< GCThreadType > WTF::mayBeGCThread ( )

◆ memoryBarrierAfterLock()

void WTF::memoryBarrierAfterLock ( )

inline

◆ memoryBarrierBeforeUnlock()

void WTF::memoryBarrierBeforeUnlock ( )

inline

◆ memoryFootprint()

WTF_EXPORT_PRIVATE std::optional< size_t > WTF::memoryFootprint ( )

◆ monotonicallyIncreasingTime()

WTF_EXPORT_PRIVATE double WTF::monotonicallyIncreasingTime ( )

◆ monotonicallyIncreasingTimeMS()

double WTF::monotonicallyIncreasingTimeMS ( )

inline

◆ monthFromDayInYear()

WTF_EXPORT_PRIVATE int WTF::monthFromDayInYear	(	int	dayInYear,
		bool	leapYear
	)

◆ msToDays()

WTF_EXPORT_PRIVATE double WTF::msToDays ( double ms )

◆ msToHours()

WTF_EXPORT_PRIVATE int WTF::msToHours ( double ms )

◆ msToMinutes()

WTF_EXPORT_PRIVATE int WTF::msToMinutes ( double ms )

◆ msToYear()

WTF_EXPORT_PRIVATE int WTF::msToYear ( double ms )

◆ nanPropagatingMax()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type WTF::nanPropagatingMax	(	T	a,
		T	b
	)

inline

◆ nanPropagatingMin()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type WTF::nanPropagatingMin	(	T	a,
		T	b
	)

inline

◆ needToFlipBytesIfLittleEndian()

bool WTF::needToFlipBytesIfLittleEndian ( bool littleEndian )

inline

◆ nonEmptyRangesOverlap()

template<typename T >

bool WTF::nonEmptyRangesOverlap	(	T	leftMin,
		T	leftMax,
		T	rightMin,
		T	rightMax
	)

inline

◆ normalizeThreadName()

const char * WTF::normalizeThreadName ( const char * threadName )

◆ numberOfProcessorCores()

WTF_EXPORT_PRIVATE int WTF::numberOfProcessorCores ( )

◆ numberToFixedPrecisionString()

WTF_EXPORT_PRIVATE const char * WTF::numberToFixedPrecisionString	(	double	,
		unsigned	significantFigures,
		NumberToStringBuffer	,
		bool	truncateTrailingZeros = `false`
	)

◆ numberToFixedWidthString()

WTF_EXPORT_PRIVATE const char * WTF::numberToFixedWidthString	(	double	,
		unsigned	decimalPlaces,
		NumberToStringBuffer
	)

◆ numberToString()

WTF_EXPORT_PRIVATE const char * WTF::numberToString	(	double	,
		NumberToStringBuffer
	)

◆ numberToStringSigned()

template<typename T , typename SignedIntegerType >

IntegerToStringConversionTrait< T >::ReturnType WTF::numberToStringSigned	(	SignedIntegerType	number,
		typename IntegerToStringConversionTrait< T >::AdditionalArgumentType *	additionalArgument = `nullptr`
	)

inline

◆ numberToStringUnsigned()

template<typename T , typename UnsignedIntegerType >

IntegerToStringConversionTrait< T >::ReturnType WTF::numberToStringUnsigned	(	UnsignedIntegerType	number,
		typename IntegerToStringConversionTrait< T >::AdditionalArgumentType *	additionalArgument = `nullptr`
	)

inline

◆ numCharactersInGraphemeClusters()

WTF_EXPORT_PRIVATE unsigned WTF::numCharactersInGraphemeClusters	(	StringView	,
		unsigned
	)

◆ numGraphemeClusters()

WTF_EXPORT_PRIVATE unsigned WTF::numGraphemeClusters ( StringView )

◆ openLatin1ContextAwareUTextProvider()

UText * WTF::openLatin1ContextAwareUTextProvider	(	UTextWithBuffer *	utWithBuffer,
		const LChar *	string,
		unsigned	length,
		const UChar *	priorContext,
		int	priorContextLength,
		UErrorCode *	status
	)

◆ openLatin1UTextProvider()

WTF_EXPORT UText * WTF::openLatin1UTextProvider	(	UTextWithBuffer *	utWithBuffer,
		const LChar *	string,
		unsigned	length,
		UErrorCode *	status
	)

◆ openLineBreakIterator()

UBreakIterator * WTF::openLineBreakIterator ( const AtomicString & locale )

◆ openUTF16ContextAwareUTextProvider()

UText * WTF::openUTF16ContextAwareUTextProvider	(	UText *	,
		const UChar *	,
		unsigned	length,
		const UChar *	priorContext,
		int	priorContextLength,
		UErrorCode *
	)

◆ operator!()

bool WTF::operator! ( const String & str )

inline

◆ operator!=() [1/54]

template<class E >

constexpr bool WTF::operator!=	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator!=() [2/54]

bool WTF::operator!=	(	const CString &	a,
		const CString &	b
	)

inline

◆ operator!=() [3/54]

bool WTF::operator!=	(	const CString &	a,
		const char *	b
	)

inline

◆ operator!=() [4/54]

template<typename T , typename U >

bool WTF::operator!=	(	const PassRefPtr< T > &	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator!=() [5/54]

template<typename T , typename U >

bool WTF::operator!=	(	const PassRefPtr< T > &	a,
		const RefPtr< U > &	b
	)

inline

◆ operator!=() [6/54]

template<typename T , typename U >

bool WTF::operator!=	(	const RefPtr< T > &	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator!=() [7/54]

template<typename T , typename U >

bool WTF::operator!=	(	const PassRefPtr< T > &	a,
		U *	b
	)

inline

◆ operator!=() [8/54]

template<typename T , typename U >

bool WTF::operator!=	(	T *	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator!=() [9/54]

template<typename T , typename U >

bool WTF::operator!=	(	const WeakPtr< T > &	a,
		const WeakPtr< U > &	b
	)

inline

◆ operator!=() [10/54]

template<typename T , typename U >

bool WTF::operator!=	(	const WeakPtr< T > &	a,
		U *	b
	)

inline

◆ operator!=() [11/54]

template<typename T , typename U >

bool WTF::operator!=	(	T *	a,
		const WeakPtr< U > &	b
	)

inline

◆ operator!=() [12/54]

template<typename T , typename U , typename V >

bool WTF::operator!=	(	const HashTableConstKeysIterator< T, U, V > &	a,
		const HashTableConstKeysIterator< T, U, V > &	b
	)

inline

◆ operator!=() [13/54]

template<typename T , typename U , typename V >

bool WTF::operator!=	(	const HashTableConstValuesIterator< T, U, V > &	a,
		const HashTableConstValuesIterator< T, U, V > &	b
	)

inline

◆ operator!=() [14/54]

bool WTF::operator!=	(	StringView	a,
		StringView	b
	)

inline

◆ operator!=() [15/54]

bool WTF::operator!=	(	StringView	a,
		const LChar *	b
	)

inline

◆ operator!=() [16/54]

template<typename T , typename U , typename V >

bool WTF::operator!=	(	const HashTableKeysIterator< T, U, V > &	a,
		const HashTableKeysIterator< T, U, V > &	b
	)

inline

◆ operator!=() [17/54]

bool WTF::operator!=	(	StringView	a,
		const char *	b
	)

inline

◆ operator!=() [18/54]

bool WTF::operator!=	(	const LChar *	a,
		StringView	b
	)

inline

◆ operator!=() [19/54]

bool WTF::operator!=	(	const char *	a,
		StringView	b
	)

inline

◆ operator!=() [20/54]

template<typename T , typename U , typename V >

bool WTF::operator!=	(	const HashTableValuesIterator< T, U, V > &	a,
		const HashTableValuesIterator< T, U, V > &	b
	)

inline

◆ operator!=() [21/54]

bool WTF::operator!=	(	const AtomicString &	a,
		const AtomicString &	b
	)

inline

◆ operator!=() [22/54]

bool WTF::operator!=	(	const AtomicString &	a,
		const LChar *	b
	)

inline

◆ operator!=() [23/54]

bool WTF::operator!=	(	const AtomicString &	a,
		const char *	b
	)

inline

◆ operator!=() [24/54]

bool WTF::operator!=	(	const AtomicString &	a,
		const String &	b
	)

inline

◆ operator!=() [25/54]

template<typename T , typename U >

bool WTF::operator!=	(	const RefPtr< T > &	a,
		const RefPtr< U > &	b
	)

inline

◆ operator!=() [26/54]

bool WTF::operator!=	(	const AtomicString &	a,
		const Vector< UChar > &	b
	)

inline

◆ operator!=() [27/54]

bool WTF::operator!=	(	const LChar *	a,
		const AtomicString &	b
	)

inline

◆ operator!=() [28/54]

bool WTF::operator!=	(	const String &	a,
		const AtomicString &	b
	)

inline

◆ operator!=() [29/54]

bool WTF::operator!=	(	const Vector< UChar > &	a,
		const AtomicString &	b
	)

inline

◆ operator!=() [30/54]

template<typename T , typename U >

bool WTF::operator!=	(	const RefPtr< T > &	a,
		U *	b
	)

inline

◆ operator!=() [31/54]

template<typename T , typename U >

bool WTF::operator!=	(	T *	a,
		const RefPtr< U > &	b
	)

inline

◆ operator!=() [32/54]

bool WTF::operator!=	(	const StringBuilder &	a,
		const StringBuilder &	b
	)

inline

◆ operator!=() [33/54]

bool WTF::operator!=	(	const StringBuilder &	a,
		const String &	b
	)

inline

◆ operator!=() [34/54]

bool WTF::operator!=	(	const String &	a,
		const StringBuilder &	b
	)

inline

◆ operator!=() [35/54]

template<class T , class E >

constexpr bool WTF::operator!=	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator!=() [36/54]

template<class T , class E >

constexpr bool WTF::operator!=	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator!=() [37/54]

template<class T , class E >

constexpr bool WTF::operator!=	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator!=() [38/54]

template<class T , class E >

constexpr bool WTF::operator!=	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator!=() [39/54]

template<class T , class E >

constexpr bool WTF::operator!=	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator!=() [40/54]

bool WTF::operator!=	(	const String &	a,
		const String &	b
	)

inline

◆ operator!=() [41/54]

bool WTF::operator!=	(	const String &	a,
		const LChar *	b
	)

inline

◆ operator!=() [42/54]

bool WTF::operator!=	(	const String &	a,
		const char *	b
	)

inline

◆ operator!=() [43/54]

bool WTF::operator!=	(	const LChar *	a,
		const String &	b
	)

inline

◆ operator!=() [44/54]

bool WTF::operator!=	(	const char *	a,
		const String &	b
	)

inline

◆ operator!=() [45/54]

template<size_t inlineCapacity>

bool WTF::operator!=	(	const Vector< char, inlineCapacity > &	a,
		const String &	b
	)

inline

◆ operator!=() [46/54]

template<size_t inlineCapacity>

bool WTF::operator!=	(	const String &	a,
		const Vector< char, inlineCapacity > &	b
	)

inline

◆ operator!=() [47/54]

template<typename T , typename U , typename V , typename W , typename X >

bool WTF::operator!=	(	const HashMap< T, U, V, W, X > &	a,
		const HashMap< T, U, V, W, X > &	b
	)

inline

◆ operator!=() [48/54]

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>

bool WTF::operator!=	(	const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	a,
		const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	b
	)

inline

◆ operator!=() [49/54]

template<typename T , typename U >

bool WTF::operator!=	(	const HashTableConstIteratorAdapter< T, U > &	a,
		const HashTableConstIteratorAdapter< T, U > &	b
	)

inline

◆ operator!=() [50/54]

template<typename T , typename U >

bool WTF::operator!=	(	const HashTableIteratorAdapter< T, U > &	a,
		const HashTableIteratorAdapter< T, U > &	b
	)

inline

◆ operator!=() [51/54]

template<typename T , typename U >

bool WTF::operator!=	(	const HashTableConstIteratorAdapter< T, U > &	a,
		const HashTableIteratorAdapter< T, U > &	b
	)

inline

◆ operator!=() [52/54]

template<typename T , typename U >

bool WTF::operator!=	(	const HashTableIteratorAdapter< T, U > &	a,
		const HashTableConstIteratorAdapter< T, U > &	b
	)

inline

◆ operator!=() [53/54]

template<typename ... _Types>

constexpr bool WTF::operator!=	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator!=() [54/54]

constexpr bool WTF::operator!=	(	Monostate const &	,
		Monostate const &
	)

inline

◆ operator*()

MediaTime WTF::operator*	(	int32_t	lhs,
		const MediaTime &	rhs
	)

inline

◆ operator+() [1/11]

StringAppend< const char *, String > WTF::operator+	(	const char *	string1,
		const String &	string2
	)

inline

◆ operator+() [2/11]

StringAppend< const char *, AtomicString > WTF::operator+	(	const char *	string1,
		const AtomicString &	string2
	)

inline

◆ operator+() [3/11]

template<typename U , typename V >

StringAppend< const char *, StringAppend< U, V > > WTF::operator+	(	const char *	string1,
		const StringAppend< U, V > &	string2
	)

inline

◆ operator+() [4/11]

StringAppend< const UChar *, String > WTF::operator+	(	const UChar *	string1,
		const String &	string2
	)

inline

◆ operator+() [5/11]

StringAppend< const UChar *, AtomicString > WTF::operator+	(	const UChar *	string1,
		const AtomicString &	string2
	)

inline

◆ operator+() [6/11]

template<typename U , typename V >

StringAppend< const UChar *, StringAppend< U, V > > WTF::operator+	(	const UChar *	string1,
		const StringAppend< U, V > &	string2
	)

inline

◆ operator+() [7/11]

StringAppend< ASCIILiteral, String > WTF::operator+	(	const ASCIILiteral &	string1,
		const String &	string2
	)

inline

◆ operator+() [8/11]

StringAppend< ASCIILiteral, AtomicString > WTF::operator+	(	const ASCIILiteral &	string1,
		const AtomicString &	string2
	)

inline

◆ operator+() [9/11]

template<typename U , typename V >

StringAppend< ASCIILiteral, StringAppend< U, V > > WTF::operator+	(	const ASCIILiteral &	string1,
		const StringAppend< U, V > &	string2
	)

inline

◆ operator+() [10/11]

template<typename T >

StringAppend< String, T > WTF::operator+	(	const String &	string1,
		T	string2
	)

◆ operator+() [11/11]

template<typename U , typename V , typename W >

StringAppend< StringAppend< U, V >, W > WTF::operator+	(	const StringAppend< U, V > &	string1,
		W	string2
	)

◆ operator<() [1/10]

template<class E >

constexpr bool WTF::operator<	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator<() [2/10]

WTF_EXPORT_PRIVATE bool WTF::operator<	(	const CString &	a,
		const CString &	b
	)

◆ operator<() [3/10]

template<class T , class E >

constexpr bool WTF::operator<	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator<() [4/10]

template<class E >

constexpr bool WTF::operator<	(	const Expected< void, E > &	x,
		const Expected< void, E > &	y
	)

◆ operator<() [5/10]

template<class T , class E >

constexpr bool WTF::operator<	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator<() [6/10]

template<class T , class E >

constexpr bool WTF::operator<	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator<() [7/10]

template<class T , class E >

constexpr bool WTF::operator<	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator<() [8/10]

template<class T , class E >

constexpr bool WTF::operator<	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator<() [9/10]

template<typename ... _Types>

constexpr bool WTF::operator<	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator<() [10/10]

constexpr bool WTF::operator<	(	Monostate const &	,
		Monostate const &
	)

inline

◆ operator<<() [1/9]

template<class E >

std::ostream& WTF::operator<<	(	std::ostream &	os,
		const UnexpectedType< E > &	u
	)

◆ operator<<() [2/9]

std::ostream& WTF::operator<<	(	std::ostream &	out,
		const MediaTime &	val
	)

◆ operator<<() [3/9]

std::ostream& WTF::operator<<	(	std::ostream &	os,
		const String &	string
	)

inline

◆ operator<<() [4/9]

template<class T , class E >

std::ostream& WTF::operator<<	(	std::ostream &	os,
		const Expected< T, E > &	e
	)

◆ operator<<() [5/9]

template<class E >

std::ostream& WTF::operator<<	(	std::ostream &	os,
		const Expected< void, E > &	e
	)

◆ operator<<() [6/9]

std::basic_ostream<char>& WTF::operator<<	(	std::basic_ostream< char > &	out,
		WallTime	value
	)

◆ operator<<() [7/9]

std::basic_ostream<char>& WTF::operator<<	(	std::basic_ostream< char > &	out,
		MonotonicTime	value
	)

◆ operator<<() [8/9]

std::basic_ostream<char>& WTF::operator<<	(	std::basic_ostream< char > &	out,
		TimeWithDynamicClockType	value
	)

◆ operator<<() [9/9]

std::basic_ostream<char>& WTF::operator<<	(	std::basic_ostream< char > &	out,
		Seconds	value
	)

◆ operator<=() [1/8]

template<class E >

constexpr bool WTF::operator<=	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator<=() [2/8]

template<class T , class E >

constexpr bool WTF::operator<=	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator<=() [3/8]

template<class T , class E >

constexpr bool WTF::operator<=	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator<=() [4/8]

template<class T , class E >

constexpr bool WTF::operator<=	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator<=() [5/8]

template<class T , class E >

constexpr bool WTF::operator<=	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator<=() [6/8]

template<class T , class E >

constexpr bool WTF::operator<=	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator<=() [7/8]

template<typename ... _Types>

constexpr bool WTF::operator<=	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator<=() [8/8]

constexpr bool WTF::operator<=	(	Monostate const &	,
		Monostate const &
	)

inline

◆ operator==() [1/55]

template<class E >

constexpr bool WTF::operator==	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator==() [2/55]

WTF_EXPORT_PRIVATE bool WTF::operator==	(	const CString &	a,
		const CString &	b
	)

◆ operator==() [3/55]

WTF_EXPORT_PRIVATE bool WTF::operator==	(	const CString &	a,
		const char *	b
	)

◆ operator==() [4/55]

template<typename T , typename U >

bool WTF::operator==	(	const PassRefPtr< T > &	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator==() [5/55]

template<typename T , typename U >

bool WTF::operator==	(	const PassRefPtr< T > &	a,
		const RefPtr< U > &	b
	)

inline

◆ operator==() [6/55]

template<typename T , typename U >

bool WTF::operator==	(	const RefPtr< T > &	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator==() [7/55]

template<typename T , typename U >

bool WTF::operator==	(	const PassRefPtr< T > &	a,
		U *	b
	)

inline

◆ operator==() [8/55]

template<typename T , typename U >

bool WTF::operator==	(	T *	a,
		const PassRefPtr< U > &	b
	)

inline

◆ operator==() [9/55]

template<typename T , typename U >

bool WTF::operator==	(	const WeakPtr< T > &	a,
		const WeakPtr< U > &	b
	)

inline

◆ operator==() [10/55]

template<typename T , typename U >

bool WTF::operator==	(	const WeakPtr< T > &	a,
		U *	b
	)

inline

◆ operator==() [11/55]

template<typename T , typename U >

bool WTF::operator==	(	T *	a,
		const WeakPtr< U > &	b
	)

inline

◆ operator==() [12/55]

template<typename T , typename U , typename V >

bool WTF::operator==	(	const HashTableConstKeysIterator< T, U, V > &	a,
		const HashTableConstKeysIterator< T, U, V > &	b
	)

inline

◆ operator==() [13/55]

template<typename T , typename U , typename V >

bool WTF::operator==	(	const HashTableConstValuesIterator< T, U, V > &	a,
		const HashTableConstValuesIterator< T, U, V > &	b
	)

inline

◆ operator==() [14/55]

bool WTF::operator==	(	StringView	a,
		StringView	b
	)

inline

◆ operator==() [15/55]

bool WTF::operator==	(	StringView	a,
		const LChar *	b
	)

inline

◆ operator==() [16/55]

template<typename T , typename U , typename V >

bool WTF::operator==	(	const HashTableKeysIterator< T, U, V > &	a,
		const HashTableKeysIterator< T, U, V > &	b
	)

inline

◆ operator==() [17/55]

bool WTF::operator==	(	StringView	a,
		const char *	b
	)

inline

◆ operator==() [18/55]

bool WTF::operator==	(	const LChar *	a,
		StringView	b
	)

inline

◆ operator==() [19/55]

bool WTF::operator==	(	const char *	a,
		StringView	b
	)

inline

◆ operator==() [20/55]

template<typename T , typename U >

bool WTF::operator==	(	const RefPtr< T > &	a,
		const RefPtr< U > &	b
	)

inline

◆ operator==() [21/55]

bool WTF::operator==	(	const AtomicString &	a,
		const AtomicString &	b
	)

inline

◆ operator==() [22/55]

bool WTF::operator==	(	const AtomicString &	,
		const LChar *
	)

◆ operator==() [23/55]

bool WTF::operator==	(	const AtomicString &	a,
		const char *	b
	)

inline

◆ operator==() [24/55]

template<typename T , typename U , typename V >

bool WTF::operator==	(	const HashTableValuesIterator< T, U, V > &	a,
		const HashTableValuesIterator< T, U, V > &	b
	)

inline

◆ operator==() [25/55]

template<typename T , typename U >

bool WTF::operator==	(	const RefPtr< T > &	a,
		U *	b
	)

inline

◆ operator==() [26/55]

bool WTF::operator==	(	const AtomicString &	a,
		const Vector< UChar > &	b
	)

inline

◆ operator==() [27/55]

bool WTF::operator==	(	const AtomicString &	a,
		const String &	b
	)

inline

◆ operator==() [28/55]

bool WTF::operator==	(	const LChar *	a,
		const AtomicString &	b
	)

inline

◆ operator==() [29/55]

bool WTF::operator==	(	const String &	a,
		const AtomicString &	b
	)

inline

◆ operator==() [30/55]

bool WTF::operator==	(	const Vector< UChar > &	a,
		const AtomicString &	b
	)

inline

◆ operator==() [31/55]

template<typename T , typename U >

bool WTF::operator==	(	T *	a,
		const RefPtr< U > &	b
	)

inline

◆ operator==() [32/55]

bool WTF::operator==	(	const StringBuilder &	a,
		const StringBuilder &	b
	)

inline

◆ operator==() [33/55]

bool WTF::operator==	(	const StringBuilder &	a,
		const String &	b
	)

inline

◆ operator==() [34/55]

bool WTF::operator==	(	const String &	a,
		const StringBuilder &	b
	)

inline

◆ operator==() [35/55]

template<class T , class E >

constexpr bool WTF::operator==	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator==() [36/55]

template<class E >

constexpr bool WTF::operator==	(	const Expected< void, E > &	x,
		const Expected< void, E > &	y
	)

◆ operator==() [37/55]

template<class T , class E >

constexpr bool WTF::operator==	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator==() [38/55]

template<class T , class E >

constexpr bool WTF::operator==	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator==() [39/55]

template<class T , class E >

constexpr bool WTF::operator==	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator==() [40/55]

template<class T , class E >

constexpr bool WTF::operator==	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator==() [41/55]

bool WTF::operator==	(	const String &	a,
		const String &	b
	)

inline

◆ operator==() [42/55]

bool WTF::operator==	(	const String &	a,
		const LChar *	b
	)

inline

◆ operator==() [43/55]

bool WTF::operator==	(	const String &	a,
		const char *	b
	)

inline

◆ operator==() [44/55]

bool WTF::operator==	(	const LChar *	a,
		const String &	b
	)

inline

◆ operator==() [45/55]

bool WTF::operator==	(	const char *	a,
		const String &	b
	)

inline

◆ operator==() [46/55]

template<size_t inlineCapacity>

bool WTF::operator==	(	const Vector< char, inlineCapacity > &	a,
		const String &	b
	)

inline

◆ operator==() [47/55]

template<size_t inlineCapacity>

bool WTF::operator==	(	const String &	a,
		const Vector< char, inlineCapacity > &	b
	)

inline

◆ operator==() [48/55]

template<typename T , typename U , typename V , typename W , typename X >

bool WTF::operator==	(	const HashMap< T, U, V, W, X > &	a,
		const HashMap< T, U, V, W, X > &	b
	)

◆ operator==() [49/55]

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>

bool WTF::operator==	(	const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	a,
		const Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	b
	)

◆ operator==() [50/55]

template<typename T , typename U >

bool WTF::operator==	(	const HashTableConstIteratorAdapter< T, U > &	a,
		const HashTableConstIteratorAdapter< T, U > &	b
	)

inline

◆ operator==() [51/55]

template<typename T , typename U >

bool WTF::operator==	(	const HashTableIteratorAdapter< T, U > &	a,
		const HashTableIteratorAdapter< T, U > &	b
	)

inline

◆ operator==() [52/55]

template<typename T , typename U >

bool WTF::operator==	(	const HashTableConstIteratorAdapter< T, U > &	a,
		const HashTableIteratorAdapter< T, U > &	b
	)

inline

◆ operator==() [53/55]

template<typename T , typename U >

bool WTF::operator==	(	const HashTableIteratorAdapter< T, U > &	a,
		const HashTableConstIteratorAdapter< T, U > &	b
	)

inline

◆ operator==() [54/55]

template<typename ... _Types>

constexpr bool WTF::operator==	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator==() [55/55]

constexpr bool WTF::operator==	(	Monostate const &	,
		Monostate const &
	)

inline

◆ operator>() [1/8]

template<class E >

constexpr bool WTF::operator>	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator>() [2/8]

template<class T , class E >

constexpr bool WTF::operator>	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator>() [3/8]

template<class T , class E >

constexpr bool WTF::operator>	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator>() [4/8]

template<class T , class E >

constexpr bool WTF::operator>	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator>() [5/8]

template<class T , class E >

constexpr bool WTF::operator>	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator>() [6/8]

template<class T , class E >

constexpr bool WTF::operator>	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator>() [7/8]

template<typename ... _Types>

constexpr bool WTF::operator>	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator>() [8/8]

constexpr bool WTF::operator>	(	Monostate const &	,
		Monostate const &
	)

inline

◆ operator>=() [1/8]

template<class E >

constexpr bool WTF::operator>=	(	const UnexpectedType< E > &	lhs,
		const UnexpectedType< E > &	rhs
	)

◆ operator>=() [2/8]

template<class T , class E >

constexpr bool WTF::operator>=	(	const Expected< T, E > &	x,
		const Expected< T, E > &	y
	)

◆ operator>=() [3/8]

template<class T , class E >

constexpr bool WTF::operator>=	(	const Expected< T, E > &	x,
		const T &	y
	)

◆ operator>=() [4/8]

template<class T , class E >

constexpr bool WTF::operator>=	(	const T &	x,
		const Expected< T, E > &	y
	)

◆ operator>=() [5/8]

template<class T , class E >

constexpr bool WTF::operator>=	(	const Expected< T, E > &	x,
		const UnexpectedType< E > &	y
	)

◆ operator>=() [6/8]

template<class T , class E >

constexpr bool WTF::operator>=	(	const UnexpectedType< E > &	x,
		const Expected< T, E > &	y
	)

◆ operator>=() [7/8]

template<typename ... _Types>

constexpr bool WTF::operator>=	(	Variant< _Types... > const &	__lhs,
		Variant< _Types... > const &	__rhs
	)

◆ operator>=() [8/8]

constexpr bool WTF::operator>=	(	Monostate const &	,
		Monostate const &
	)

inline

◆ pageMask()

WTF_EXPORT_PRIVATE size_t WTF::pageMask ( )

◆ pageSize()

WTF_EXPORT_PRIVATE size_t WTF::pageSize ( )

◆ pairIntHash()

unsigned WTF::pairIntHash	(	unsigned	key1,
		unsigned	key2
	)

inline

◆ parseDateFromNullTerminatedCharacters() [1/2]

WTF_EXPORT_PRIVATE double WTF::parseDateFromNullTerminatedCharacters ( const char * dateString )

◆ parseDateFromNullTerminatedCharacters() [2/2]

WTF_EXPORT_PRIVATE double WTF::parseDateFromNullTerminatedCharacters	(	const char *	dateString,
		bool &	haveTZ,
		int &	offset
	)

◆ parseDouble() [1/3]

double WTF::parseDouble	(	const LChar *	string,
		size_t	length,
		size_t &	parsedLength
	)

inline

◆ parseDouble() [2/3]

double WTF::parseDouble	(	const UChar *	string,
		size_t	length,
		size_t &	parsedLength
	)

inline

◆ parseDouble() [3/3]

double WTF::parseDouble	(	StringView	string,
		size_t &	parsedLength
	)

inline

◆ parseES5DateFromNullTerminatedCharacters()

WTF_EXPORT_PRIVATE double WTF::parseES5DateFromNullTerminatedCharacters ( const char * dateString )

◆ placeByteAsHex()

template<typename T >

void WTF::placeByteAsHex	(	unsigned char	byte,
		T &	destination,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ placeByteAsHexCompressIfPossible()

template<typename T >

void WTF::placeByteAsHexCompressIfPossible	(	unsigned char	byte,
		T &	destination,
		unsigned &	index,
		HexConversionMode	mode = `Uppercase`
	)

inline

◆ platformUserPreferredLanguages()

WTF_EXPORT_PRIVATE Vector< String > WTF::platformUserPreferredLanguages ( )

◆ pointerDump()

template<typename T >

PointerDump< T > WTF::pointerDump ( const T * ptr )

◆ pointerDumpInContext()

template<typename T , typename U >

PointerDumpInContext< T, U > WTF::pointerDumpInContext	(	const T *	ptr,
		U *	context
	)

◆ pointerListDump()

template<typename T >

PointerListDump< T > WTF::pointerListDump	(	const T &	list,
		const char *	comma = `", "`
	)

◆ printInternal() [1/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::CodeType
	)

◆ printInternal() [2/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		ClockType
	)

◆ printInternal() [3/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::CollectionScope
	)

◆ printInternal() [4/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::DestructionMode
	)

◆ printInternal() [5/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::TagRegistersMode
	)

◆ printInternal() [6/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::Profiler::CompilationKind
	)

◆ printInternal() [7/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ConstantMode
	)

◆ printInternal() [8/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ToThisStatus
	)

◆ printInternal() [9/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::GCConductor
	)

◆ printInternal() [10/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::TypeofType
	)

◆ printInternal() [11/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::CodeSpecializationKind
	)

◆ printInternal() [12/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::Profiler::JettisonReason
	)

◆ printInternal() [13/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ExceptionEventLocation
	)

◆ printInternal() [14/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::CallMode
	)

◆ printInternal() [15/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::MutatorState
	)

◆ printInternal() [16/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::ArrayBufferSharingMode	mode
	)

inline

◆ printInternal() [17/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::DFG::CompilationMode
	)

◆ printInternal() [18/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::GCLogging::Level
	)

◆ printInternal() [19/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ExitingJITType
	)

◆ printInternal() [20/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::ConstraintVolatility	volatility
	)

inline

◆ printInternal() [21/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::CompilationResult
	)

◆ printInternal() [22/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ExitKind
	)

◆ printInternal() [23/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::CollectorPhase
	)

◆ printInternal() [24/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::HeapCell::Kind
	)

◆ printInternal() [25/80]

void WTF::printInternal	(	PrintStream &	,
		GCThreadType
	)

◆ printInternal() [26/80]

void WTF::printInternal	(	PrintStream &	out,
		const ArithProfile &	profile
	)

◆ printInternal() [27/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		const char *
	)

◆ printInternal() [28/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		const StringView &
	)

◆ printInternal() [29/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::PutByIdFlags
	)

◆ printInternal() [30/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		const CString &
	)

◆ printInternal() [31/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		const String &
	)

◆ printInternal() [32/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		const StringImpl *
	)

◆ printInternal() [33/80]

void WTF::printInternal	(	PrintStream &	out,
		const AtomicStringImpl *	value
	)

inline

◆ printInternal() [34/80]

void WTF::printInternal	(	PrintStream &	out,
		const UniquedStringImpl *	value
	)

inline

◆ printInternal() [35/80]

void WTF::printInternal	(	PrintStream &	out,
		const UniquedStringImpl &	value
	)

inline

◆ printInternal() [36/80]

void WTF::printInternal	(	PrintStream &	out,
		char *	value
	)

inline

◆ printInternal() [37/80]

void WTF::printInternal	(	PrintStream &	out,
		CString &	value
	)

inline

◆ printInternal() [38/80]

void WTF::printInternal	(	PrintStream &	out,
		String &	value
	)

inline

◆ printInternal() [39/80]

void WTF::printInternal	(	PrintStream &	out,
		StringImpl *	value
	)

inline

◆ printInternal() [40/80]

void WTF::printInternal	(	PrintStream &	out,
		AtomicStringImpl *	value
	)

inline

◆ printInternal() [41/80]

void WTF::printInternal	(	PrintStream &	out,
		UniquedStringImpl *	value
	)

inline

◆ printInternal() [42/80]

void WTF::printInternal	(	PrintStream &	out,
		UniquedStringImpl &	value
	)

inline

◆ printInternal() [43/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		bool
	)

◆ printInternal() [44/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		signed	char
	)

◆ printInternal() [45/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		unsigned	char
	)

◆ printInternal() [46/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		short
	)

◆ printInternal() [47/80]

void WTF::printInternal	(	PrintStream &	out,
		ICEvent::Kind	kind
	)

◆ printInternal() [48/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		int
	)

◆ printInternal() [49/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		unsigned
	)

◆ printInternal() [50/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		long
	)

◆ printInternal() [51/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		unsigned long	long
	)

◆ printInternal() [52/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		float
	)

◆ printInternal() [53/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		double
	)

◆ printInternal() [54/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::ParserError::SyntaxErrorType	type
	)

inline

◆ printInternal() [55/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		RawPointer
	)

◆ printInternal() [56/80]

void WTF::printInternal	(	PrintStream &	out,
		const JSC::ObservedType &	observedType
	)

◆ printInternal() [57/80]

template<typename T >

void WTF::printInternal	(	PrintStream &	out,
		const T &	value
	)

◆ printInternal() [58/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::DataFormat
	)

◆ printInternal() [59/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	out,
		unsigned short	value
	)

◆ printInternal() [60/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::ParserError::ErrorType	type
	)

inline

◆ printInternal() [61/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	out,
		long	value
	)

◆ printInternal() [62/80]

WTF_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	out,
		unsigned long	value
	)

◆ printInternal() [63/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::B3::Air::Opcode	opcode
	)

◆ printInternal() [64/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::ErrorType
	)

◆ printInternal() [65/80]

void WTF::printInternal	(	PrintStream &	out,
		OpcodeID	opcode
	)

◆ printInternal() [66/80]

template<typename T >

void WTF::printInternal	(	PrintStream &	out,
		const std::unique_ptr< T > &	value
	)

◆ printInternal() [67/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::TypedArrayType
	)

◆ printInternal() [68/80]

template<typename T >

void WTF::printInternal	(	PrintStream &	out,
		const RefPtr< T > &	value
	)

◆ printInternal() [69/80]

JS_EXPORT_PRIVATE void WTF::printInternal	(	PrintStream &	,
		JSC::TypedArrayMode
	)

◆ printInternal() [70/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::VarKind
	)

◆ printInternal() [71/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::JITCode::JITType
	)

◆ printInternal() [72/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::InlineCallFrame::Kind
	)

◆ printInternal() [73/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::InferredType::Kind
	)

◆ printInternal() [74/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::PropertyCondition::Kind
	)

◆ printInternal() [75/80]

template<typename T >

void WTF::printInternal	(	PrintStream &	out,
		const std::optional< T > &	value
	)

◆ printInternal() [76/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::FPRReg	reg
	)

inline

◆ printInternal() [77/80]

void WTF::printInternal	(	PrintStream &	,
		JSC::DFG::CapabilityLevel
	)

◆ printInternal() [78/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::MarkedBlock::Handle::SweepMode
	)

◆ printInternal() [79/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::GPRReg	reg
	)

inline

◆ printInternal() [80/80]

void WTF::printInternal	(	PrintStream &	out,
		JSC::Variable::VariableKind	kind
	)

◆ productOverflows()

template<typename T , typename... Args>

bool WTF::productOverflows ( Args... args )

◆ ramSize()

WTF_EXPORT_PRIVATE size_t WTF::ramSize ( )

◆ randomNumber()

WTF_EXPORT_PRIVATE double WTF::randomNumber ( )

◆ rangesOverlap()

template<typename T >

bool WTF::rangesOverlap	(	T	leftMin,
		T	leftMax,
		T	rightMin,
		T	rightMax
	)

inline

◆ refGPtr() [1/3]

template<>

SoupBuffer* WTF::refGPtr ( SoupBuffer * ptr )

◆ refGPtr() [2/3]

template<>

GtkTargetList * WTF::refGPtr ( GtkTargetList * ptr )

◆ refGPtr() [3/3]

template<>

GtkWidgetPath * WTF::refGPtr ( GtkWidgetPath * ptr )

◆ refIfNotNull()

template<typename T >

ALWAYS_INLINE void WTF::refIfNotNull ( T * ptr )

◆ registerGCThread()

WTF_EXPORT_PRIVATE void WTF::registerGCThread ( GCThreadType )

◆ releaseFastMallocFreeMemory()

WTF_EXPORT_PRIVATE void WTF::releaseFastMallocFreeMemory ( )

◆ releaseFastMallocFreeMemoryForThisThread()

WTF_EXPORT_PRIVATE void WTF::releaseFastMallocFreeMemoryForThisThread ( )

◆ releaseLineBreakIterator()

WTF_EXPORT_PRIVATE void WTF::releaseLineBreakIterator ( UBreakIterator * )

◆ removeIterator()

template<typename Key , typename Value , typename Extractor , typename HashFunctions , typename Traits , typename KeyTraits >

void WTF::removeIterator ( HashTableConstIterator< Key, Value, Extractor, HashFunctions, Traits, KeyTraits > * it )

◆ resetAccumulatedLogs()

WTF_EXPORT_PRIVATE void WTF::resetAccumulatedLogs ( )

◆ reverseFind() [1/3]

template<typename CharacterType >

size_t WTF::reverseFind	(	const CharacterType *	characters,
		unsigned	length,
		CharacterType	matchCharacter,
		unsigned	index = `UINT_MAX`
	)

inline

◆ reverseFind() [2/3]

ALWAYS_INLINE size_t WTF::reverseFind	(	const UChar *	characters,
		unsigned	length,
		LChar	matchCharacter,
		unsigned	index = `UINT_MAX`
	)

◆ reverseFind() [3/3]

size_t WTF::reverseFind	(	const LChar *	characters,
		unsigned	length,
		UChar	matchCharacter,
		unsigned	index = `UINT_MAX`
	)

inline

◆ reverseFindLineTerminator()

template<typename CharacterType >

size_t WTF::reverseFindLineTerminator	(	const CharacterType *	characters,
		unsigned	length,
		unsigned	index = `UINT_MAX`
	)

inline

◆ roundUpToMultipleOf() [1/2]

size_t WTF::roundUpToMultipleOf	(	size_t	divisor,
		size_t	x
	)

inline

◆ roundUpToMultipleOf() [2/2]

template<size_t divisor>

constexpr size_t WTF::roundUpToMultipleOf ( size_t x )

inline

◆ roundUpToMultipleOfImpl()

ALWAYS_INLINE constexpr size_t WTF::roundUpToMultipleOfImpl	(	size_t	divisor,
		size_t	x
	)

◆ roundUpToMultipleOfImpl0()

ALWAYS_INLINE constexpr size_t WTF::roundUpToMultipleOfImpl0	(	size_t	remainderMask,
		size_t	x
	)

◆ roundUpToPowerOfTwo()

uint32_t WTF::roundUpToPowerOfTwo ( uint32_t v )

inline

◆ safeCast()

template<typename ToType , typename FromType >

ToType WTF::safeCast ( FromType value )

inline

◆ safeFPDivision()

template<typename T >

std::enable_if< std::is_floating_point< T >::value, T >::type WTF::safeFPDivision	(	T	u,
		T	v
	)

inline

◆ scheduleDispatchFunctionsOnMainThread()

void WTF::scheduleDispatchFunctionsOnMainThread ( )

◆ scopedLambda() [1/2]

template<typename FunctionType , typename Functor >

ScopedLambdaFunctor< FunctionType, Functor > WTF::scopedLambda ( const Functor & functor )

◆ scopedLambda() [2/2]

template<typename FunctionType , typename Functor >

ScopedLambdaFunctor< FunctionType, Functor > WTF::scopedLambda ( Functor && functor )

◆ scopedLambdaRef()

template<typename FunctionType , typename Functor >

ScopedLambdaRefFunctor< FunctionType, Functor > WTF::scopedLambdaRef ( const Functor & functor )

◆ sentenceBreakIterator()

WTF_EXPORT_PRIVATE UBreakIterator * WTF::sentenceBreakIterator ( StringView )

◆ setCloseOnExec()

bool WTF::setCloseOnExec ( int fileDescriptor )

◆ setCurrentThreadIsUserInitiated()

WTF_EXPORT_PRIVATE void WTF::setCurrentThreadIsUserInitiated ( int relativePriority = 0 )

◆ setCurrentThreadIsUserInteractive()

WTF_EXPORT_PRIVATE void WTF::setCurrentThreadIsUserInteractive ( int relativePriority = 0 )

◆ setDataFile()

WTF_EXPORT_PRIVATE void WTF::setDataFile ( const char * path )

◆ setMainThreadCallbacksPaused()

WTF_EXPORT_PRIVATE void WTF::setMainThreadCallbacksPaused ( bool paused )

◆ setPlatformUserPreferredLanguagesChangedCallback()

WTF_EXPORT_PRIVATE void WTF::setPlatformUserPreferredLanguagesChangedCallback ( void(*)() )

◆ sixCharacterHashStringToInteger()

WTF_EXPORT_PRIVATE unsigned WTF::sixCharacterHashStringToInteger ( const char * )

◆ sleep() [1/4]

WTF_EXPORT_PRIVATE void WTF::sleep ( double )

◆ sleep() [2/4]

WTF_EXPORT_PRIVATE void WTF::sleep ( const TimeWithDynamicClockType & )

◆ sleep() [3/4]

WTF_EXPORT_PRIVATE void WTF::sleep ( WallTime )

◆ sleep() [4/4]

WTF_EXPORT_PRIVATE void WTF::sleep ( Seconds )

◆ sleepMS()

void WTF::sleepMS ( double value )

inline

◆ sortedListDump() [1/2]

template<typename T , typename Comparator >

CString WTF::sortedListDump	(	const T &	list,
		const Comparator &	comparator,
		const char *	comma = `", "`
	)

◆ sortedListDump() [2/2]

template<typename T >

CString WTF::sortedListDump	(	const T &	list,
		const char *	comma = `", "`
	)

◆ sortedMapDump()

template<typename T , typename Comparator >

CString WTF::sortedMapDump	(	const T &	map,
		const Comparator &	comparator,
		const char *	arrow = `"=>"`,
		const char *	comma = `", "`
	)

◆ startsWith()

template<typename StringClassA , typename StringClassB >

bool WTF::startsWith	(	const StringClassA &	reference,
		const StringClassB &	prefix
	)

◆ startsWithIgnoringASCIICase()

template<typename StringClassA , typename StringClassB >

bool WTF::startsWithIgnoringASCIICase	(	const StringClassA &	reference,
		const StringClassB &	prefix
	)

◆ startsWithLettersIgnoringASCIICase() [1/3]

template<unsigned length>

bool WTF::startsWithLettersIgnoringASCIICase	(	const String &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ startsWithLettersIgnoringASCIICase() [2/3]

template<unsigned length>

bool WTF::startsWithLettersIgnoringASCIICase	(	const StringImpl &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ startsWithLettersIgnoringASCIICase() [3/3]

template<unsigned length>

bool WTF::startsWithLettersIgnoringASCIICase	(	const StringImpl *	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ startsWithLettersIgnoringASCIICaseCommon()

template<typename StringClass , unsigned length>

bool WTF::startsWithLettersIgnoringASCIICaseCommon	(	const StringClass &	string,
		const char(&)	lowercaseLetters[length]
	)

inline

◆ startsWithLettersIgnoringASCIICaseCommonWithoutLength()

template<typename StringClass >

bool WTF::startsWithLettersIgnoringASCIICaseCommonWithoutLength	(	const StringClass &	string,
		const char *	lowercaseLetters
	)

◆ static_pointer_cast() [1/2]

template<typename V , typename U >

PassRefPtr< V > WTF::static_pointer_cast ( const PassRefPtr & p )

inline

◆ static_pointer_cast() [2/2]

template<typename T , typename U >

RefPtr< T > WTF::static_pointer_cast ( const RefPtr & p )

inline

◆ static_reference_cast() [1/3]

template<typename T , typename U >

Ref< T > WTF::static_reference_cast ( Ref & reference )

inline

◆ static_reference_cast() [2/3]

template<typename T , typename U >

Ref< T > WTF::static_reference_cast ( Ref && reference )

inline

◆ static_reference_cast() [3/3]

template<typename T , typename U >

Ref< T > WTF::static_reference_cast ( const Ref & reference )

inline

◆ storeLoadFence()

void WTF::storeLoadFence ( )

inline

◆ storeStoreFence()

void WTF::storeStoreFence ( )

inline

◆ sumOverflows()

template<typename T , typename... Args>

bool WTF::sumOverflows ( Args... args )

◆ sumWithOverflow() [1/2]

void WTF::sumWithOverflow	(	bool &	overflow,
		unsigned &	total,
		unsigned	addend
	)

inline

◆ sumWithOverflow() [2/2]

template<typename... Unsigned>

void WTF::sumWithOverflow	(	bool &	overflow,
		unsigned &	total,
		unsigned	addend,
		Unsigned ...	addends
	)

inline

◆ swap() [1/7]

template<typename T >

void WTF::swap	(	GDIObject< T > &	a,
		GDIObject< T > &	b
	)

inline

◆ swap() [2/7]

template<class T >

void WTF::swap	(	NakedPtr< T > &	a,
		NakedPtr< T > &	b
	)

inline

◆ swap() [3/7]

template<class T >

void WTF::swap	(	RefPtr< T > &	a,
		RefPtr< T > &	b
	)

inline

◆ swap() [4/7]

template<typename T , typename E >

void WTF::swap	(	Expected< T, E > &	x,
		Expected< T, E > &	y
	)

◆ swap() [5/7]

void WTF::swap	(	String &	a,
		String &	b
	)

inline

◆ swap() [6/7]

template<typename T , size_t inlineCapacity, typename OverflowHandler , size_t minCapacity>

void WTF::swap	(	Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	a,
		Vector< T, inlineCapacity, OverflowHandler, minCapacity > &	b
	)

inline

◆ swap() [7/7]

template<typename... _Types>

std::enable_if< __all_swappable< _Types... >::value &&__all_move_constructible< _Types... >::value, void >::type WTF::swap	(	Variant< _Types... > &	__lhs,
		Variant< _Types... > &	__rhs
	)

◆ switchOn()

template<class V , class... F>

auto WTF::switchOn	(	V &&	v,
		F &&...	f
	)		-> decltype(visit(makeVisitor(std::forward<F>(f)...), std::forward<V>(v)))

◆ ThreadingWindowWndProc()

LRESULT CALLBACK WTF::ThreadingWindowWndProc	(	HWND	hWnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

◆ timeClip()

WTF_EXPORT_PRIVATE double WTF::timeClip ( double )

◆ toASCIIHexValue() [1/2]

template<typename CharacterType >

uint8_t WTF::toASCIIHexValue ( CharacterType character )

inline

◆ toASCIIHexValue() [2/2]

template<typename CharacterType >

uint8_t WTF::toASCIIHexValue	(	CharacterType	firstCharacter,
		CharacterType	secondCharacter
	)

inline

◆ toASCIILower() [1/3]

template<typename CharacterType >

CharacterType WTF::toASCIILower ( CharacterType character )

inline

◆ toASCIILower() [2/3]

template<>

char WTF::toASCIILower ( char character )

inline

◆ toASCIILower() [3/3]

template<>

LChar WTF::toASCIILower ( LChar character )

inline

◆ toASCIILowerUnchecked()

template<typename CharacterType >

CharacterType WTF::toASCIILowerUnchecked ( CharacterType character )

inline

◆ toASCIIUpper()

template<typename CharacterType >

CharacterType WTF::toASCIIUpper ( CharacterType character )

inline

◆ toCString()

template<typename... Types>

CString WTF::toCString ( const Types &... values )

◆ toHashMap()

template<typename ElementType , typename KeyType , typename HashArg , typename KeyGetterFunctor >

void WTF::toHashMap	(	Bag< ElementType > &	bag,
		KeyGetterFunctor &	getKey,
		HashMap< KeyType, ElementType *, HashArg > &	result
	)

◆ toString()

template<typename... Types>

String WTF::toString ( const Types &... values )

◆ triState()

TriState WTF::triState ( bool boolean )

inline

◆ tryBinarySearch() [1/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::tryBinarySearch	(	ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ tryBinarySearch() [2/2]

template<typename ArrayElementType , typename KeyType , typename ArrayType , typename ExtractKey >

ArrayElementType * WTF::tryBinarySearch	(	const ArrayType &	array,
		size_t	size,
		KeyType	key,
		ExtractKey	extractKey = `ExtractKey()`
	)

inline

◆ tryFastAlignedMalloc()

WTF_EXPORT_PRIVATE void * WTF::tryFastAlignedMalloc	(	size_t	alignment,
		size_t
	)

◆ tryFastCalloc()

WTF_EXPORT_PRIVATE TryMallocReturnValue WTF::tryFastCalloc	(	size_t	numElements,
		size_t	elementSize
	)

◆ tryFastMalloc()

WTF_EXPORT_PRIVATE TryMallocReturnValue WTF::tryFastMalloc ( size_t )

◆ tryFastZeroedMalloc()

TryMallocReturnValue WTF::tryFastZeroedMalloc ( size_t )

◆ tryHoldLock()

template<typename LockType >

Locker< LockType > WTF::tryHoldLock ( LockType & lock )

◆ tryMakeString()

template<typename... StringTypes>

String WTF::tryMakeString ( StringTypes ... strings )

◆ tryMakeStringFromAdapters()

template<typename StringTypeAdapter , typename... StringTypeAdapters>

String WTF::tryMakeStringFromAdapters	(	StringTypeAdapter	adapter,
		StringTypeAdapters ...	adapters
	)

◆ typelessPointersAreEqual()

bool WTF::typelessPointersAreEqual	(	const void *	a,
		const void *	b
	)

inline

◆ upperNibbleToASCIIHexDigit()

char WTF::upperNibbleToASCIIHexDigit ( uint8_t value )

inline

◆ upperNibbleToLowercaseASCIIHexDigit()

char WTF::upperNibbleToLowercaseASCIIHexDigit ( uint8_t value )

inline

◆ uTextAccessInChunkOrOutOfRange()

bool WTF::uTextAccessInChunkOrOutOfRange	(	UText *	text,
		int64_t	nativeIndex,
		int64_t	nativeLength,
		UBool	forward,
		UBool &	isAccessible
	)

inline

◆ uTextAccessPinIndex()

int64_t WTF::uTextAccessPinIndex	(	int64_t &	index,
		int64_t	limit
	)

inline

◆ uTextCloneImpl()

UText * WTF::uTextCloneImpl	(	UText *	destination,
		const UText *	source,
		UBool	deep,
		UErrorCode *	status
	)

◆ uTextProviderContext()

UTextProviderContext WTF::uTextProviderContext	(	const UText *	text,
		int64_t	nativeIndex,
		UBool	forward
	)

inline

◆ valueOrCompute()

template<class OptionalType , class Callback >

ALWAYS_INLINE auto WTF::valueOrCompute	(	OptionalType	optional,
		Callback	callback
	)		-> typename OptionalType::value_type

◆ visit() [1/2]

template<typename _Visitor , typename ... _Types>

constexpr __visitor_return_type< _Visitor, _Types... >::__type WTF::visit	(	_Visitor &&	__visitor,
		Variant< _Types... > &	__v
	)

◆ visit() [2/2]

template<typename _Visitor , typename ... _Variants>

constexpr __multi_visitor_return_type< _Visitor, _Variants... >::__type WTF::visit	(	_Visitor &&	__visitor,
		_Variants &&...	__v
	)

◆ waitForThreadCompletion()

WTF_EXPORT_PRIVATE int WTF::waitForThreadCompletion ( ThreadIdentifier )

◆ wordBreakIterator()

WTF_EXPORT_PRIVATE UBreakIterator * WTF::wordBreakIterator ( StringView )

◆ writeNumberToBufferSigned()

template<typename CharacterType , typename SignedIntegerType >

void WTF::writeNumberToBufferSigned	(	SignedIntegerType	number,
		CharacterType *	destination
	)

inline

◆ writeNumberToBufferUnsigned()

template<typename CharacterType , typename UnsignedIntegerType >

void WTF::writeNumberToBufferUnsigned	(	UnsignedIntegerType	number,
		CharacterType *	destination
	)

inline

◆ wtfThreadData()

WTFThreadData & WTF::wtfThreadData ( )

inline

◆ zeroWithConsumeDependency()

template<typename T , typename std::enable_if< sizeof(T)==8 >::type * = nullptr>

ALWAYS_INLINE ConsumeDependency WTF::zeroWithConsumeDependency ( T value )

Variable Documentation

◆ _NSConcreteMallocBlock

void * WTF::_NSConcreteMallocBlock

◆ asciiCaseFoldTable

const unsigned char WTF::asciiCaseFoldTable

Initial value:

= {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
    0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
}

◆ emptyAtom

const WTF_EXPORTDATA AtomicString WTF::emptyAtom

◆ hoursPerDay

const double WTF::hoursPerDay = 24.0

◆ kThreadingWindowClassName

const LPCWSTR WTF::kThreadingWindowClassName = L"ThreadingWindowClass"

◆ LogMemoryPressure

WTFLogChannel WTF::LogMemoryPressure = { WTFLogChannelOn, "MemoryPressure", LOG_CHANNEL_WEBKIT_SUBSYSTEM, OS_LOG_DEFAULT }

◆ machineWordAlignmentMask

const uintptr_t WTF::machineWordAlignmentMask = sizeof(MachineWord) - 1

◆ minutesPerHour

const double WTF::minutesPerHour = 60.0

◆ monthFullName

const char *const WTF::monthFullName = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }

◆ monthName

const char *const WTF::monthName = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }

◆ msPerDay

const double WTF::msPerDay = msPerSecond * secondsPerDay

◆ msPerHour

const double WTF::msPerHour = msPerSecond * secondsPerHour

◆ msPerMinute

const double WTF::msPerMinute = msPerSecond * secondsPerMinute

◆ msPerMonth

const double WTF::msPerMonth = 2592000000.0

◆ msPerSecond

const double WTF::msPerSecond = 1000.0

◆ nonAlphabet

const char WTF::nonAlphabet = -1

◆ notFound

const size_t WTF::notFound = static_cast<size_t>(-1)

◆ nullAtom

const WTF_EXPORTDATA AtomicString WTF::nullAtom

◆ NumberToStringBufferLength

const unsigned WTF::NumberToStringBufferLength = 96

◆ secondsPerDay

const double WTF::secondsPerDay = secondsPerHour * hoursPerDay

◆ secondsPerHour

const double WTF::secondsPerHour = secondsPerMinute * minutesPerHour

◆ secondsPerMinute

const double WTF::secondsPerMinute = 60.0

◆ sourceSigned

template<typename Target , typename Source , bool isTargetBigger = sizeof(Target)>

bool bool WTF::sourceSigned = std::numeric_limits<Source>::is_signed> struct BoundsChecker

◆ starAtom

const WTF_EXPORTDATA AtomicString WTF::starAtom

◆ targetSigned

template<typename Target , typename Source , bool isTargetBigger = sizeof(Target)>

bool WTF::targetSigned = std::numeric_limits<Target>::is_signed

◆ Unexpect

constexpr UnexpectTag WTF::Unexpect { }

◆ UTextWithBufferInlineCapacity

const int WTF::UTextWithBufferInlineCapacity = 16

◆ variant_npos

constexpr size_t WTF::variant_npos =-1

◆ weekdayName

const char *const WTF::weekdayName = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" }

◆ xmlAtom

const WTF_EXPORTDATA AtomicString WTF::xmlAtom

◆ xmlnsAtom

const WTF_EXPORTDATA AtomicString WTF::xmlnsAtom

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AllocAlignmentInteger

◆ AtomicStringTableDestructor

◆ CharacterMatchFunction

◆ CharacterMatchFunctionPtr

◆ CharBuffer

◆ CheckedInt16

◆ CheckedInt32

◆ CheckedInt64

◆ CheckedInt8

◆ CheckedSize

◆ CheckedUint16

◆ CheckedUint32

◆ CheckedUint64

◆ CheckedUint8

◆ ConsumeDependency

◆ DefaultLockAlgorithm

◆ DeprecatedOptional

◆ DtoaBuffer

◆ in_place_index_t

◆ in_place_t

◆ in_place_type_t

◆ IsWhiteSpaceFunctionPtr

◆ LCharBuffer

◆ LockHolder

◆ LowMemoryHandler

◆ MachineWord

◆ MutexLocker

◆ NoLockLocker

◆ NumberToLStringBuffer

◆ NumberToStringBuffer

◆ PlatformCondition

◆ PlatformMutex

◆ ReasonSet

◆ SchedulePairHashSet

◆ StaticCondition

◆ StaticLock

◆ StaticWordLock

◆ StringTableImpl

◆ TextBreakIteratorPlatform

◆ ThreadFunction

◆ ThreadIdentifier

◆ UCharBuffer

◆ variant_alternative_t

◆ WordLockHolder

Enumeration Type Documentation

◆ Base64DecodeOptions [1/3]

◆ Base64DecodeOptions [2/3]

◆ Base64DecodeOptions [3/3]

◆ Base64EncodePolicy [1/3]

◆ Base64EncodePolicy [2/3]

◆ Base64EncodePolicy [3/3]

◆ BinarySearchMode [1/3]

◆ BinarySearchMode [2/3]

◆ BinarySearchMode [3/3]

◆ CanBeGCThread [1/3]

◆ CanBeGCThread [2/3]

◆ CanBeGCThread [3/3]

◆ CheckedState [1/3]

◆ CheckedState [2/3]

◆ CheckedState [3/3]

◆ CheckMoveParameterTag [1/3]

◆ CheckMoveParameterTag [2/3]

◆ CheckMoveParameterTag [3/3]

◆ ClockType [1/3]

◆ ClockType [2/3]

◆ ClockType [3/3]

◆ ConversionMode [1/3]

◆ ConversionMode [2/3]

◆ ConversionMode [3/3]

◆ Critical [1/3]

◆ Critical [2/3]

◆ Critical [3/3]

◆ GCThreadType [1/3]