wpi Namespace Reference

Namespaces
namespace	adl_detail
namespace	detail
namespace	hashing
namespace	impl
namespace	java
	Java Native Interface (JNI) utility functions.
namespace	literals
namespace	log
namespace	math
namespace	pointer_union_detail
namespace	sig
namespace	structparser
namespace	support
namespace	sys
namespace	uv

Classes
struct	add_const_past_pointer
	If T is a pointer to X, return a pointer to const X. More...
struct	add_const_past_pointer< T, std::enable_if_t< std::is_pointer_v< T > > >
struct	add_lvalue_reference_if_not_pointer
	If T is a pointer, just return it. If it is not, return T&. More...
struct	add_lvalue_reference_if_not_pointer< T, std::enable_if_t< std::is_pointer_v< T > > >
struct	AlignedCharArrayUnion
	A suitably aligned and sized character array member which can hold elements of any type. More...
class	AllocatorBase
	CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators. More...
class	array
	This class is a wrapper around std::array that does compile time size checking. More...
class	bad_expected_access
class	buffer_ostream
class	buffer_unique_ostream
struct	CalculateSmallVectorDefaultInlinedElements
	Helper class for calculating the default number of inline elements for SmallVector<T>. More...
class	CallbackListenerData
class	CallbackManager
class	CallbackThread
struct	cast_convert_val
struct	cast_convert_val< To, FromTy *, FromTy * >
struct	cast_convert_val< To, FromTy, FromTy >
struct	cast_retty
struct	cast_retty_impl
struct	cast_retty_impl< To, const From * >
struct	cast_retty_impl< To, const From *const >
struct	cast_retty_impl< To, const From >
struct	cast_retty_impl< To, From * >
struct	cast_retty_impl< To, std::unique_ptr< From > >
struct	cast_retty_wrap
struct	cast_retty_wrap< To, FromTy, FromTy >
struct	CastInfo
	This struct provides a method for customizing the way a cast is performed. More...
struct	CastInfo< To, const PointerUnion< PTs... > >
struct	CastInfo< To, From, std::enable_if_t<!is_simple_type< From >::value > >
	This struct provides an overload for CastInfo where From has simplify_type defined. More...
struct	CastInfo< To, PointerUnion< PTs... > >
struct	CastInfo< To, std::optional< From > >
	Provide a CastInfo specialized for std::optional<From>. More...
struct	CastInfo< To, std::unique_ptr< From > >
	Provide a CastInfo specialized for std::unique_ptr. More...
struct	CastInfoPointerUnionImpl
	We can't (at least, at this moment with C++14) declare CastInfo as a friend of PointerUnion like this: More...
struct	CastIsPossible
	This struct provides a way to check if a given cast is possible. More...
struct	CastIsPossible< To, From, std::enable_if_t< std::is_base_of_v< To, From > > >
	Upcasting (from derived to base) and casting from a type to itself should always be possible. More...
struct	CastIsPossible< To, std::optional< From > >
class	circular_buffer
	This is a simple circular buffer so we don't need to "bucket brigade" copy old values. More...
class	ConcurrentQueue
struct	const_pointer_or_const_ref
struct	const_pointer_or_const_ref< T, std::enable_if_t< std::is_pointer_v< T > > >
struct	ConstStrippingForwardingCast
	Provides a cast trait that strips const from types to make it easier to implement a const-version of a non-const cast. More...
struct	ct_string
	Fixed length string (array of character) for compile time use. More...
class	DebugEpochBase
	A base class for data structure classes wishing to make iterators ("handles") pointing into themselves fail-fast. More...
struct	DefaultDoCastIfPossible
	This cast trait just provides the default implementation of doCastIfPossible to make CastInfo specializations more declarative. More...
class	DenseMap
class	DenseMapBase
struct	DenseMapInfo
	An information struct used to provide DenseMap with the various necessary components for a given value type T. More...
struct	DenseMapInfo< char >
struct	DenseMapInfo< hash_code, void >
struct	DenseMapInfo< int >
struct	DenseMapInfo< long >
struct	DenseMapInfo< long long >
struct	DenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType >, void >
struct	DenseMapInfo< PointerUnion< PTs... > >
struct	DenseMapInfo< short >
struct	DenseMapInfo< std::pair< T, U > >
struct	DenseMapInfo< std::tuple< Ts... > >
struct	DenseMapInfo< std::variant< Ts... > >
struct	DenseMapInfo< T * >
struct	DenseMapInfo< unsigned >
struct	DenseMapInfo< unsigned char >
struct	DenseMapInfo< unsigned long >
struct	DenseMapInfo< unsigned long long >
struct	DenseMapInfo< unsigned short >
class	DenseMapIterator
class	DsClient
class	DynamicStruct
	Dynamic (run-time) read-only access to a serialized raw struct. More...
class	DynamicStructObject
	Dynamic (run-time) mutable access to a serialized raw struct, with internal data storage. More...
struct	empty_array_t
class	Event
	An atomic signaling event for synchronization. More...
class	EventLoopRunner
	Executes an event loop on a separate thread. More...
struct	EventVector
class	expected
	An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T. More...
struct	explicitly_convertible
struct	explicitly_convertible< From, To, std::void_t< decltype(static_cast< To >(std::declval< std::add_rvalue_reference_t< From > >()))> >
struct	FirstIndexOfType
	Find the first index where a type appears in a list of types. More...
struct	FirstIndexOfType< T, T, Us... >
struct	FirstIndexOfType< T, U, Us... >
struct	ForwardToPointerCast
	Provides a cast trait that uses a defined pointer to pointer cast as a base for reference-to-reference casts. More...
class	function_ref
	An efficient, type-erasing, non-owning reference to a callable. More...
class	function_ref< Ret(Params...)>
struct	FunctionPointerLikeTypeTraits
	Provide suitable custom traits struct for function pointers. More...
class	future
	A lightweight version of std::future. More...
class	future< void >
	Explicit specialization for future<void>. More...
class	hash_code
	An opaque object representing a hash code. More...
class	HashBuilderImpl
struct	http_parser
struct	http_parser_settings
struct	http_parser_url
class	HttpConnection
class	HttpLocation
class	HttpMultipartScanner
class	HttpParser
	HTTP protocol parser. More...
class	HttpPath
	Class for HTTP path matching. More...
class	HttpPathRef
	Proxy reference object for a portion of a HttpPath. More...
class	HttpQueryMap
	Map for looking up elements of the query portion of a URI. More...
class	HttpRequest
class	HttpServerConnection
class	HttpWebSocketServerConnection
	A server-side HTTP connection that also accepts WebSocket upgrades. More...
struct	in_place_t
class	interpolating_map
	Implements a table of key-value pairs with linear interpolation between values. More...
class	is_integral_or_enum
	Metafunction that determines whether the given type is either an integral type or an enumeration type, including enum classes. More...
struct	is_simple_type
struct	isa_impl
struct	isa_impl< To, From, std::enable_if_t< std::is_base_of_v< To, From > > >
struct	isa_impl_cl
struct	isa_impl_cl< To, const From * >
struct	isa_impl_cl< To, const From *const >
struct	isa_impl_cl< To, const From >
struct	isa_impl_cl< To, const std::unique_ptr< From > >
struct	isa_impl_cl< To, From * >
struct	isa_impl_cl< To, From *const >
struct	isa_impl_wrap
struct	isa_impl_wrap< To, FromTy, FromTy >
class	iterator_adaptor_base
	CRTP base class for adapting an iterator to a different type. More...
class	iterator_facade_base
	CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface. More...
class	iterator_range
	A range adaptor for a pair of iterators. More...
class	Logger
class	MallocAllocator
class	MappedFileRegion
class	MapVector
	This class implements a map that also provides access to all stored values in a deterministic order. More...
class	MemoryBuffer
	This interface provides simple read-only access to a block of memory, and provides simple methods for reading files and standard input into a memory buffer. More...
class	MemoryBufferRef
class	monostate
class	MulticastServiceAnnouncer
class	MulticastServiceResolver
class	MutableDynamicStruct
	Dynamic (run-time) mutable access to a serialized raw struct. More...
class	NetworkAcceptor
class	NetworkStream
struct	NullableValueCastFailed
	All of these cast traits are meant to be implementations for useful casts that users may want to use that are outside the standard behavior. More...
struct	NullDeleter
struct	OptionalValueCast
	This cast trait provides std::optional<T> casting. More...
class	ParallelTcpConnector
	Parallel TCP connector. More...
struct	pointee_iterator
	An iterator type that allows iterating over the pointees via some other iterator. More...
class	pointer_iterator
class	PointerIntPair
	PointerIntPair - This class implements a pair of a pointer and small integer. More...
struct	PointerIntPairInfo
struct	PointerLikeTypeTraits
	A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity. More...
struct	PointerLikeTypeTraits< const T * >
struct	PointerLikeTypeTraits< const T >
struct	PointerLikeTypeTraits< PointerIntPair< PointerTy, IntBits, IntType, PtrTraits > >
struct	PointerLikeTypeTraits< PointerUnion< PTs... > >
struct	PointerLikeTypeTraits< ReturnT(*)(ParamTs...)>
	Provide a default specialization for function pointers that assumes 4-byte alignment. More...
struct	PointerLikeTypeTraits< T * >
struct	PointerLikeTypeTraits< uintptr_t >
struct	PointerLikeTypeTraits< void * >
class	PointerUnion
	A discriminated union of two or more pointer types, with the discriminator in the low bit of the pointer. More...
class	PortForwarder
	Forward ports to another host. More...
class	priority_queue
	This class is the same as std::priority_queue with two changes: More...
class	promise
	A lightweight version of std::promise. More...
class	promise< void >
	Explicit specialization for promise<void>. More...
class	PromiseFactory
	A promise factory for lightweight futures. More...
class	PromiseFactory< void >
	Explicit specialization for PromiseFactory<void>. More...
struct	Protobuf
	Protobuf serialization template. More...
class	ProtobufMessage
	Owning wrapper (ala std::unique_ptr) for google::protobuf::Message* that does not require the protobuf headers be included. More...
class	ProtobufMessageDatabase
	Database of protobuf dynamic messages. More...
class	raw_fd_istream
class	raw_fd_ostream
	A raw_ostream that writes to a file descriptor. More...
class	raw_fd_stream
	A raw_ostream of a file for reading/writing/seeking. More...
class	raw_istream
class	raw_mem_istream
class	raw_null_ostream
	A raw_ostream that discards all output. More...
class	raw_os_ostream
	raw_os_ostream - A raw_ostream that writes to an std::ostream. More...
class	raw_ostream
	This class implements an extremely fast bulk output stream that can only output to a stream. More...
class	raw_pwrite_stream
	An abstract base class for streams implementations that also support a pwrite operation. More...
class	raw_socket_istream
class	raw_socket_ostream
class	raw_string_ostream
	A raw_ostream that writes to an std::string. More...
class	raw_svector_ostream
	A raw_ostream that writes to an SmallVector or SmallString. More...
class	raw_usvector_ostream
	A raw_ostream that writes to an SmallVector or SmallString. More...
class	raw_uv_ostream
	raw_ostream style output to a SmallVector of uv::Buffer buffers. More...
class	raw_uvector_ostream
	A raw_ostream that writes to a vector. More...
class	raw_vector_ostream
	A raw_ostream that writes to a vector. More...
struct	RawFrame
class	recursive_spinlock1
	A recursive spinlock mutex. More...
class	recursive_spinlock2
	A recursive spinlock mutex. More...
struct	remove_cvref
struct	RoundUpToPowerOfTwo
	RoundUpToPowerOfTwo - This is a helper template that rounds N up to the next power of two (which means N itself if N is already a power of two). More...
struct	RoundUpToPowerOfTwoH
	RoundUpToPowerOfTwoH - If N is not a power of two, increase it. More...
struct	RoundUpToPowerOfTwoH< N, false >
class	SafeThread
class	SafeThreadBase
	Base class for SafeThreadOwner threads. More...
class	SafeThreadEvent
class	SafeThreadOwner
struct	SameType
class	scope_exit
struct	ScopedFatalErrorHandler
	ScopedFatalErrorHandler - This is a simple helper class which just calls install_fatal_error_handler in its constructor and remove_fatal_error_handler in its destructor. More...
class	Semaphore
	A semaphore for synchronization. More...
class	Sendable
	Interface for Sendable objects. More...
class	SendableBuilder
	Helper class for building Sendable dashboard representations. More...
class	SendableHelper
	A helper class for use with objects that add themselves to SendableRegistry. More...
class	SendableRegistry
	The SendableRegistry class is the public interface for registering sensors and actuators for use on dashboards and LiveWindow. More...
class	SHA1
class	SignalObject
	RAII wrapper for signaling handles. More...
struct	simplify_type
	Define a template that can be specialized by smart pointers to reflect the fact that they are automatically dereferenced, and are not involved with the template selection process... the default implementation is a noop. More...
struct	simplify_type< const From >
class	SmallDenseMap
struct	SmallMapVector
	A MapVector that performs no allocations if smaller than a certain size. More...
class	SmallPtrSet
	SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements. More...
class	SmallPtrSetImpl
	A templated base class for SmallPtrSet which provides the typesafe interface that is common across all small sizes. More...
class	SmallPtrSetImplBase
	SmallPtrSetImplBase - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything. More...
class	SmallPtrSetIterator
	SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet. More...
class	SmallPtrSetIteratorImpl
	SmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator. More...
class	SmallSet
	SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less than N). More...
class	SmallSet< PointeeType *, N >
	If this set is of pointer values, transparently switch over to using SmallPtrSet for performance. More...
class	SmallSetIterator
	SmallSetIterator - This class implements a const_iterator for SmallSet by delegating to the underlying SmallVector or Set iterators. More...
class	SmallString
	SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g. More...
class	SmallVector
	This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small. More...
struct	SmallVectorAlignmentAndSize
	Figure out the offset of the first element. More...
class	SmallVectorBase
	This is all the stuff common to all SmallVectors. More...
class	SmallVectorImpl
	This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter. More...
class	SmallVectorMemoryBuffer
	SmallVector-backed MemoryBuffer instance. More...
struct	SmallVectorStorage
	Storage for the SmallVector elements. More...
struct	SmallVectorStorage< T, 0 >
	We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined. More...
class	SmallVectorTemplateBase
	SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's. More...
class	SmallVectorTemplateBase< T, true >
	SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's. More...
class	SmallVectorTemplateCommon
	This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD. More...
class	spinlock
	A spinlock mutex. More...
class	static_circular_buffer
	This is a simple circular buffer so we don't need to "bucket brigade" copy old values. More...
class	StringMap
	StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes. More...
class	StringMapConstIterator
class	StringMapEntry
	StringMapEntry - This is used to represent one value that is inserted into a StringMap. More...
class	StringMapEntryBase
	StringMapEntryBase - Shared base class of StringMapEntry instances. More...
class	StringMapEntryStorage
	StringMapEntryStorage - Holds the value in a StringMapEntry. More...
class	StringMapEntryStorage< std::nullopt_t >
class	StringMapImpl
	StringMapImpl - This is the base class of StringMap that is shared among all of its instantiations. More...
class	StringMapIterator
class	StringMapIterBase
class	StringMapKeyIterator
struct	Struct
	Struct serialization template. More...
struct	Struct< bool >
	Raw struct support for boolean values. More...
struct	Struct< double >
	Raw struct support for double values. More...
struct	Struct< float >
	Raw struct support for float values. More...
struct	Struct< int16_t >
	Raw struct support for int16_t values. More...
struct	Struct< int32_t >
	Raw struct support for int32_t values. More...
struct	Struct< int64_t >
	Raw struct support for int64_t values. More...
struct	Struct< int8_t >
	Raw struct support for int8_t values. More...
struct	Struct< std::array< T, N >, I... >
	Raw struct support for fixed-size arrays of other structs. More...
struct	Struct< uint16_t >
	Raw struct support for uint16_t values. More...
struct	Struct< uint32_t >
	Raw struct support for uint32_t values. More...
struct	Struct< uint64_t >
	Raw struct support for uint64_t values. More...
struct	Struct< uint8_t >
	Raw struct support for uint8_t values. More...
class	StructArrayBuffer
class	StructDescriptor
	Raw struct dynamic struct descriptor. More...
class	StructDescriptorDatabase
	Database of raw struct dynamic descriptors. More...
class	StructFieldDescriptor
	Raw struct dynamic field descriptor. More...
class	TCPAcceptor
class	TCPConnector
class	TCPStream
struct	TypesAreDistinct
	Determine if all types in Ts are distinct. More...
struct	TypesAreDistinct<>
class	UDPClient
class	UidVector
	Vector which provides an integrated freelist for removal and reuse of individual elements. More...
class	Uleb128Reader
	Unsigned LEB128 streaming reader. More...
struct	unexpect_t
class	unexpected
class	unique_function
	unique_function is a type-erasing functor similar to std::function. More...
class	unique_function< R(P...) const >
class	unique_function< R(P...)>
struct	UniquePtrCast
	This cast trait provides std::unique_ptr casting. More...
class	UrlParser
	Parses a URL into its constiuent components. More...
struct	ValueFromPointerCast
	This cast trait provides casting for the specific case of casting to a value-typed object from a pointer-typed object. More...
struct	ValueIsPresent
	ValueIsPresent provides a way to check if a value is, well, present. More...
struct	ValueIsPresent< std::optional< T > >
struct	ValueIsPresent< T, std::enable_if_t< IsNullable< T > > >
class	VersionTuple
	Represents a version number in the form major[.minor[.subminor[.build]]]. More...
class	WebSocket
	RFC 6455 compliant WebSocket client and server implementation. More...
class	WebSocketServer
	Dedicated WebSocket server. More...
class	WebSocketServerHelper
	WebSocket HTTP server helper. More...
class	WorkerThread
class	WorkerThread< R(T...)>
class	WritableMemoryBuffer
	This class is an extension of MemoryBuffer, which allows copy-on-write access to the underlying contents. More...
class	WriteThroughMemoryBuffer
	This class is an extension of MemoryBuffer, which allows write access to the underlying contents and committing those changes to the original source. More...

Concepts
concept	ProtobufSerializable
	Specifies that a type is capable of protobuf serialization and deserialization.
concept	MutableProtobufSerializable
	Specifies that a type is capable of in-place protobuf deserialization.
concept	StructSerializable
	Specifies that a type is capable of raw struct serialization and deserialization.
concept	MutableStructSerializable
	Specifies that a type is capable of in-place raw struct deserialization.
concept	HasNestedStruct
	Specifies that a struct type has nested struct declarations.
concept	DecayedDerivedFrom

Functions
std::string_view	UnescapeURI (std::string_view str, SmallVectorImpl< char > &buf, bool *error)
std::string_view	EscapeURI (std::string_view str, SmallVectorImpl< char > &buf, bool spacePlus=true)
bool	ParseHttpHeaders (raw_istream &is, SmallVectorImpl< char > *contentType, SmallVectorImpl< char > *contentLength)
bool	FindMultipartBoundary (wpi::raw_istream &is, std::string_view boundary, std::string *saveBuf)
int	SocketErrno ()
std::string	SocketStrerror (int code)
std::string	SocketStrerror ()
unsigned long	http_parser_version (void)
void	http_parser_init (http_parser *parser, enum http_parser_type type)
void	http_parser_settings_init (http_parser_settings *settings)
size_t	http_parser_execute (http_parser *parser, const http_parser_settings *settings, const char *data, size_t len)
int	http_should_keep_alive (const http_parser *parser)
const char *	http_method_str (enum http_method m)
const char *	http_status_str (enum http_status s)
const char *	http_errno_name (enum http_errno err)
const char *	http_errno_description (enum http_errno err)
void	http_parser_url_init (struct http_parser_url *u)
int	http_parser_parse_url (const char *buf, size_t buflen, int is_connect, struct http_parser_url *u)
void	http_parser_pause (http_parser *parser, int paused)
int	http_body_is_final (const http_parser *parser)
std::string	GetHostname ()
std::string_view	GetHostname (SmallVectorImpl< char > &name)
std::string_view	MimeTypeFromPath (std::string_view path)
template<ProtobufSerializable T>
T	UnpackProtobuf (const google::protobuf::Message &msg)
	Unpack a serialized protobuf message. More...
template<ProtobufSerializable T>
void	PackProtobuf (google::protobuf::Message *msg, const T &value)
	Pack a serialized protobuf message. More...
template<ProtobufSerializable T>
void	UnpackProtobufInto (T *out, const google::protobuf::Message &msg)
	Unpack a serialized struct into an existing object, overwriting its contents. More...
template<typename T >
future< T >	make_ready_future (T &&value)
	Constructs a valid future with the value set. More...
future< void >	make_ready_future ()
	Constructs a valid future with the value set. More...
std::string	Demangle (std::string_view mangledSymbol)
	Demangle a C++ symbol. More...
template<typename T >
std::string	GetTypeName (const T &type)
	Returns the type name of an object. More...
template<typename T >
std::vector< T >::iterator	insert_sorted (std::vector< T > &vec, T const &item)
template<typename F , typename... Ts>
constexpr void	for_each (F &&f, Ts &&... elems)
	Calls f(i, elem) for each element of elems where i is the index of the element in elems and elem is the element. More...
WPI_EventHandle	CreateEvent (bool manualReset=false, bool initialState=false)
	Creates an event. More...
void	DestroyEvent (WPI_EventHandle handle)
	Destroys an event. More...
void	SetEvent (WPI_EventHandle handle)
	Sets an event to signaled state. More...
void	ResetEvent (WPI_EventHandle handle)
	Sets an event to non-signaled state. More...
WPI_SemaphoreHandle	CreateSemaphore (int initialCount=0, int maximumCount=INT_MAX)
	Creates a semaphore. More...
void	DestroySemaphore (WPI_SemaphoreHandle handle)
	Destroys a semaphore. More...
bool	ReleaseSemaphore (WPI_SemaphoreHandle handle, int releaseCount=1, int *prevCount=nullptr)
	Releases N counts of a semaphore. More...
bool	WaitForObject (WPI_Handle handle)
	Waits for an handle to be signaled. More...
bool	WaitForObject (WPI_Handle handle, double timeout, bool *timedOut)
	Waits for an handle to be signaled, with timeout. More...
std::span< WPI_Handle >	WaitForObjects (std::span< const WPI_Handle > handles, std::span< WPI_Handle > signaled)
	Waits for one or more handles to be signaled. More...
std::span< WPI_Handle >	WaitForObjects (std::initializer_list< WPI_Handle > handles, std::span< WPI_Handle > signaled)
	Waits for one or more handles to be signaled. More...
std::span< WPI_Handle >	WaitForObjects (std::span< const WPI_Handle > handles, std::span< WPI_Handle > signaled, double timeout, bool *timedOut)
	Waits for one or more handles to be signaled, with timeout. More...
std::span< WPI_Handle >	WaitForObjects (std::initializer_list< WPI_Handle > handles, std::span< WPI_Handle > signaled, double timeout, bool *timedOut)
	Waits for one or more handles to be signaled, with timeout. More...
void	CreateSignalObject (WPI_Handle handle, bool manualReset=false, bool initialState=false)
	Sets up signaling for an arbitrary handle. More...
void	SetSignalObject (WPI_Handle handle)
	Sets a handle to signaled state. More...
void	ResetSignalObject (WPI_Handle handle)
	Sets a handle to non-signaled state. More...
void	DestroySignalObject (WPI_Handle handle)
	Cleans up signaling for a handle. More...
uint64_t	SizeUleb128 (uint64_t val)
	Get size of unsigned LEB128 data. More...
uint64_t	WriteUleb128 (SmallVectorImpl< char > &dest, uint64_t val)
	Write unsigned LEB128 data. More...
void	WriteUleb128 (raw_ostream &os, uint64_t val)
	Write unsigned LEB128 data. More...
uint64_t	ReadUleb128 (const char *addr, uint64_t *ret)
	Read unsigned LEB128 data. More...
bool	ReadUleb128 (raw_istream &is, uint64_t *ret)
	Read unsigned LEB128 data from a stream. More...
template<typename T , typename... I> requires StructSerializable<T, I...>
T	UnpackStruct (std::span< const uint8_t > data, const I &... info)
	Unpack a serialized struct. More...
template<typename T , size_t Offset, typename... I> requires StructSerializable<T, I...>
T	UnpackStruct (std::span< const uint8_t > data, const I &... info)
	Unpack a serialized struct starting at a given offset within the data. More...
template<typename T , typename... I> requires StructSerializable<T, I...>
void	PackStruct (std::span< uint8_t > data, T &&value, const I &... info)
	Pack a serialized struct. More...
template<size_t Offset, typename T , typename... I> requires StructSerializable<T, I...>
void	PackStruct (std::span< uint8_t > data, T &&value, const I &... info)
	Pack a serialized struct starting at a given offset within the data. More...
template<typename T , typename... I> requires StructSerializable<T, I...>
void	UnpackStructInto (T *out, std::span< const uint8_t > data, const I &... info)
	Unpack a serialized struct into an existing object, overwriting its contents. More...
template<size_t Offset, typename T , typename... I> requires StructSerializable<T, I...>
void	UnpackStructInto (T *out, std::span< const uint8_t > data, const I &... info)
	Unpack a serialized struct into an existing object, overwriting its contents, and starting at a given offset within the data. More...
template<typename T , typename... I> requires StructSerializable<T, I...>
constexpr auto	GetStructTypeString (const I &... info)
	Get the type string for a raw struct serializable type. More...
template<typename T , typename... I> requires StructSerializable<T, I...>
constexpr size_t	GetStructSize (const I &... info)
	Get the size for a raw struct serializable type. More...
template<typename T , size_t N, typename... I> requires StructSerializable<T, I...>
constexpr auto	MakeStructArrayTypeString (const I &... info)
template<typename T , size_t N, typename... I> requires StructSerializable<T, I...>
constexpr auto	MakeStructArraySchema (const I &... info)
template<typename T , typename... I> requires StructSerializable<T, I...>
constexpr std::string_view	GetStructSchema (const I &... info)
template<typename T , typename... I> requires StructSerializable<T, I...>
constexpr std::span< const uint8_t >	GetStructSchemaBytes (const I &... info)
template<typename T , typename... I> requires StructSerializable<T, I...>
void	ForEachStructSchema (std::invocable< std::string_view, std::string_view > auto fn, const I &... info)
std::string	GetStackTrace (int offset)
	Get a stack trace, ignoring the first "offset" symbols. More...
std::string	GetStackTraceDefault (int offset)
	The default implementation used for GetStackTrace(). More...
void	SetGetStackTraceImpl (std::string(*func)(int offset))
	Set the implementation used by GetStackTrace(). More...
template<typename T , std::convertible_to< T >... Ts>
	array (T, Ts...) -> array< T, 1+sizeof...(Ts)>
template<typename T , size_t N>
constexpr std::span< T >	drop_front (std::span< T, N > in, typename std::span< T >::size_type n=1)
	Drop the first N elements of the array. More...
template<typename T , size_t N>
constexpr std::span< T >	drop_back (std::span< T, N > in, typename std::span< T >::size_type n=1)
	Drop the last N elements of the array. More...
template<typename T , size_t N>
constexpr std::span< T >	take_front (std::span< T, N > in, typename std::span< T >::size_type n=1)
	Returns a span equal to in but with only the first n elements remaining. More...
template<typename T , size_t N>
constexpr std::span< T >	take_back (std::span< T, N > in, typename std::span< T >::size_type n=1)
	Returns a span equal to in but with only the last n elements remaining. More...
uint64_t	NowDefault ()
	The default implementation used for Now(). More...
void	SetNowImpl (uint64_t(*func)())
	Set the implementation used by Now(). More...
uint64_t	Now ()
	Return a value representing the current time in microseconds. More...
uint64_t	GetSystemTime ()
	Return the current system time in microseconds since the Unix epoch (January 1st, 1970 00:00 UTC). More...
template<typename Char , size_t M>
	ct_string (Char const (&s)[M]) -> ct_string< Char, std::char_traits< Char >, M - 1 >
template<ct_string S>
constexpr auto	operator""_ct_string ()
template<typename Char , typename Traits , size_t N1, size_t N2>
constexpr auto	operator+ (ct_string< Char, Traits, N1 > const &s1, ct_string< Char, Traits, N2 > const &s2) noexcept
template<typename Char , typename Traits , size_t N1, size_t... N>
constexpr auto	Concat (ct_string< Char, Traits, N1 > const &s1, ct_string< Char, Traits, N > const &... s)
	Concatenates multiple fixed_strings into a larger fixed_string at compile time. More...
template<intmax_t N, int Base = 10, typename Char = char, typename Traits = std::char_traits<Char>> requires (Base >= 2 && Base <= 36)
constexpr auto	NumToCtString ()
	Converts any integral to a ct_string at compile-time. More...
size_t	Base64Decode (raw_ostream &os, std::string_view encoded)
size_t	Base64Decode (std::string_view encoded, std::string *plain)
std::string_view	Base64Decode (std::string_view encoded, size_t *num_read, SmallVectorImpl< char > &buf)
size_t	Base64Decode (std::string_view encoded, std::vector< uint8_t > *plain)
std::span< uint8_t >	Base64Decode (std::string_view encoded, size_t *num_read, SmallVectorImpl< uint8_t > &buf)
void	Base64Encode (raw_ostream &os, std::string_view plain)
void	Base64Encode (std::string_view plain, std::string *encoded)
std::string_view	Base64Encode (std::string_view plain, SmallVectorImpl< char > &buf)
void	Base64Encode (raw_ostream &os, std::span< const uint8_t > plain)
void	Base64Encode (std::span< const uint8_t > plain, std::string *encoded)
std::string_view	Base64Encode (std::span< const uint8_t > plain, SmallVectorImpl< char > &buf)
template<class E >
constexpr bool	operator== (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
constexpr bool	operator!= (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
constexpr bool	operator< (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
constexpr bool	operator<= (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
constexpr bool	operator> (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
constexpr bool	operator>= (const unexpected< E > &lhs, const unexpected< E > &rhs)
template<class E >
unexpected< typename std::decay< E >::type >	make_unexpected (E &&e)
template<class T , class E , class U , class F >
constexpr bool	operator== (const expected< T, E > &lhs, const expected< U, F > &rhs)
template<class T , class E , class U , class F >
constexpr bool	operator!= (const expected< T, E > &lhs, const expected< U, F > &rhs)
template<class E , class F >
constexpr bool	operator== (const expected< void, E > &lhs, const expected< void, F > &rhs)
template<class E , class F >
constexpr bool	operator!= (const expected< void, E > &lhs, const expected< void, F > &rhs)
template<class T , class E , class U >
constexpr bool	operator== (const expected< T, E > &x, const U &v)
template<class T , class E , class U >
constexpr bool	operator== (const U &v, const expected< T, E > &x)
template<class T , class E , class U >
constexpr bool	operator!= (const expected< T, E > &x, const U &v)
template<class T , class E , class U >
constexpr bool	operator!= (const U &v, const expected< T, E > &x)
template<class T , class E >
constexpr bool	operator== (const expected< T, E > &x, const unexpected< E > &e)
template<class T , class E >
constexpr bool	operator== (const unexpected< E > &e, const expected< T, E > &x)
template<class T , class E >
constexpr bool	operator!= (const expected< T, E > &x, const unexpected< E > &e)
template<class T , class E >
constexpr bool	operator!= (const unexpected< E > &e, const expected< T, E > &x)
template<class T , class E , detail::enable_if_t<(std::is_void< T >::value||std::is_move_constructible< T >::value) &&detail::is_swappable< T >::value &&std::is_move_constructible< E >::value &&detail::is_swappable< E >::value > * = nullptr>
void	swap (expected< T, E > &lhs, expected< T, E > &rhs) noexcept(noexcept(lhs.swap(rhs)))
LLVM_ATTRIBUTE_RETURNS_NONNULL void *	safe_malloc (size_t Sz)
LLVM_ATTRIBUTE_RETURNS_NONNULL void *	safe_calloc (size_t Count, size_t Sz)
LLVM_ATTRIBUTE_RETURNS_NONNULL void *	safe_realloc (void *Ptr, size_t Sz)
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *	allocate_buffer (size_t Size, size_t Alignment)
	Allocate a buffer of memory with the given size and alignment. More...
void	deallocate_buffer (void *Ptr, size_t Size, size_t Alignment)
	Deallocate a buffer of memory with the given size and alignment. More...
template<typename T , unsigned LN, unsigned RN, typename C >
bool	operator== (const SmallSet< T, LN, C > &LHS, const SmallSet< T, RN, C > &RHS)
	Equality comparison for SmallSet. More...
template<typename T , unsigned LN, unsigned RN, typename C >
bool	operator!= (const SmallSet< T, LN, C > &LHS, const SmallSet< T, RN, C > &RHS)
	Inequality comparison for SmallSet. More...
template<typename T >
T	maskTrailingOnes (unsigned N)
	Create a bitmask with the N right-most bits set to 1, and all other bits set to 0. More...
template<typename T >
T	maskLeadingOnes (unsigned N)
	Create a bitmask with the N left-most bits set to 1, and all other bits set to 0. More...
template<typename T >
T	maskTrailingZeros (unsigned N)
	Create a bitmask with the N right-most bits set to 0, and all other bits set to 1. More...
template<typename T >
T	maskLeadingZeros (unsigned N)
	Create a bitmask with the N left-most bits set to 0, and all other bits set to 1. More...
template<typename T >
T	reverseBits (T Val)
	Reverse the bits in Val. More...
constexpr uint32_t	Hi_32 (uint64_t Value)
	Return the high 32 bits of a 64 bit value. More...
constexpr uint32_t	Lo_32 (uint64_t Value)
	Return the low 32 bits of a 64 bit value. More...
constexpr uint64_t	Make_64 (uint32_t High, uint32_t Low)
	Make a 64-bit integer from a high / low pair of 32-bit integers. More...
template<unsigned N>
constexpr bool	isInt (int64_t x)
	Checks if an integer fits into the given bit width. More...
template<unsigned N, unsigned S>
constexpr bool	isShiftedInt (int64_t x)
	Checks if a signed integer is an N bit number shifted left by S. More...
template<unsigned N>
constexpr bool	isUInt (uint64_t x)
	Checks if an unsigned integer fits into the given bit width. More...
template<unsigned N, unsigned S>
constexpr bool	isShiftedUInt (uint64_t x)
	Checks if a unsigned integer is an N bit number shifted left by S. More...
uint64_t	maxUIntN (uint64_t N)
	Gets the maximum value for a N-bit unsigned integer. More...
int64_t	minIntN (int64_t N)
	Gets the minimum value for a N-bit signed integer. More...
int64_t	maxIntN (int64_t N)
	Gets the maximum value for a N-bit signed integer. More...
bool	isUIntN (unsigned N, uint64_t x)
	Checks if an unsigned integer fits into the given (dynamic) bit width. More...
bool	isIntN (unsigned N, int64_t x)
	Checks if an signed integer fits into the given (dynamic) bit width. More...
constexpr bool	isMask_32 (uint32_t Value)
	Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (32 bit version). More...
constexpr bool	isMask_64 (uint64_t Value)
	Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (64 bit version). More...
constexpr bool	isShiftedMask_32 (uint32_t Value)
	Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex. More...
constexpr bool	isShiftedMask_64 (uint64_t Value)
	Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.) More...
constexpr bool	isPowerOf2_32 (uint32_t Value)
	Return true if the argument is a power of two > 0. More...
constexpr bool	isPowerOf2_64 (uint64_t Value)
	Return true if the argument is a power of two > 0 (64 bit edition.) More...
bool	isShiftedMask_32 (uint32_t Value, unsigned &MaskIdx, unsigned &MaskLen)
	Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex. More...
bool	isShiftedMask_64 (uint64_t Value, unsigned &MaskIdx, unsigned &MaskLen)
	Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.) If true, MaskIdx will specify the index of the lowest set bit and MaskLen is updated to specify the length of the mask, else neither are updated. More...
template<size_t kValue>
constexpr size_t	CTLog2 ()
	Compile time Log2. More...
template<>
constexpr size_t	CTLog2< 1 > ()
unsigned	Log2_32 (uint32_t Value)
	Return the floor log base 2 of the specified value, -1 if the value is zero. More...
unsigned	Log2_64 (uint64_t Value)
	Return the floor log base 2 of the specified value, -1 if the value is zero. More...
unsigned	Log2_32_Ceil (uint32_t Value)
	Return the ceil log base 2 of the specified value, 32 if the value is zero. More...
unsigned	Log2_64_Ceil (uint64_t Value)
	Return the ceil log base 2 of the specified value, 64 if the value is zero. More...
constexpr uint64_t	MinAlign (uint64_t A, uint64_t B)
	A and B are either alignments or offsets. More...
constexpr uint64_t	NextPowerOf2 (uint64_t A)
	Returns the next power of two (in 64-bits) that is strictly greater than A. More...
uint64_t	PowerOf2Ceil (uint64_t A)
	Returns the power of two which is greater than or equal to the given value. More...
uint64_t	alignTo (uint64_t Value, uint64_t Align)
	Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align. More...
uint64_t	alignToPowerOf2 (uint64_t Value, uint64_t Align)
uint64_t	alignTo (uint64_t Value, uint64_t Align, uint64_t Skew)
	If non-zero Skew is specified, the return value will be a minimal integer that is greater than or equal to Size and equal to A * N + Skew for some integer N. More...
template<uint64_t Align>
constexpr uint64_t	alignTo (uint64_t Value)
	Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align. More...
uint64_t	divideCeil (uint64_t Numerator, uint64_t Denominator)
	Returns the integer ceil(Numerator / Denominator). More...
uint64_t	divideNearest (uint64_t Numerator, uint64_t Denominator)
	Returns the integer nearest(Numerator / Denominator). More...
uint64_t	alignDown (uint64_t Value, uint64_t Align, uint64_t Skew=0)
	Returns the largest uint64_t less than or equal to Value and is Skew mod Align. More...
template<unsigned B>
constexpr int32_t	SignExtend32 (uint32_t X)
	Sign-extend the number in the bottom B bits of X to a 32-bit integer. More...
int32_t	SignExtend32 (uint32_t X, unsigned B)
	Sign-extend the number in the bottom B bits of X to a 32-bit integer. More...
template<unsigned B>
constexpr int64_t	SignExtend64 (uint64_t x)
	Sign-extend the number in the bottom B bits of X to a 64-bit integer. More...
int64_t	SignExtend64 (uint64_t X, unsigned B)
	Sign-extend the number in the bottom B bits of X to a 64-bit integer. More...
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, T >	AbsoluteDifference (T X, T Y)
	Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result. More...
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, T >	SaturatingAdd (T X, T Y, bool *ResultOverflowed=nullptr)
	Add two unsigned integers, X and Y, of type T. More...
template<class T , class... Ts>
std::enable_if_t< std::is_unsigned_v< T >, T >	SaturatingAdd (T X, T Y, T Z, Ts... Args)
	Add multiple unsigned integers of type T. More...
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, T >	SaturatingMultiply (T X, T Y, bool *ResultOverflowed=nullptr)
	Multiply two unsigned integers, X and Y, of type T. More...
template<typename T >
std::enable_if_t< std::is_unsigned_v< T >, T >	SaturatingMultiplyAdd (T X, T Y, T A, bool *ResultOverflowed=nullptr)
	Multiply two unsigned integers, X and Y, and add the unsigned integer, A to the product. More...
template<typename T >
std::enable_if_t< std::is_signed_v< T >, T >	AddOverflow (T X, T Y, T &Result)
	Add two signed integers, computing the two's complement truncated result, returning true if overflow occurred. More...
template<typename T >
std::enable_if_t< std::is_signed_v< T >, T >	SubOverflow (T X, T Y, T &Result)
	Subtract two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred. More...
template<typename T >
std::enable_if_t< std::is_signed_v< T >, T >	MulOverflow (T X, T Y, T &Result)
	Multiply two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred. More...
template<typename T >
constexpr int	sgn (T val)
template<typename T >
constexpr T	Lerp (const T &startValue, const T &endValue, double t)
	Linearly interpolates between two values. More...
template<typename T , typename Function >
auto	transformOptional (const std::optional< T > &O, const Function &F) -> std::optional< decltype(F(*O))>
template<typename T , typename Function >
auto	transformOptional (std::optional< T > &&O, const Function &F) -> std::optional< decltype(F(*std::move(O)))>
template<typename OStream , typename T >
std::enable_if_t<!std::is_reference_v< OStream > &&std::is_base_of_v< raw_ostream, OStream >, OStream && >	operator<< (OStream &&OS, const T &Value)
	Call the appropriate insertion operator, given an rvalue reference to a raw_ostream object and return a stream of the same type as the argument. More...
raw_fd_ostream &	outs ()
	This returns a reference to a raw_fd_ostream for standard output. More...
raw_fd_ostream &	errs ()
	This returns a reference to a raw_ostream for standard error. More...
raw_ostream &	nulls ()
	This returns a reference to a raw_ostream which simply discards output. More...
template<typename To , typename From >
bool	isa (const From &Val)
	isa<X> - Return true if the parameter to the template is an instance of one of the template type arguments. More...
template<typename First , typename Second , typename... Rest, typename From >
bool	isa (const From &Val)
template<typename To , typename From >
decltype(auto)	cast (const From &Val)
	cast<X> - Return the argument parameter cast to the specified type. More...
template<typename To , typename From >
decltype(auto)	cast (From &Val)
template<typename To , typename From >
decltype(auto)	cast (From *Val)
template<typename To , typename From >
decltype(auto)	cast (std::unique_ptr< From > &&Val)
template<typename To , typename From >
decltype(auto)	dyn_cast (const From &Val)
	dyn_cast<X> - Return the argument parameter cast to the specified type. More...
template<typename To , typename From >
decltype(auto)	dyn_cast (From &Val)
template<typename To , typename From >
decltype(auto)	dyn_cast (From *Val)
template<typename To , typename From >
decltype(auto)	dyn_cast (std::unique_ptr< From > &&Val)
template<typename... X, class Y >
bool	isa_and_present (const Y &Val)
	isa_and_present<X> - Functionally identical to isa, except that a null value is accepted. More...
template<typename... X, class Y >
bool	isa_and_nonnull (const Y &Val)
template<class X , class Y >
auto	cast_if_present (const Y &Val)
	cast_if_present<X> - Functionally identical to cast, except that a null value is accepted. More...
template<class X , class Y >
auto	cast_if_present (Y &Val)
template<class X , class Y >
auto	cast_if_present (Y *Val)
template<class X , class Y >
auto	cast_if_present (std::unique_ptr< Y > &&Val)
template<class X , class Y >
auto	cast_or_null (const Y &Val)
template<class X , class Y >
auto	cast_or_null (Y &Val)
template<class X , class Y >
auto	cast_or_null (Y *Val)
template<class X , class Y >
auto	cast_or_null (std::unique_ptr< Y > &&Val)
template<class X , class Y >
auto	dyn_cast_if_present (const Y &Val)
	dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case of optionals) value is accepted. More...
template<class X , class Y >
auto	dyn_cast_if_present (Y &Val)
template<class X , class Y >
auto	dyn_cast_if_present (Y *Val)
template<class X , class Y >
auto	dyn_cast_or_null (const Y &Val)
template<class X , class Y >
auto	dyn_cast_or_null (Y &Val)
template<class X , class Y >
auto	dyn_cast_or_null (Y *Val)
template<class X , class Y >
CastInfo< X, std::unique_ptr< Y > >::CastResultType	unique_dyn_cast (std::unique_ptr< Y > &Val)
	unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>, taking ownership of the input pointer iff isa<X>(Val) is true. More...
template<class X , class Y >
auto	unique_dyn_cast (std::unique_ptr< Y > &&Val)
template<class X , class Y >
CastInfo< X, std::unique_ptr< Y > >::CastResultType	unique_dyn_cast_or_null (std::unique_ptr< Y > &Val)
template<class X , class Y >
auto	unique_dyn_cast_or_null (std::unique_ptr< Y > &&Val)
template<class Lambda , int = (Lambda{}(), 0)>
constexpr bool	is_constexpr (Lambda)
constexpr bool	is_constexpr (...)
void	install_fatal_error_handler (fatal_error_handler_t handler, void *user_data=nullptr)
	install_fatal_error_handler - Installs a new error handler to be used whenever a serious (non-recoverable) error is encountered by LLVM. More...
void	remove_fatal_error_handler ()
	Restores default error handling behaviour. More...
void	report_fatal_error (const char *reason, bool gen_crash_diag=true)
	Reports a serious error, calling any installed error handler. More...
void	report_fatal_error (const std::string &reason, bool gen_crash_diag=true)
void	report_fatal_error (std::string_view reason, bool gen_crash_diag=true)
void	install_bad_alloc_error_handler (fatal_error_handler_t handler, void *user_data=nullptr)
	Installs a new bad alloc error handler that should be used whenever a bad alloc error, e.g. More...
void	remove_bad_alloc_error_handler ()
	Restores default bad alloc error handling behavior. More...
void	install_out_of_memory_new_handler ()
void	report_bad_alloc_error (const char *Reason, bool GenCrashDiag=true)
	Reports a bad alloc error, calling any user defined bad alloc error handler. More...
void	wpi_unreachable_internal (const char *msg=nullptr, const char *file=nullptr, unsigned line=0)
	This function calls abort(), and prints the optional message to stderr. More...
template<typename To , typename From , typename = std::enable_if_t<sizeof(To) == sizeof(From)>, typename = std::enable_if_t<std::is_trivially_constructible<To>::value>, typename = std::enable_if_t<std::is_trivially_copyable<To>::value>, typename = std::enable_if_t<std::is_trivially_copyable<From>::value>>
To	bit_cast (const From &from) noexcept
template<typename T , typename = std::enable_if_t<std::is_integral_v<T>>>
constexpr T	byteswap (T V) noexcept
	Reverses the bytes in the given integer value V. More...
template<typename DerivedT , typename KeyT , typename ValueT , typename KeyInfoT , typename BucketT >
bool	operator== (const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &LHS, const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &RHS)
	Equality comparison for DenseMap. More...
template<typename DerivedT , typename KeyT , typename ValueT , typename KeyInfoT , typename BucketT >
bool	operator!= (const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &LHS, const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &RHS)
	Inequality comparison for DenseMap. More...
template<typename KeyT , typename ValueT , typename KeyInfoT >
size_t	capacity_in_bytes (const DenseMap< KeyT, ValueT, KeyInfoT > &X)
template<typename Container >
	iterator_range (Container &&) -> iterator_range< detail::IterOfRange< Container > >
template<class T >
iterator_range< T >	make_range (T x, T y)
	Convenience function for iterating over sub-ranges. More...
template<typename T >
iterator_range< T >	make_range (std::pair< T, T > p)
template<typename T , unsigned N>
size_t	capacity_in_bytes (const SmallVector< T, N > &X)
template<unsigned Size, typename R >
SmallVector< ValueTypeFromRangeType< R >, Size >	to_vector (R &&Range)
	Given a range of type R, iterate the entire range and return a SmallVector with elements of the vector. More...
template<typename R >
SmallVector< ValueTypeFromRangeType< R > >	to_vector (R &&Range)
template<typename Out , unsigned Size, typename R >
SmallVector< Out, Size >	to_vector_of (R &&Range)
template<typename Out , typename R >
SmallVector< Out >	to_vector_of (R &&Range)
template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iterator_range< pointee_iterator< WrappedIteratorT > >	make_pointee_range (RangeT &&Range)
template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iterator_range< pointer_iterator< WrappedIteratorT > >	make_pointer_range (RangeT &&Range)
template<std::size_t I, typename PointerTy , unsigned IntBits, typename IntType , typename PtrTraits , typename Info >
decltype(auto)	get (const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
template<typename ValueTy >
bool	operator== (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
template<typename ValueTy >
bool	operator!= (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
template<typename ValueTy >
bool	operator< (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
template<typename ValueTy >
bool	operator<= (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
template<typename ValueTy >
bool	operator> (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
template<typename ValueTy >
bool	operator>= (const StringMap< ValueTy > &lhs, const StringMap< ValueTy > &rhs)
constexpr char	hexdigit (unsigned X, bool LowerCase=false) noexcept
	hexdigit - Return the hexadecimal character for the given number X (which should be less than 16). More...
constexpr unsigned	hexDigitValue (char C) noexcept
	Interpret the given character C as a hexadecimal digit and return its value. More...
constexpr bool	isDigit (char C) noexcept
	Checks if character C is one of the 10 decimal digits. More...
constexpr bool	isHexDigit (char C) noexcept
	Checks if character C is a hexadecimal numeric character. More...
constexpr bool	isAlpha (char C) noexcept
	Checks if character C is a valid letter as classified by "C" locale. More...
constexpr bool	isAlnum (char C) noexcept
	Checks whether character C is either a decimal digit or an uppercase or lowercase letter as classified by "C" locale. More...
constexpr bool	isASCII (char C) noexcept
	Checks whether character C is valid ASCII (high bit is zero). More...
constexpr bool	isPrint (char C) noexcept
	Checks whether character C is printable. More...
constexpr char	toLower (char x) noexcept
	Returns the corresponding lowercase character if x is uppercase. More...
constexpr char	toUpper (char x) noexcept
	Returns the corresponding uppercase character if x is lowercase. More...
std::string	utohexstr (unsigned long long val, bool lowerCase=false)
constexpr bool	equals (std::string_view lhs, std::string_view rhs) noexcept
	equals - Check for string equality, this is more efficient than compare() when the relative ordering of inequal strings isn't needed. More...
int	compare_lower (std::string_view lhs, std::string_view rhs) noexcept
	compare_lower - Compare two strings, ignoring case. More...
constexpr bool	equals_lower (std::string_view lhs, std::string_view rhs) noexcept
	equals_lower - Check for string equality, ignoring case. More...
std::string_view::size_type	find_lower (std::string_view str, char ch, std::string_view::size_type from=0) noexcept
	Search for the first character ch in str, ignoring case. More...
std::string_view::size_type	find_lower (std::string_view str, std::string_view other, std::string_view::size_type from=0) noexcept
	Search for the first string other in str, ignoring case. More...
std::string_view::size_type	find_lower (std::string_view str, const char *other, std::string_view::size_type from=0) noexcept
	Search for the first string other in str, ignoring case. More...
std::string_view::size_type	rfind_lower (std::string_view str, char ch, std::string_view::size_type from=std::string_view::npos) noexcept
	Search for the last character ch in str, ignoring case. More...
std::string_view::size_type	rfind_lower (std::string_view str, std::string_view other) noexcept
	Search for the last string other in str, ignoring case. More...
std::string_view::size_type	rfind_lower (std::string_view str, const char *other) noexcept
	Search for the last string other in str, ignoring case. More...
constexpr std::string_view	substr (std::string_view str, std::string_view::size_type start, std::string_view::size_type n=std::string_view::npos) noexcept
	Returns the substring of str from [start, start + n). More...
constexpr bool	starts_with (std::string_view str, std::string_view prefix) noexcept
	Checks if str starts with the given prefix. More...
constexpr bool	starts_with (std::string_view str, char prefix) noexcept
	Checks if str starts with the given prefix. More...
constexpr bool	starts_with (std::string_view str, const char *prefix) noexcept
	Checks if str starts with the given prefix. More...
bool	starts_with_lower (std::string_view str, std::string_view prefix) noexcept
	Checks if str starts with the given prefix, ignoring case. More...
constexpr bool	starts_with_lower (std::string_view str, char prefix) noexcept
	Checks if str starts with the given prefix, ignoring case. More...
bool	starts_with_lower (std::string_view str, const char *prefix) noexcept
	Checks if str starts with the given prefix, ignoring case. More...
constexpr bool	ends_with (std::string_view str, std::string_view suffix) noexcept
	Checks if str ends with the given suffix. More...
constexpr bool	ends_with (std::string_view str, char suffix) noexcept
	Checks if str ends with the given suffix. More...
constexpr bool	ends_with (std::string_view str, const char *suffix) noexcept
	Checks if str ends with the given suffix. More...
bool	ends_with_lower (std::string_view str, std::string_view suffix) noexcept
	Checks if str ends with the given suffix, ignoring case. More...
constexpr bool	ends_with_lower (std::string_view str, char suffix) noexcept
	Checks if str ends with the given suffix, ignoring case. More...
bool	ends_with_lower (std::string_view str, const char *suffix) noexcept
	Checks if str ends with the given suffix, ignoring case. More...
constexpr bool	contains (std::string_view str, std::string_view other) noexcept
	Checks if str contains the substring other. More...
constexpr bool	contains (std::string_view str, char ch) noexcept
	Checks if str contains the substring other. More...
constexpr bool	contains (std::string_view str, const char *other) noexcept
	Checks if str contains the substring other. More...
bool	contains_lower (std::string_view str, std::string_view other) noexcept
	Checks if str contains the substring other, ignoring case. More...
bool	contains_lower (std::string_view str, char ch) noexcept
	Checks if str contains the substring other, ignoring case. More...
bool	contains_lower (std::string_view str, const char *other) noexcept
	Checks if str contains the substring other, ignoring case. More...
constexpr std::string_view	drop_front (std::string_view str, std::string_view::size_type n=1) noexcept
	Return a string_view equal to str but with the first n elements dropped. More...
constexpr std::string_view	drop_back (std::string_view str, std::string_view::size_type n=1) noexcept
	Return a string_view equal to str but with the last n elements dropped. More...
constexpr std::string_view	take_front (std::string_view str, std::string_view::size_type n=1) noexcept
	Returns a view equal to str but with only the first n elements remaining. More...
constexpr std::string_view	take_back (std::string_view str, std::string_view::size_type n=1) noexcept
	Returns a view equal to str but with only the last n elements remaining. More...
constexpr std::string_view	slice (std::string_view str, std::string_view::size_type start, std::string_view::size_type end) noexcept
	Returns a reference to the substring of str from [start, end). More...
constexpr std::pair< std::string_view, std::string_view >	split (std::string_view str, char separator) noexcept
	Splits str into two substrings around the first occurrence of a separator character. More...
constexpr std::pair< std::string_view, std::string_view >	split (std::string_view str, std::string_view separator) noexcept
	Splits str into two substrings around the first occurrence of a separator string. More...
constexpr std::pair< std::string_view, std::string_view >	rsplit (std::string_view str, char separator) noexcept
	Splits str into two substrings around the last occurrence of a separator character. More...
constexpr std::pair< std::string_view, std::string_view >	rsplit (std::string_view str, std::string_view separator) noexcept
	Splits str into two substrings around the last occurrence of a separator string. More...
void	split (std::string_view str, SmallVectorImpl< std::string_view > &arr, std::string_view separator, int maxSplit=-1, bool keepEmpty=true) noexcept
	Splits str into substrings around the occurrences of a separator string. More...
void	split (std::string_view str, SmallVectorImpl< std::string_view > &arr, char separator, int maxSplit=-1, bool keepEmpty=true) noexcept
	Splits str into substrings around the occurrences of a separator character. More...
constexpr std::string_view	ltrim (std::string_view str, char ch) noexcept
	Returns str with consecutive ch characters starting from the the left removed. More...
constexpr std::string_view	ltrim (std::string_view str, std::string_view chars=" \t\n\v\f\r") noexcept
	Returns str with consecutive characters in chars starting from the left removed. More...
constexpr std::string_view	rtrim (std::string_view str, char ch) noexcept
	Returns str with consecutive Char characters starting from the right removed. More...
constexpr std::string_view	rtrim (std::string_view str, std::string_view chars=" \t\n\v\f\r") noexcept
	Returns str with consecutive characters in chars starting from the right removed. More...
constexpr std::string_view	trim (std::string_view str, char ch) noexcept
	Returns str with consecutive ch characters starting from the left and right removed. More...
constexpr std::string_view	trim (std::string_view str, std::string_view chars=" \t\n\v\f\r") noexcept
	Returns str with consecutive characters in chars starting from the left and right removed. More...
template<typename T , std::enable_if_t< std::numeric_limits< T >::is_signed, bool > = true>
std::optional< T >	parse_integer (std::string_view str, unsigned radix) noexcept
	Parses the string str as an integer of the specified radix. More...
template<typename T , std::enable_if_t< std::numeric_limits< T >::is_signed, bool > = true>
std::optional< T >	consume_integer (std::string_view *str, unsigned radix) noexcept
	Parses the string str as an integer of the specified radix. More...
template<typename T >
std::optional< T >	parse_float (std::string_view str) noexcept
	Parses the string str as a floating point value. More...
template<>
std::optional< float >	parse_float< float > (std::string_view str) noexcept
template<>
std::optional< double >	parse_float< double > (std::string_view str) noexcept
template<>
std::optional< long double >	parse_float< long double > (std::string_view str) noexcept
std::pair< std::string_view, std::string_view >	UnescapeCString (std::string_view str, SmallVectorImpl< char > &buf)
	Unescapes a C-style string (reverse operation to raw_ostream::write_escaped). More...
template<class OutputIt , class... Args>
void	format_to_n_c_str (OutputIt out, std::iter_difference_t< OutputIt > n, fmt::format_string< Args... > fmt, Args &&... args)
	Like std::format_to_n() in that it writes at most n bytes to the output buffer, but also includes a terminating null byte in n. More...
ConversionResult	ConvertUTF8toUTF16 (const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF8toUTF32Partial (const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
	Convert a partial UTF8 sequence to UTF32. More...
ConversionResult	ConvertUTF8toUTF32 (const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
	Convert a partial UTF8 sequence to UTF32. More...
ConversionResult	ConvertUTF16toUTF8 (const UTF16 **sourceStart, const UTF16 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF32toUTF8 (const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF16toUTF32 (const UTF16 **sourceStart, const UTF16 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF32toUTF16 (const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags)
Boolean	isLegalUTF8Sequence (const UTF8 *source, const UTF8 *sourceEnd)
Boolean	isLegalUTF8String (const UTF8 **source, const UTF8 *sourceEnd)
unsigned	getUTF8SequenceSize (const UTF8 *source, const UTF8 *sourceEnd)
unsigned	getNumBytesForUTF8 (UTF8 firstByte)
bool	ConvertUTF8toWide (unsigned WideCharWidth, std::string_view Source, char *&ResultPtr, const UTF8 *&ErrorPtr)
	Convert an UTF8 string_view to UTF8, UTF16, or UTF32 depending on WideCharWidth. More...
bool	ConvertUTF8toWide (std::string_view Source, std::wstring &Result)
	Converts a UTF-8 string_view to a std::wstring. More...
bool	ConvertUTF8toWide (const char *Source, std::wstring &Result)
	Converts a UTF-8 C-string to a std::wstring. More...
bool	convertWideToUTF8 (const std::wstring &Source, SmallVectorImpl< char > &Result)
	Converts a std::wstring to a UTF-8 encoded std::string. More...
bool	ConvertCodePointToUTF8 (unsigned Source, char *&ResultPtr)
	Convert an Unicode code point to UTF8 sequence. More...
ConversionResult	convertUTF8Sequence (const UTF8 **source, const UTF8 *sourceEnd, UTF32 *target, ConversionFlags flags)
	Convert the first UTF8 sequence in the given source buffer to a UTF32 code point. More...
bool	hasUTF16ByteOrderMark (std::span< const char > SrcBytes)
	Returns true if a blob of text starts with a UTF-16 big or little endian byte order mark. More...
bool	convertUTF16ToUTF8String (std::span< const char > SrcBytes, SmallVectorImpl< char > &Out)
	Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string. More...
bool	convertUTF16ToUTF8String (std::span< const UTF16 > Src, SmallVectorImpl< char > &Out)
	Converts a UTF16 string into a UTF8 std::string. More...
bool	convertUTF32ToUTF8String (std::span< const char > SrcBytes, std::string &Out)
	Converts a stream of raw bytes assumed to be UTF32 into a UTF8 std::string. More...
bool	convertUTF32ToUTF8String (std::span< const UTF32 > Src, std::string &Out)
	Converts a UTF32 string into a UTF8 std::string. More...
bool	convertUTF8ToUTF16String (std::string_view SrcUTF8, SmallVectorImpl< UTF16 > &DstUTF16)
	Converts a UTF-8 string into a UTF-16 string with native endianness. More...
template<class T = void *>
bool	shouldReverseIterate ()
raw_ostream &	operator<< (raw_ostream &OS, sys::TimePoint<> TP)
template<typename RangeT >
constexpr auto	adl_begin (RangeT &&range) -> decltype(adl_detail::begin_impl(std::forward< RangeT >(range)))
	Returns the begin iterator to range using std::begin and function found through Argument-Dependent Lookup (ADL). More...
template<typename RangeT >
constexpr auto	adl_end (RangeT &&range) -> decltype(adl_detail::end_impl(std::forward< RangeT >(range)))
	Returns the end iterator to range using std::end and functions found through Argument-Dependent Lookup (ADL). More...
template<typename T >
constexpr void	adl_swap (T &&lhs, T &&rhs) noexcept(noexcept(adl_detail::swap_impl(std::declval< T >(), std::declval< T >())))
	Swaps lhs with rhs using std::swap and functions found through Argument-Dependent Lookup (ADL). More...
template<typename RangeT >
constexpr auto	adl_size (RangeT &&range) -> decltype(adl_detail::size_impl(std::forward< RangeT >(range)))
	Returns the size of range using std::size and functions found through Argument-Dependent Lookup (ADL). More...
template<typename T >
std::enable_if_t< is_integral_or_enum< T >::value, hash_code >	hash_value (T value)
	Compute a hash_code for any integer value. More...
template<typename T >
hash_code	hash_value (const T *ptr)
	Compute a hash_code for a pointer's address. More...
template<typename T , typename U >
hash_code	hash_value (const std::pair< T, U > &arg)
	Compute a hash_code for a pair of objects. More...
template<typename... Ts>
hash_code	hash_value (const std::tuple< Ts... > &arg)
	Compute a hash_code for a tuple. More...
template<typename T >
hash_code	hash_value (const std::basic_string< T > &arg)
	Compute a hash_code for a standard string. More...
template<typename T >
hash_code	hash_value (const std::optional< T > &arg)
	Compute a hash_code for a standard string. More...
void	set_fixed_execution_hash_seed (uint64_t fixed_value)
	Override the execution seed with a fixed value. More...
template<typename InputIteratorT >
hash_code	hash_combine_range (InputIteratorT first, InputIteratorT last)
	Compute a hash_code for a sequence of values. More...
template<typename ... Ts>
hash_code	hash_combine (const Ts &...args)
	Combine values into a single hash_code. More...
std::error_code	mapWindowsError (unsigned EV)
std::error_code	make_error_code (errc E)
template<std::size_t Index, typename ValueTy >
decltype(auto)	get (const StringMapEntry< ValueTy > &E)
uint64_t	xxHash64 (std::string_view Data)
uint64_t	xxHash64 (std::span< const uint8_t > Data)
uint64_t	xxh3_64bits (std::span< const uint8_t > data)
uint64_t	xxh3_64bits (std::string_view data)
template<typename PtrType >
bool	operator== (const SmallPtrSetImpl< PtrType > &LHS, const SmallPtrSetImpl< PtrType > &RHS)
	Equality comparison for SmallPtrSet. More...
template<typename PtrType >
bool	operator!= (const SmallPtrSetImpl< PtrType > &LHS, const SmallPtrSetImpl< PtrType > &RHS)
	Inequality comparison for SmallPtrSet. More...
template<typename ... PTs>
bool	operator== (PointerUnion< PTs... > lhs, PointerUnion< PTs... > rhs)
template<typename ... PTs>
bool	operator!= (PointerUnion< PTs... > lhs, PointerUnion< PTs... > rhs)
template<typename ... PTs>
bool	operator< (PointerUnion< PTs... > lhs, PointerUnion< PTs... > rhs)

Function Documentation

AbsoluteDifference()

template<typename T >

std::enable_if_t< std::is_unsigned_v< T >, T > wpi::AbsoluteDifference	(	T	X,
		T	Y
	)

Subtract two unsigned integers, X and Y, of type T and return the absolute value of the result.

AddOverflow()

template<typename T >

std::enable_if_t< std::is_signed_v< T >, T > wpi::AddOverflow	(	T	X,
		T	Y,
		T &	Result
	)

Add two signed integers, computing the two's complement truncated result, returning true if overflow occurred.

adl_begin()

template<typename RangeT >

constexpr auto wpi::adl_begin ( RangeT &&  range ) -> decltype(adl_detail::begin_impl(std::forward<RangeT>(range)))

constexpr

Returns the begin iterator to range using std::begin and function found through Argument-Dependent Lookup (ADL).

adl_end()

template<typename RangeT >

constexpr auto wpi::adl_end ( RangeT &&  range ) -> decltype(adl_detail::end_impl(std::forward<RangeT>(range)))

constexpr

Returns the end iterator to range using std::end and functions found through Argument-Dependent Lookup (ADL).

adl_size()

template<typename RangeT >

constexpr auto wpi::adl_size ( RangeT &&  range ) -> decltype(adl_detail::size_impl(std::forward<RangeT>(range)))

constexpr

Returns the size of range using std::size and functions found through Argument-Dependent Lookup (ADL).

adl_swap()

template<typename T >

constexpr void wpi::adl_swap ( T &&  lhs, T &&  rhs  )

constexprnoexcept

Swaps lhs with rhs using std::swap and functions found through Argument-Dependent Lookup (ADL).

alignDown()

uint64_t wpi::alignDown ( uint64_t  Value, uint64_t  Align, uint64_t  Skew = 0  )

inline

Returns the largest uint64_t less than or equal to Value and is Skew mod Align.

Align must be non-zero

alignTo() [1/3]

template<uint64_t Align>

constexpr uint64_t wpi::alignTo ( uint64_t  Value )

inlineconstexpr

Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align.

Align must be non-zero.

alignTo() [2/3]

uint64_t wpi::alignTo ( uint64_t  Value, uint64_t  Align  )

inline

Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Align.

Align must be non-zero.

Examples:

alignTo(5, 8) = 8
alignTo(17, 8) = 24
alignTo(~0LL, 8) = 0
alignTo(321, 255) = 510

alignTo() [3/3]

uint64_t wpi::alignTo ( uint64_t  Value, uint64_t  Align, uint64_t  Skew  )

inline

If non-zero Skew is specified, the return value will be a minimal integer that is greater than or equal to Size and equal to A * N + Skew for some integer N.

If Skew is larger than A, its value is adjusted to 'Skew mod A'. Align must be non-zero.

Examples:

alignTo(5, 8, 7) = 7
alignTo(17, 8, 1) = 17
alignTo(~0LL, 8, 3) = 3
alignTo(321, 255, 42) = 552

alignToPowerOf2()

uint64_t wpi::alignToPowerOf2 ( uint64_t  Value, uint64_t  Align  )

inline

allocate_buffer()

LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * wpi::allocate_buffer	(	size_t	Size,
		size_t	Alignment
	)

Allocate a buffer of memory with the given size and alignment.

When the compiler supports aligned operator new, this will use it to to handle even over-aligned allocations.

However, this doesn't make any attempt to leverage the fancier techniques like posix_memalign due to portability. It is mostly intended to allow compatibility with platforms that, after aligned allocation was added, use reduced default alignment.

array()

template<typename T , std::convertible_to< T >... Ts>

wpi::array	(	T	,
		Ts...
	)		-> array< T, 1+sizeof...(Ts)>

Base64Decode() [1/5]

size_t wpi::Base64Decode	(	raw_ostream &	os,
		std::string_view	encoded
	)

Base64Decode() [2/5]

std::string_view wpi::Base64Decode	(	std::string_view	encoded,
		size_t *	num_read,
		SmallVectorImpl< char > &	buf
	)

Base64Decode() [3/5]

std::span< uint8_t > wpi::Base64Decode	(	std::string_view	encoded,
		size_t *	num_read,
		SmallVectorImpl< uint8_t > &	buf
	)

Base64Decode() [4/5]

size_t wpi::Base64Decode	(	std::string_view	encoded,
		std::string *	plain
	)

Base64Decode() [5/5]

size_t wpi::Base64Decode	(	std::string_view	encoded,
		std::vector< uint8_t > *	plain
	)

Base64Encode() [1/6]

void wpi::Base64Encode	(	raw_ostream &	os,
		std::span< const uint8_t >	plain
	)

Base64Encode() [2/6]

void wpi::Base64Encode	(	raw_ostream &	os,
		std::string_view	plain
	)

Base64Encode() [3/6]

std::string_view wpi::Base64Encode	(	std::span< const uint8_t >	plain,
		SmallVectorImpl< char > &	buf
	)

Base64Encode() [4/6]

void wpi::Base64Encode	(	std::span< const uint8_t >	plain,
		std::string *	encoded
	)

Base64Encode() [5/6]

std::string_view wpi::Base64Encode	(	std::string_view	plain,
		SmallVectorImpl< char > &	buf
	)

Base64Encode() [6/6]

void wpi::Base64Encode	(	std::string_view	plain,
		std::string *	encoded
	)

bit_cast()

template<typename To , typename From , typename = std::enable_if_t<sizeof(To) == sizeof(From)>, typename = std::enable_if_t<std::is_trivially_constructible<To>::value>, typename = std::enable_if_t<std::is_trivially_copyable<To>::value>, typename = std::enable_if_t<std::is_trivially_copyable<From>::value>>

To wpi::bit_cast ( const From &  from )

inlinenoexcept

byteswap()

template<typename T , typename = std::enable_if_t<std::is_integral_v<T>>>

constexpr T wpi::byteswap ( T  V )

constexprnoexcept

Reverses the bytes in the given integer value V.

capacity_in_bytes() [1/2]

template<typename KeyT , typename ValueT , typename KeyInfoT >

size_t wpi::capacity_in_bytes ( const DenseMap< KeyT, ValueT, KeyInfoT > &  X )

inline

capacity_in_bytes() [2/2]

template<typename T , unsigned N>

size_t wpi::capacity_in_bytes ( const SmallVector< T, N > &  X )

inline

cast() [1/4]

template<typename To , typename From >

decltype(auto) wpi::cast ( const From &  Val )

inline

cast<X> - Return the argument parameter cast to the specified type.

This casting operator asserts that the type is correct, so it does not return null on failure. It does not allow a null argument (use cast_if_present for that). It is typically used like this:

cast<Instruction>(myVal)->getParent()

cast() [2/4]

template<typename To , typename From >

decltype(auto) wpi::cast ( From &  Val )

inline

cast() [3/4]

template<typename To , typename From >

decltype(auto) wpi::cast ( From *  Val )

inline

cast() [4/4]

template<typename To , typename From >

decltype(auto) wpi::cast ( std::unique_ptr< From > &&  Val )

inline

cast_if_present() [1/4]

template<class X , class Y >

auto wpi::cast_if_present ( const Y &  Val )

inline

cast_if_present<X> - Functionally identical to cast, except that a null value is accepted.

cast_if_present() [2/4]

template<class X , class Y >

auto wpi::cast_if_present ( std::unique_ptr< Y > &&  Val )

inline

cast_if_present() [3/4]

template<class X , class Y >

auto wpi::cast_if_present ( Y &  Val )

inline

cast_if_present() [4/4]

template<class X , class Y >

auto wpi::cast_if_present ( Y *  Val )

inline

cast_or_null() [1/4]

template<class X , class Y >

auto wpi::cast_or_null

(

const Y &

Val

)

cast_or_null() [2/4]

template<class X , class Y >

auto wpi::cast_or_null

(

std::unique_ptr< Y > &&

Val

)

cast_or_null() [3/4]

template<class X , class Y >

auto wpi::cast_or_null

(

Y &

Val

)

cast_or_null() [4/4]

template<class X , class Y >

auto wpi::cast_or_null

(

Y *

Val

)

compare_lower()

int wpi::compare_lower ( std::string_view  lhs, std::string_view  rhs  )

noexcept

compare_lower - Compare two strings, ignoring case.

Concat()

template<typename Char , typename Traits , size_t N1, size_t... N>

constexpr auto wpi::Concat ( ct_string< Char, Traits, N1 > const &  s1, ct_string< Char, Traits, N > const &...  s  )

constexpr

Concatenates multiple fixed_strings into a larger fixed_string at compile time.

Parameters

s1	first string
s	second and later strings

Returns

concatenated string

consume_integer()

template<typename T , std::enable_if_t< std::numeric_limits< T >::is_signed, bool > = true>

std::optional< T > wpi::consume_integer ( std::string_view *  str, unsigned  radix  )

inlinenoexcept

Parses the string str as an integer of the specified radix.

If radix is specified as zero, this does radix autosensing using extended C rules: 0 is octal, 0x is hex, 0b is binary.

If the string does not begin with a number of the specified radix, this returns nullopt to signify the error. The string is considered erroneous if empty or if it overflows T. The portion of the string representing the discovered numeric value is removed from the beginning of the string.

contains() [1/3]

constexpr bool wpi::contains ( std::string_view  str, char  ch  )

constexprnoexcept

Checks if str contains the substring other.

contains() [2/3]

constexpr bool wpi::contains ( std::string_view  str, const char *  other  )

constexprnoexcept

Checks if str contains the substring other.

contains() [3/3]

constexpr bool wpi::contains ( std::string_view  str, std::string_view  other  )

constexprnoexcept

Checks if str contains the substring other.

contains_lower() [1/3]

bool wpi::contains_lower ( std::string_view  str, char  ch  )

inlinenoexcept

Checks if str contains the substring other, ignoring case.

contains_lower() [2/3]

bool wpi::contains_lower ( std::string_view  str, const char *  other  )

inlinenoexcept

Checks if str contains the substring other, ignoring case.

contains_lower() [3/3]

bool wpi::contains_lower ( std::string_view  str, std::string_view  other  )

inlinenoexcept

Checks if str contains the substring other, ignoring case.

ConvertCodePointToUTF8()

bool wpi::ConvertCodePointToUTF8	(	unsigned	Source,
		char *&	ResultPtr
	)

Convert an Unicode code point to UTF8 sequence.

Parameters

	Source	a Unicode code point.
[in,out]	ResultPtr	pointer to the output buffer, needs to be at least UNI_MAX_UTF8_BYTES_PER_CODE_POINT bytes. On success ResultPtr is updated one past end of the converted sequence.

Returns

true on success.

ConvertUTF16toUTF32()

ConversionResult wpi::ConvertUTF16toUTF32	(	const UTF16 **	sourceStart,
		const UTF16 *	sourceEnd,
		UTF32 **	targetStart,
		UTF32 *	targetEnd,
		ConversionFlags	flags
	)

ConvertUTF16toUTF8()

ConversionResult wpi::ConvertUTF16toUTF8	(	const UTF16 **	sourceStart,
		const UTF16 *	sourceEnd,
		UTF8 **	targetStart,
		UTF8 *	targetEnd,
		ConversionFlags	flags
	)

convertUTF16ToUTF8String() [1/2]

bool wpi::convertUTF16ToUTF8String	(	std::span< const char >	SrcBytes,
		SmallVectorImpl< char > &	Out
	)

Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.

Parameters

[in]	SrcBytes	A buffer of what is assumed to be UTF-16 encoded text.
[out]	Out	Converted UTF-8 is stored here on success.

Returns

true on success

convertUTF16ToUTF8String() [2/2]

bool wpi::convertUTF16ToUTF8String	(	std::span< const UTF16 >	Src,
		SmallVectorImpl< char > &	Out
	)

Converts a UTF16 string into a UTF8 std::string.

Parameters

[in]	Src	A buffer of UTF-16 encoded text.
[out]	Out	Converted UTF-8 is stored here on success.

Returns

true on success

ConvertUTF32toUTF16()

ConversionResult wpi::ConvertUTF32toUTF16	(	const UTF32 **	sourceStart,
		const UTF32 *	sourceEnd,
		UTF16 **	targetStart,
		UTF16 *	targetEnd,
		ConversionFlags	flags
	)

ConvertUTF32toUTF8()

ConversionResult wpi::ConvertUTF32toUTF8	(	const UTF32 **	sourceStart,
		const UTF32 *	sourceEnd,
		UTF8 **	targetStart,
		UTF8 *	targetEnd,
		ConversionFlags	flags
	)

convertUTF32ToUTF8String() [1/2]

bool wpi::convertUTF32ToUTF8String	(	std::span< const char >	SrcBytes,
		std::string &	Out
	)

Converts a stream of raw bytes assumed to be UTF32 into a UTF8 std::string.

Parameters

[in]	SrcBytes	A buffer of what is assumed to be UTF-32 encoded text.
[out]	Out	Converted UTF-8 is stored here on success.

Returns

true on success

convertUTF32ToUTF8String() [2/2]

bool wpi::convertUTF32ToUTF8String	(	std::span< const UTF32 >	Src,
		std::string &	Out
	)

Converts a UTF32 string into a UTF8 std::string.

Parameters

[in]	Src	A buffer of UTF-32 encoded text.
[out]	Out	Converted UTF-8 is stored here on success.

Returns

true on success

convertUTF8Sequence()

ConversionResult wpi::convertUTF8Sequence ( const UTF8 **  source, const UTF8 *  sourceEnd, UTF32 *  target, ConversionFlags  flags  )

inline

Convert the first UTF8 sequence in the given source buffer to a UTF32 code point.

Parameters

[in,out]	source	A pointer to the source buffer. If the conversion succeeds, this pointer will be updated to point to the byte just past the end of the converted sequence.
	sourceEnd	A pointer just past the end of the source buffer.
[out]	target	The converted code
	flags	Whether the conversion is strict or lenient.

Returns

conversionOK on success

See also

ConvertUTF8toUTF32

ConvertUTF8toUTF16()

ConversionResult wpi::ConvertUTF8toUTF16	(	const UTF8 **	sourceStart,
		const UTF8 *	sourceEnd,
		UTF16 **	targetStart,
		UTF16 *	targetEnd,
		ConversionFlags	flags
	)

convertUTF8ToUTF16String()

bool wpi::convertUTF8ToUTF16String	(	std::string_view	SrcUTF8,
		SmallVectorImpl< UTF16 > &	DstUTF16
	)

Converts a UTF-8 string into a UTF-16 string with native endianness.

Returns

true on success

ConvertUTF8toUTF32()

ConversionResult wpi::ConvertUTF8toUTF32	(	const UTF8 **	sourceStart,
		const UTF8 *	sourceEnd,
		UTF32 **	targetStart,
		UTF32 *	targetEnd,
		ConversionFlags	flags
	)

Convert a partial UTF8 sequence to UTF32.

If the sequence ends in an incomplete code unit sequence, returns sourceIllegal.

ConvertUTF8toUTF32Partial()

ConversionResult wpi::ConvertUTF8toUTF32Partial	(	const UTF8 **	sourceStart,
		const UTF8 *	sourceEnd,
		UTF32 **	targetStart,
		UTF32 *	targetEnd,
		ConversionFlags	flags
	)

Convert a partial UTF8 sequence to UTF32.

If the sequence ends in an incomplete code unit sequence, returns sourceExhausted.

ConvertUTF8toWide() [1/3]

bool wpi::ConvertUTF8toWide	(	const char *	Source,
		std::wstring &	Result
	)

Converts a UTF-8 C-string to a std::wstring.

Returns

true on success.

ConvertUTF8toWide() [2/3]

bool wpi::ConvertUTF8toWide	(	std::string_view	Source,
		std::wstring &	Result
	)

Converts a UTF-8 string_view to a std::wstring.

Returns

true on success.

ConvertUTF8toWide() [3/3]

bool wpi::ConvertUTF8toWide	(	unsigned	WideCharWidth,
		std::string_view	Source,
		char *&	ResultPtr,
		const UTF8 *&	ErrorPtr
	)

Convert an UTF8 string_view to UTF8, UTF16, or UTF32 depending on WideCharWidth.

The converted data is written to ResultPtr, which needs to point to at least WideCharWidth * (Source.Size() + 1) bytes. On success, ResultPtr will point one after the end of the copied string. On failure, ResultPtr will not be changed, and ErrorPtr will be set to the location of the first character which could not be converted.

Returns

true on success.

convertWideToUTF8()

bool wpi::convertWideToUTF8	(	const std::wstring &	Source,
		SmallVectorImpl< char > &	Result
	)

Converts a std::wstring to a UTF-8 encoded std::string.

Returns

true on success.

CreateEvent()

WPI_EventHandle wpi::CreateEvent	(	bool	manualReset = false,
		bool	initialState = false
	)

Creates an event.

Events have binary state (signaled or not signaled) and may be either automatically reset or manually reset. Automatic-reset events go to non-signaled state when a WaitForObject is woken up by the event; manual-reset events require ResetEvent() to be called to set the event to non-signaled state; if ResetEvent() is not called, any waiter on that event will immediately wake when called.

Parameters

manualReset	true for manual reset, false for automatic reset
initialState	true to make the event initially in signaled state

Returns

Event handle

CreateSemaphore()

WPI_SemaphoreHandle wpi::CreateSemaphore	(	int	initialCount = 0,
		int	maximumCount = INT_MAX
	)

Creates a semaphore.

Semaphores keep an internal counter. Releasing the semaphore increases the count. A semaphore with a non-zero count is considered signaled. When a waiter wakes up it atomically decrements the count by 1. This is generally useful in a single-supplier, multiple-consumer scenario.

Parameters

initialCount	initial value for the semaphore's internal counter
maximumCount	maximum value for the samephore's internal counter

Returns

Semaphore handle

CreateSignalObject()

void wpi::CreateSignalObject	(	WPI_Handle	handle,
		bool	manualReset = false,
		bool	initialState = false
	)

Sets up signaling for an arbitrary handle.

With this function, any handle can operate like an event handle.

Parameters

handle	Event handle
manualReset	true for manual reset, false for automatic reset
initialState	true to make the handle initially in signaled state

ct_string()

template<typename Char , size_t M>

wpi::ct_string

(

Char const (&)

s[M]

)

-> ct_string< Char, std::char_traits< Char >, M - 1 >

CTLog2()

template<size_t kValue>

constexpr size_t wpi::CTLog2 ( )

inlineconstexpr

Compile time Log2.

Valid only for positive powers of two.

CTLog2< 1 >()

template<>

constexpr size_t wpi::CTLog2< 1 > ( )

inlineconstexpr

deallocate_buffer()

void wpi::deallocate_buffer	(	void *	Ptr,
		size_t	Size,
		size_t	Alignment
	)

Deallocate a buffer of memory with the given size and alignment.

If supported, this will used the sized delete operator. Also if supported, this will pass the alignment to the delete operator.

The pointer must have been allocated with the corresponding new operator, most likely using the above helper.

Demangle()

std::string wpi::Demangle

(

std::string_view

mangledSymbol

)

Demangle a C++ symbol.

Parameters

mangledSymbol

the mangled symbol.

Returns

The demangled symbol, or mangledSymbol if demangling fails.

DestroyEvent()

void wpi::DestroyEvent

(

WPI_EventHandle

handle

)

Destroys an event.

Destruction wakes up any waiters.

Parameters

handle

event handle

DestroySemaphore()

void wpi::DestroySemaphore

(

WPI_SemaphoreHandle

handle

)

Destroys a semaphore.

Destruction wakes up any waiters.

Parameters

handle

semaphore handle

DestroySignalObject()

void wpi::DestroySignalObject

(

WPI_Handle

handle

)

Cleans up signaling for a handle.

Destruction wakes up any waiters.

Parameters

handle

handle

divideCeil()

uint64_t wpi::divideCeil ( uint64_t  Numerator, uint64_t  Denominator  )

inline

Returns the integer ceil(Numerator / Denominator).

divideNearest()

uint64_t wpi::divideNearest ( uint64_t  Numerator, uint64_t  Denominator  )

inline

Returns the integer nearest(Numerator / Denominator).

drop_back() [1/2]

template<typename T , size_t N>

constexpr std::span< T > wpi::drop_back ( std::span< T, N >  in, typename std::span< T >::size_type  n = 1  )

constexpr

Drop the last N elements of the array.

drop_back() [2/2]

constexpr std::string_view wpi::drop_back ( std::string_view  str, std::string_view::size_type  n = 1  )

constexprnoexcept

Return a string_view equal to str but with the last n elements dropped.

drop_front() [1/2]

template<typename T , size_t N>

constexpr std::span< T > wpi::drop_front ( std::span< T, N >  in, typename std::span< T >::size_type  n = 1  )

constexpr

Drop the first N elements of the array.

drop_front() [2/2]

constexpr std::string_view wpi::drop_front ( std::string_view  str, std::string_view::size_type  n = 1  )

constexprnoexcept

Return a string_view equal to str but with the first n elements dropped.

dyn_cast() [1/4]

template<typename To , typename From >

decltype(auto) wpi::dyn_cast ( const From &  Val )

inline

dyn_cast<X> - Return the argument parameter cast to the specified type.

This casting operator returns null if the argument is of the wrong type, so it can be used to test for a type as well as cast if successful. The value passed in must be present, if not, use dyn_cast_if_present. This should be used in the context of an if statement like this:

if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }

dyn_cast() [2/4]

template<typename To , typename From >

decltype(auto) wpi::dyn_cast ( From &  Val )

inline

dyn_cast() [3/4]

template<typename To , typename From >

decltype(auto) wpi::dyn_cast ( From *  Val )

inline

dyn_cast() [4/4]

template<typename To , typename From >

decltype(auto) wpi::dyn_cast ( std::unique_ptr< From > &&  Val )

inline

dyn_cast_if_present() [1/3]

template<class X , class Y >

auto wpi::dyn_cast_if_present

(

const Y &

Val

)

dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case of optionals) value is accepted.

dyn_cast_if_present() [2/3]

template<class X , class Y >

auto wpi::dyn_cast_if_present

(

Y &

Val

)

dyn_cast_if_present() [3/3]

template<class X , class Y >

auto wpi::dyn_cast_if_present

(

Y *

Val

)

dyn_cast_or_null() [1/3]

template<class X , class Y >

auto wpi::dyn_cast_or_null

(

const Y &

Val

)

dyn_cast_or_null() [2/3]

template<class X , class Y >

auto wpi::dyn_cast_or_null

(

Y &

Val

)

dyn_cast_or_null() [3/3]

template<class X , class Y >

auto wpi::dyn_cast_or_null

(

Y *

Val

)

ends_with() [1/3]

constexpr bool wpi::ends_with ( std::string_view  str, char  suffix  )

constexprnoexcept

Checks if str ends with the given suffix.

ends_with() [2/3]

constexpr bool wpi::ends_with ( std::string_view  str, const char *  suffix  )

constexprnoexcept

Checks if str ends with the given suffix.

ends_with() [3/3]

constexpr bool wpi::ends_with ( std::string_view  str, std::string_view  suffix  )

constexprnoexcept

Checks if str ends with the given suffix.

ends_with_lower() [1/3]

constexpr bool wpi::ends_with_lower ( std::string_view  str, char  suffix  )

constexprnoexcept

Checks if str ends with the given suffix, ignoring case.

ends_with_lower() [2/3]

bool wpi::ends_with_lower ( std::string_view  str, const char *  suffix  )

inlinenoexcept

Checks if str ends with the given suffix, ignoring case.

ends_with_lower() [3/3]

bool wpi::ends_with_lower ( std::string_view  str, std::string_view  suffix  )

noexcept

Checks if str ends with the given suffix, ignoring case.

equals()

constexpr bool wpi::equals ( std::string_view  lhs, std::string_view  rhs  )

constexprnoexcept

equals - Check for string equality, this is more efficient than compare() when the relative ordering of inequal strings isn't needed.

equals_lower()

constexpr bool wpi::equals_lower ( std::string_view  lhs, std::string_view  rhs  )

constexprnoexcept

equals_lower - Check for string equality, ignoring case.

errs()

raw_fd_ostream & wpi::errs

(

)

This returns a reference to a raw_ostream for standard error.

Use it like: errs() << "foo" << "bar"; By default, the stream is tied to stdout to ensure stdout is flushed before stderr is written, to ensure the error messages are written in their expected place.

EscapeURI()

std::string_view wpi::EscapeURI	(	std::string_view	str,
		SmallVectorImpl< char > &	buf,
		bool	spacePlus = true
	)

find_lower() [1/3]

std::string_view::size_type wpi::find_lower ( std::string_view  str, char  ch, std::string_view::size_type  from = 0  )

noexcept

Search for the first character ch in str, ignoring case.

Returns

The index of the first occurrence of ch, or npos if not found.

find_lower() [2/3]

std::string_view::size_type wpi::find_lower ( std::string_view  str, const char *  other, std::string_view::size_type  from = 0  )

inlinenoexcept

Search for the first string other in str, ignoring case.

Returns

The index of the first occurrence of other, or npos if not found.

find_lower() [3/3]

std::string_view::size_type wpi::find_lower ( std::string_view  str, std::string_view  other, std::string_view::size_type  from = 0  )

noexcept

Search for the first string other in str, ignoring case.

Returns

The index of the first occurrence of other, or npos if not found.

FindMultipartBoundary()

bool wpi::FindMultipartBoundary	(	wpi::raw_istream &	is,
		std::string_view	boundary,
		std::string *	saveBuf
	)

for_each()

template<typename F , typename... Ts>

constexpr void wpi::for_each ( F &&  f, Ts &&...  elems  )

constexpr

Calls f(i, elem) for each element of elems where i is the index of the element in elems and elem is the element.

Parameters

f	The callback.
elems	The elements.

ForEachStructSchema()

template<typename T , typename... I>
requires StructSerializable<T, I...>

void wpi::ForEachStructSchema	(	std::invocable< std::string_view, std::string_view > auto	fn,
		const I &...	info
	)

format_to_n_c_str()

template<class OutputIt , class... Args>

void wpi::format_to_n_c_str ( OutputIt  out, std::iter_difference_t< OutputIt >  n, fmt::format_string< Args... >  fmt, Args &&...  args  )

inline

Like std::format_to_n() in that it writes at most n bytes to the output buffer, but also includes a terminating null byte in n.

This is essentially a more performant replacement for std::snprintf().

Parameters

out	The output buffer.
n	The size of the output buffer.
fmt	The format string.
args	The format string arguments.

get() [1/2]

template<std::size_t I, typename PointerTy , unsigned IntBits, typename IntType , typename PtrTraits , typename Info >

decltype(auto) wpi::get

(

const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &

Pair

)

get() [2/2]

template<std::size_t Index, typename ValueTy >

decltype(auto) wpi::get

(

const StringMapEntry< ValueTy > &

E

)

GetHostname() [1/2]

std::string wpi::GetHostname

(

)

GetHostname() [2/2]

std::string_view wpi::GetHostname

(

SmallVectorImpl< char > &

name

)

getNumBytesForUTF8()

unsigned wpi::getNumBytesForUTF8

(

UTF8

firstByte

)

GetStackTrace()

std::string wpi::GetStackTrace

(

int

offset

)

Get a stack trace, ignoring the first "offset" symbols.

Parameters

offset

The number of symbols at the top of the stack to ignore

GetStackTraceDefault()

std::string wpi::GetStackTraceDefault

(

int

offset

)

The default implementation used for GetStackTrace().

Parameters

offset

The number of symbols at the top of the stack to ignore

GetStructSchema()

template<typename T , typename... I>
requires StructSerializable<T, I...>

constexpr std::string_view wpi::GetStructSchema ( const I &...  info )

constexpr

GetStructSchemaBytes()

template<typename T , typename... I>
requires StructSerializable<T, I...>

constexpr std::span< const uint8_t > wpi::GetStructSchemaBytes ( const I &...  info )

constexpr

GetStructSize()

template<typename T , typename... I>
requires StructSerializable<T, I...>

constexpr size_t wpi::GetStructSize ( const I &...  info )

constexpr

Get the size for a raw struct serializable type.

Template Parameters

T	serializable type

Parameters

info	optional struct type info

Returns

size

GetStructTypeString()

template<typename T , typename... I>
requires StructSerializable<T, I...>

constexpr auto wpi::GetStructTypeString ( const I &...  info )

constexpr

Get the type string for a raw struct serializable type.

Template Parameters

T	serializable type

Parameters

info	optional struct type info

Returns

type string

GetSystemTime()

uint64_t wpi::GetSystemTime

(

)

Return the current system time in microseconds since the Unix epoch (January 1st, 1970 00:00 UTC).

Returns

Time in microseconds.

GetTypeName()

template<typename T >

std::string wpi::GetTypeName

(

const T &

type

)

Returns the type name of an object.

Parameters

type	The object

getUTF8SequenceSize()

unsigned wpi::getUTF8SequenceSize	(	const UTF8 *	source,
		const UTF8 *	sourceEnd
	)

hash_combine()

template<typename ... Ts>

hash_code wpi::hash_combine

(

const Ts &...

args

)

Combine values into a single hash_code.

This routine accepts a varying number of arguments of any type. It will attempt to combine them into a single hash_code. For user-defined types it attempts to call a

See also

hash_value overload (via ADL) for the type. For integer and pointer types it directly combines their data into the resulting hash_code.

The result is suitable for returning from a user's hash_value implementation for their user-defined type. Consumers of a type should not call this routine, they should instead call 'hash_value'.

hash_combine_range()

template<typename InputIteratorT >

hash_code wpi::hash_combine_range	(	InputIteratorT	first,
		InputIteratorT	last
	)

Compute a hash_code for a sequence of values.

This hashes a sequence of values. It produces the same hash_code as 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences and is significantly faster given pointers and types which can be hashed as a sequence of bytes.

hash_value() [1/6]

template<typename T >

hash_code wpi::hash_value

(

const std::basic_string< T > &

arg

)

Compute a hash_code for a standard string.

hash_value() [2/6]

template<typename T >

hash_code wpi::hash_value

(

const std::optional< T > &

arg

)

Compute a hash_code for a standard string.

hash_value() [3/6]

template<typename T , typename U >

hash_code wpi::hash_value

(

const std::pair< T, U > &

arg

)

Compute a hash_code for a pair of objects.

hash_value() [4/6]

template<typename... Ts>

hash_code wpi::hash_value

(

const std::tuple< Ts... > &

arg

)

Compute a hash_code for a tuple.

hash_value() [5/6]

template<typename T >

hash_code wpi::hash_value

(

const T *

ptr

)

Compute a hash_code for a pointer's address.

N.B.: This hashes the address. Not the value and not the type.

hash_value() [6/6]

template<typename T >

std::enable_if_t< is_integral_or_enum< T >::value, hash_code > wpi::hash_value

(

T

value

)

Compute a hash_code for any integer value.

Note that this function is intended to compute the same hash_code for a particular value without regard to the pre-promotion type. This is in contrast to hash_combine which may produce different hash_codes for differing argument types even if they would implicit promote to a common type without changing the value.

hasUTF16ByteOrderMark()

bool wpi::hasUTF16ByteOrderMark

(

std::span< const char >

SrcBytes

)

Returns true if a blob of text starts with a UTF-16 big or little endian byte order mark.

hexdigit()

constexpr char wpi::hexdigit ( unsigned  X, bool  LowerCase = false  )

constexprnoexcept

hexdigit - Return the hexadecimal character for the given number X (which should be less than 16).

hexDigitValue()

constexpr unsigned wpi::hexDigitValue ( char  C )

constexprnoexcept

Interpret the given character C as a hexadecimal digit and return its value.

If C is not a valid hex digit, -1U is returned.

Hi_32()

constexpr uint32_t wpi::Hi_32 ( uint64_t  Value )

inlineconstexpr

Return the high 32 bits of a 64 bit value.

http_body_is_final()

int wpi::http_body_is_final

(

const http_parser *

parser

)

http_errno_description()

const char * wpi::http_errno_description

(

enum http_errno

err

)

http_errno_name()

const char * wpi::http_errno_name

(

enum http_errno

err

)

http_method_str()

const char * wpi::http_method_str

(

enum http_method

m

)

http_parser_execute()

size_t wpi::http_parser_execute	(	http_parser *	parser,
		const http_parser_settings *	settings,
		const char *	data,
		size_t	len
	)

http_parser_init()

void wpi::http_parser_init	(	http_parser *	parser,
		enum http_parser_type	type
	)

http_parser_parse_url()

int wpi::http_parser_parse_url	(	const char *	buf,
		size_t	buflen,
		int	is_connect,
		struct http_parser_url *	u
	)

http_parser_pause()

void wpi::http_parser_pause	(	http_parser *	parser,
		int	paused
	)

http_parser_settings_init()

void wpi::http_parser_settings_init

(

http_parser_settings *

settings

)

http_parser_url_init()

void wpi::http_parser_url_init

(

struct http_parser_url *

u

)

http_parser_version()

unsigned long wpi::http_parser_version

(

void

)

http_should_keep_alive()

int wpi::http_should_keep_alive

(

const http_parser *

parser

)

http_status_str()

const char * wpi::http_status_str

(

enum http_status

s

)

insert_sorted()

template<typename T >

std::vector< T >::iterator wpi::insert_sorted	(	std::vector< T > &	vec,
		T const &	item
	)

install_bad_alloc_error_handler()

void wpi::install_bad_alloc_error_handler	(	fatal_error_handler_t	handler,
		void *	user_data = nullptr
	)

Installs a new bad alloc error handler that should be used whenever a bad alloc error, e.g.

failing malloc/calloc, is encountered by LLVM.

The user can install a bad alloc handler, in order to define the behavior in case of failing allocations, e.g. throwing an exception. Note that this handler must not trigger any additional allocations itself.

If no error handler is installed the default is to print the error message to stderr, and call exit(1). If an error handler is installed then it is the handler's responsibility to log the message, it will no longer be printed to stderr. If the error handler returns, then exit(1) will be called.

Parameters

user_data

- An argument which will be passed to the installed error handler.

install_fatal_error_handler()

void wpi::install_fatal_error_handler	(	fatal_error_handler_t	handler,
		void *	user_data = nullptr
	)

install_fatal_error_handler - Installs a new error handler to be used whenever a serious (non-recoverable) error is encountered by LLVM.

If no error handler is installed the default is to print the error message to stderr, and call exit(1). If an error handler is installed then it is the handler's responsibility to log the message, it will no longer be printed to stderr. If the error handler returns, then exit(1) will be called.

It is dangerous to naively use an error handler which throws an exception. Even though some applications desire to gracefully recover from arbitrary faults, blindly throwing exceptions through unfamiliar code isn't a way to achieve this.

Parameters

user_data

- An argument which will be passed to the install error handler.

install_out_of_memory_new_handler()

void wpi::install_out_of_memory_new_handler

(

)

is_constexpr() [1/2]

constexpr bool wpi::is_constexpr (   ... )

constexpr

is_constexpr() [2/2]

template<class Lambda , int = (Lambda{}(), 0)>

constexpr bool wpi::is_constexpr ( Lambda  )

constexpr

isa() [1/2]

template<typename To , typename From >

bool wpi::isa ( const From &  Val )

inline

isa<X> - Return true if the parameter to the template is an instance of one of the template type arguments.

Used like this:

if (isa<Type>(myVal)) { ... } if (isa<Type0, Type1, Type2>(myVal)) { ... }

isa() [2/2]

template<typename First , typename Second , typename... Rest, typename From >

bool wpi::isa ( const From &  Val )

inline

isa_and_nonnull()

template<typename... X, class Y >

bool wpi::isa_and_nonnull ( const Y &  Val )

inline

isa_and_present()

template<typename... X, class Y >

bool wpi::isa_and_present ( const Y &  Val )

inline

isa_and_present<X> - Functionally identical to isa, except that a null value is accepted.

isAlnum()

constexpr bool wpi::isAlnum ( char  C )

constexprnoexcept

Checks whether character C is either a decimal digit or an uppercase or lowercase letter as classified by "C" locale.

isAlpha()

constexpr bool wpi::isAlpha ( char  C )

constexprnoexcept

Checks if character C is a valid letter as classified by "C" locale.

isASCII()

constexpr bool wpi::isASCII ( char  C )

constexprnoexcept

Checks whether character C is valid ASCII (high bit is zero).

isDigit()

constexpr bool wpi::isDigit ( char  C )

constexprnoexcept

Checks if character C is one of the 10 decimal digits.

isHexDigit()

constexpr bool wpi::isHexDigit ( char  C )

constexprnoexcept

Checks if character C is a hexadecimal numeric character.

isInt()

template<unsigned N>

constexpr bool wpi::isInt ( int64_t  x )

inlineconstexpr

Checks if an integer fits into the given bit width.

isIntN()

bool wpi::isIntN ( unsigned  N, int64_t  x  )

inline

Checks if an signed integer fits into the given (dynamic) bit width.

isLegalUTF8Sequence()

Boolean wpi::isLegalUTF8Sequence	(	const UTF8 *	source,
		const UTF8 *	sourceEnd
	)

isLegalUTF8String()

Boolean wpi::isLegalUTF8String	(	const UTF8 **	source,
		const UTF8 *	sourceEnd
	)

isMask_32()

constexpr bool wpi::isMask_32 ( uint32_t  Value )

inlineconstexpr

Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (32 bit version).

Ex. isMask_32(0x0000FFFFU) == true.

isMask_64()

constexpr bool wpi::isMask_64 ( uint64_t  Value )

inlineconstexpr

Return true if the argument is a non-empty sequence of ones starting at the least significant bit with the remainder zero (64 bit version).

isPowerOf2_32()

constexpr bool wpi::isPowerOf2_32 ( uint32_t  Value )

inlineconstexpr

Return true if the argument is a power of two > 0.

Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)

isPowerOf2_64()

constexpr bool wpi::isPowerOf2_64 ( uint64_t  Value )

inlineconstexpr

Return true if the argument is a power of two > 0 (64 bit edition.)

isPrint()

constexpr bool wpi::isPrint ( char  C )

constexprnoexcept

Checks whether character C is printable.

Locale-independent version of the C standard library isprint whose results may differ on different platforms.

isShiftedInt()

template<unsigned N, unsigned S>

constexpr bool wpi::isShiftedInt ( int64_t  x )

inlineconstexpr

Checks if a signed integer is an N bit number shifted left by S.

isShiftedMask_32() [1/2]

constexpr bool wpi::isShiftedMask_32 ( uint32_t  Value )

inlineconstexpr

Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex.

isShiftedMask_32(0x0000FF00U) == true.

isShiftedMask_32() [2/2]

bool wpi::isShiftedMask_32 ( uint32_t  Value, unsigned &  MaskIdx, unsigned &  MaskLen  )

inline

Return true if the argument contains a non-empty sequence of ones with the remainder zero (32 bit version.) Ex.

isShiftedMask_32(0x0000FF00U) == true. If true, MaskIdx will specify the index of the lowest set bit and MaskLen is updated to specify the length of the mask, else neither are updated.

isShiftedMask_64() [1/2]

constexpr bool wpi::isShiftedMask_64 ( uint64_t  Value )

inlineconstexpr

Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.)

isShiftedMask_64() [2/2]

bool wpi::isShiftedMask_64 ( uint64_t  Value, unsigned &  MaskIdx, unsigned &  MaskLen  )

inline

Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit version.) If true, MaskIdx will specify the index of the lowest set bit and MaskLen is updated to specify the length of the mask, else neither are updated.

isShiftedUInt()

template<unsigned N, unsigned S>

constexpr bool wpi::isShiftedUInt ( uint64_t  x )

inlineconstexpr

Checks if a unsigned integer is an N bit number shifted left by S.

isUInt()

template<unsigned N>

constexpr bool wpi::isUInt ( uint64_t  x )

inlineconstexpr

Checks if an unsigned integer fits into the given bit width.

isUIntN()

bool wpi::isUIntN ( unsigned  N, uint64_t  x  )

inline

Checks if an unsigned integer fits into the given (dynamic) bit width.

iterator_range()

template<typename Container >

wpi::iterator_range

(

Container &&

)

-> iterator_range< detail::IterOfRange< Container > >

Lerp()

template<typename T >

constexpr T wpi::Lerp ( const T &  startValue, const T &  endValue, double  t  )

constexpr

Linearly interpolates between two values.

Parameters

startValue	The start value.
endValue	The end value.
t	The fraction for interpolation.

Returns

The interpolated value.

Lo_32()

constexpr uint32_t wpi::Lo_32 ( uint64_t  Value )

inlineconstexpr

Return the low 32 bits of a 64 bit value.

Log2_32()

unsigned wpi::Log2_32 ( uint32_t  Value )

inline

Return the floor log base 2 of the specified value, -1 if the value is zero.

(32 bit edition.) Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2

Log2_32_Ceil()

unsigned wpi::Log2_32_Ceil ( uint32_t  Value )

inline

Return the ceil log base 2 of the specified value, 32 if the value is zero.

(32 bit edition). Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3

Log2_64()

unsigned wpi::Log2_64 ( uint64_t  Value )

inline

Return the floor log base 2 of the specified value, -1 if the value is zero.

(64 bit edition.)

Log2_64_Ceil()

unsigned wpi::Log2_64_Ceil ( uint64_t  Value )

inline

Return the ceil log base 2 of the specified value, 64 if the value is zero.

(64 bit edition.)

ltrim() [1/2]

constexpr std::string_view wpi::ltrim ( std::string_view  str, char  ch  )

constexprnoexcept

Returns str with consecutive ch characters starting from the the left removed.

ltrim() [2/2]

constexpr std::string_view wpi::ltrim ( std::string_view  str, std::string_view  chars = " \t\n\v\f\r"  )

constexprnoexcept

Returns str with consecutive characters in chars starting from the left removed.

Make_64()

constexpr uint64_t wpi::Make_64 ( uint32_t  High, uint32_t  Low  )

inlineconstexpr

Make a 64-bit integer from a high / low pair of 32-bit integers.

make_error_code()

std::error_code wpi::make_error_code ( errc  E )

inline

make_pointee_range()

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>

iterator_range< pointee_iterator< WrappedIteratorT > > wpi::make_pointee_range

(

RangeT &&

Range

)

make_pointer_range()

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>

iterator_range< pointer_iterator< WrappedIteratorT > > wpi::make_pointer_range

(

RangeT &&

Range

)

make_range() [1/2]

template<typename T >

iterator_range< T > wpi::make_range

(

std::pair< T, T >

p

)

make_range() [2/2]

template<class T >

iterator_range< T > wpi::make_range	(	T	x,
		T	y
	)

Convenience function for iterating over sub-ranges.

This provides a bit of syntactic sugar to make using sub-ranges in for loops a bit easier. Analogous to std::make_pair().

make_ready_future() [1/2]

future< void > wpi::make_ready_future ( )

inline

Constructs a valid future with the value set.

make_ready_future() [2/2]

template<typename T >

future< T > wpi::make_ready_future ( T &&  value )

inline

Constructs a valid future with the value set.

make_unexpected()

template<class E >

unexpected< typename std::decay< E >::type > wpi::make_unexpected

(

E &&

e

)

MakeStructArraySchema()

template<typename T , size_t N, typename... I>
requires StructSerializable<T, I...>

constexpr auto wpi::MakeStructArraySchema ( const I &...  info )

constexpr

MakeStructArrayTypeString()

template<typename T , size_t N, typename... I>
requires StructSerializable<T, I...>

constexpr auto wpi::MakeStructArrayTypeString ( const I &...  info )

constexpr

mapWindowsError()

std::error_code wpi::mapWindowsError

(

unsigned

EV

)

maskLeadingOnes()

template<typename T >

T wpi::maskLeadingOnes

(

unsigned

N

)

Create a bitmask with the N left-most bits set to 1, and all other bits set to 0.

Only unsigned types are allowed.

maskLeadingZeros()

template<typename T >

T wpi::maskLeadingZeros

(

unsigned

N

)

Create a bitmask with the N left-most bits set to 0, and all other bits set to 1.

Only unsigned types are allowed.

maskTrailingOnes()

template<typename T >

T wpi::maskTrailingOnes

(

unsigned

N

)

Create a bitmask with the N right-most bits set to 1, and all other bits set to 0.

Only unsigned types are allowed.

maskTrailingZeros()

template<typename T >

T wpi::maskTrailingZeros

(

unsigned

N

)

Create a bitmask with the N right-most bits set to 0, and all other bits set to 1.

Only unsigned types are allowed.

maxIntN()

int64_t wpi::maxIntN ( int64_t  N )

inline

Gets the maximum value for a N-bit signed integer.

maxUIntN()

uint64_t wpi::maxUIntN ( uint64_t  N )

inline

Gets the maximum value for a N-bit unsigned integer.

MimeTypeFromPath()

std::string_view wpi::MimeTypeFromPath

(

std::string_view

path

)

MinAlign()

constexpr uint64_t wpi::MinAlign ( uint64_t  A, uint64_t  B  )

inlineconstexpr

A and B are either alignments or offsets.

Return the minimum alignment that may be assumed after adding the two together.

minIntN()

int64_t wpi::minIntN ( int64_t  N )

inline

Gets the minimum value for a N-bit signed integer.

MulOverflow()

template<typename T >

std::enable_if_t< std::is_signed_v< T >, T > wpi::MulOverflow	(	T	X,
		T	Y,
		T &	Result
	)

Multiply two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred.

NextPowerOf2()

constexpr uint64_t wpi::NextPowerOf2 ( uint64_t  A )

inlineconstexpr

Returns the next power of two (in 64-bits) that is strictly greater than A.

Returns zero on overflow.

Now()

uint64_t wpi::Now

(

)

Return a value representing the current time in microseconds.

This is a monotonic clock with an undefined epoch.

Returns

Time in microseconds.

NowDefault()

uint64_t wpi::NowDefault

(

)

The default implementation used for Now().

In general this is the time returned by the operating system.

Returns

Time in microseconds.

nulls()

raw_ostream & wpi::nulls

(

)

This returns a reference to a raw_ostream which simply discards output.

NumToCtString()

template<intmax_t N, int Base = 10, typename Char = char, typename Traits = std::char_traits<Char>>
requires (Base >= 2 && Base <= 36)

constexpr auto wpi::NumToCtString ( )

constexpr

Converts any integral to a ct_string at compile-time.

Template Parameters

N	number to convert
Base	desired base, can be from 2 to 36
Char	character type
Traits	character traits

operator!=() [1/12]

template<typename DerivedT , typename KeyT , typename ValueT , typename KeyInfoT , typename BucketT >

bool wpi::operator!=	(	const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &	LHS,
		const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &	RHS
	)

Inequality comparison for DenseMap.

Equivalent to !(LHS == RHS). See operator== for performance notes.

operator!=() [2/12]

template<class T , class E , class U , class F >

constexpr bool wpi::operator!= ( const expected< T, E > &  lhs, const expected< U, F > &  rhs  )

constexpr

operator!=() [3/12]

template<class T , class E , class U >

constexpr bool wpi::operator!= ( const expected< T, E > &  x, const U &  v  )

constexpr

operator!=() [4/12]

template<class T , class E >

constexpr bool wpi::operator!= ( const expected< T, E > &  x, const unexpected< E > &  e  )

constexpr

operator!=() [5/12]

template<class E , class F >

constexpr bool wpi::operator!= ( const expected< void, E > &  lhs, const expected< void, F > &  rhs  )

constexpr

operator!=() [6/12]

template<typename PtrType >

bool wpi::operator!=	(	const SmallPtrSetImpl< PtrType > &	LHS,
		const SmallPtrSetImpl< PtrType > &	RHS
	)

Inequality comparison for SmallPtrSet.

Equivalent to !(LHS == RHS).

operator!=() [7/12]

template<typename T , unsigned LN, unsigned RN, typename C >

bool wpi::operator!=	(	const SmallSet< T, LN, C > &	LHS,
		const SmallSet< T, RN, C > &	RHS
	)

Inequality comparison for SmallSet.

Equivalent to !(LHS == RHS). See operator== for performance notes.

operator!=() [8/12]

template<typename ValueTy >

bool wpi::operator!= ( const StringMap< ValueTy > &  lhs, const StringMap< ValueTy > &  rhs  )

inline

operator!=() [9/12]

template<class T , class E , class U >

constexpr bool wpi::operator!= ( const U &  v, const expected< T, E > &  x  )

constexpr

operator!=() [10/12]

template<class T , class E >

constexpr bool wpi::operator!= ( const unexpected< E > &  e, const expected< T, E > &  x  )

constexpr

operator!=() [11/12]

template<class E >

constexpr bool wpi::operator!= ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

operator!=() [12/12]

template<typename ... PTs>

bool wpi::operator!=	(	PointerUnion< PTs... >	lhs,
		PointerUnion< PTs... >	rhs
	)

operator+()

template<typename Char , typename Traits , size_t N1, size_t N2>

constexpr auto wpi::operator+ ( ct_string< Char, Traits, N1 > const &  s1, ct_string< Char, Traits, N2 > const &  s2  )

constexprnoexcept

operator<() [1/3]

template<typename ValueTy >

bool wpi::operator<	(	const StringMap< ValueTy > &	lhs,
		const StringMap< ValueTy > &	rhs
	)

operator<() [2/3]

template<class E >

constexpr bool wpi::operator< ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

operator<() [3/3]

template<typename ... PTs>

bool wpi::operator<	(	PointerUnion< PTs... >	lhs,
		PointerUnion< PTs... >	rhs
	)

operator<<() [1/2]

template<typename OStream , typename T >

std::enable_if_t<!std::is_reference_v< OStream > && std::is_base_of_v< raw_ostream, OStream >, OStream && > wpi::operator<<	(	OStream &&	OS,
		const T &	Value
	)

Call the appropriate insertion operator, given an rvalue reference to a raw_ostream object and return a stream of the same type as the argument.

operator<<() [2/2]

raw_ostream & wpi::operator<<	(	raw_ostream &	OS,
		sys::TimePoint<>	TP
	)

operator<=() [1/2]

template<typename ValueTy >

bool wpi::operator<= ( const StringMap< ValueTy > &  lhs, const StringMap< ValueTy > &  rhs  )

inline

operator<=() [2/2]

template<class E >

constexpr bool wpi::operator<= ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

operator==() [1/12]

template<typename DerivedT , typename KeyT , typename ValueT , typename KeyInfoT , typename BucketT >

bool wpi::operator==	(	const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &	LHS,
		const DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > &	RHS
	)

Equality comparison for DenseMap.

Iterates over elements of LHS confirming that each (key, value) pair in LHS is also in RHS, and that no additional pairs are in RHS. Equivalent to N calls to RHS.find and N value comparisons. Amortized complexity is linear, worst case is O(N^2) (if every hash collides).

operator==() [2/12]

template<class T , class E , class U , class F >

constexpr bool wpi::operator== ( const expected< T, E > &  lhs, const expected< U, F > &  rhs  )

constexpr

operator==() [3/12]

template<class T , class E , class U >

constexpr bool wpi::operator== ( const expected< T, E > &  x, const U &  v  )

constexpr

operator==() [4/12]

template<class T , class E >

constexpr bool wpi::operator== ( const expected< T, E > &  x, const unexpected< E > &  e  )

constexpr

operator==() [5/12]

template<class E , class F >

constexpr bool wpi::operator== ( const expected< void, E > &  lhs, const expected< void, F > &  rhs  )

constexpr

operator==() [6/12]

template<typename PtrType >

bool wpi::operator==	(	const SmallPtrSetImpl< PtrType > &	LHS,
		const SmallPtrSetImpl< PtrType > &	RHS
	)

Equality comparison for SmallPtrSet.

Iterates over elements of LHS confirming that each value from LHS is also in RHS, and that no additional values are in RHS.

operator==() [7/12]

template<typename T , unsigned LN, unsigned RN, typename C >

bool wpi::operator==	(	const SmallSet< T, LN, C > &	LHS,
		const SmallSet< T, RN, C > &	RHS
	)

Equality comparison for SmallSet.

Iterates over elements of LHS confirming that each element is also a member of RHS, and that RHS contains no additional values. Equivalent to N calls to RHS.count. For small-set mode amortized complexity is O(N^2) For large-set mode amortized complexity is linear, worst case is O(N^2) (if every hash collides).

operator==() [8/12]

template<typename ValueTy >

bool wpi::operator==	(	const StringMap< ValueTy > &	lhs,
		const StringMap< ValueTy > &	rhs
	)

operator==() [9/12]

template<class T , class E , class U >

constexpr bool wpi::operator== ( const U &  v, const expected< T, E > &  x  )

constexpr

operator==() [10/12]

template<class T , class E >

constexpr bool wpi::operator== ( const unexpected< E > &  e, const expected< T, E > &  x  )

constexpr

operator==() [11/12]

template<class E >

constexpr bool wpi::operator== ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

operator==() [12/12]

template<typename ... PTs>

bool wpi::operator==	(	PointerUnion< PTs... >	lhs,
		PointerUnion< PTs... >	rhs
	)

operator>() [1/2]

template<typename ValueTy >

bool wpi::operator> ( const StringMap< ValueTy > &  lhs, const StringMap< ValueTy > &  rhs  )

inline

operator>() [2/2]

template<class E >

constexpr bool wpi::operator> ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

operator>=() [1/2]

template<typename ValueTy >

bool wpi::operator>= ( const StringMap< ValueTy > &  lhs, const StringMap< ValueTy > &  rhs  )

inline

operator>=() [2/2]

template<class E >

constexpr bool wpi::operator>= ( const unexpected< E > &  lhs, const unexpected< E > &  rhs  )

constexpr

outs()

raw_fd_ostream & wpi::outs

(

)

This returns a reference to a raw_fd_ostream for standard output.

Use it like: outs() << "foo" << "bar";

PackProtobuf()

template<ProtobufSerializable T>

void wpi::PackProtobuf ( google::protobuf::Message *  msg, const T &  value  )

inline

Pack a serialized protobuf message.

Parameters

msg	protobuf message (mutable, output)
value	object

PackStruct() [1/2]

template<typename T , typename... I>
requires StructSerializable<T, I...>

void wpi::PackStruct ( std::span< uint8_t >  data, T &&  value, const I &...  info  )

inline

Pack a serialized struct.

Parameters

data	struct storage (mutable, output)
value	object
info	optional struct type info

PackStruct() [2/2]

template<size_t Offset, typename T , typename... I>
requires StructSerializable<T, I...>

void wpi::PackStruct ( std::span< uint8_t >  data, T &&  value, const I &...  info  )

inline

Pack a serialized struct starting at a given offset within the data.

This is primarily useful in pack implementations to pack nested structs.

Template Parameters

Offset

starting offset

Parameters

data	struct storage (mutable, output)
value	object
info	optional struct type info

parse_float()

template<typename T >

std::optional< T > wpi::parse_float ( std::string_view  str )

noexcept

Parses the string str as a floating point value.

If the string is invalid or if only a subset of the string is valid, this returns nullopt to signify the error. The string is considered erroneous if empty or if it overflows T.

parse_float< double >()

template<>

std::optional< double > wpi::parse_float< double > ( std::string_view  str )

noexcept

parse_float< float >()

template<>

std::optional< float > wpi::parse_float< float > ( std::string_view  str )

noexcept

parse_float< long double >()

template<>

std::optional< long double > wpi::parse_float< long double > ( std::string_view  str )

noexcept

parse_integer()

template<typename T , std::enable_if_t< std::numeric_limits< T >::is_signed, bool > = true>

std::optional< T > wpi::parse_integer ( std::string_view  str, unsigned  radix  )

inlinenoexcept

Parses the string str as an integer of the specified radix.

If radix is specified as zero, this does radix autosensing using extended C rules: 0 is octal, 0x is hex, 0b is binary.

If the string is invalid or if only a subset of the string is valid, this returns nullopt to signify the error. The string is considered erroneous if empty or if it overflows T.

ParseHttpHeaders()

bool wpi::ParseHttpHeaders	(	raw_istream &	is,
		SmallVectorImpl< char > *	contentType,
		SmallVectorImpl< char > *	contentLength
	)

PowerOf2Ceil()

uint64_t wpi::PowerOf2Ceil ( uint64_t  A )

inline

Returns the power of two which is greater than or equal to the given value.

Essentially, it is a ceil operation across the domain of powers of two.

ReadUleb128() [1/2]

uint64_t wpi::ReadUleb128	(	const char *	addr,
		uint64_t *	ret
	)

Read unsigned LEB128 data.

Decode an unsigned LEB128 encoded datum. The algorithm is taken from Appendix C of the DWARF 3 spec. For information on the encodings refer to section "7.6 - Variable Length Data". Return the number of bytes read.

Parameters

addr	The address where the ULEB128 data is stored.
ret	Address to store the result.

ReadUleb128() [2/2]

bool wpi::ReadUleb128	(	raw_istream &	is,
		uint64_t *	ret
	)

Read unsigned LEB128 data from a stream.

Decode an unsigned LEB128 encoded datum. The algorithm is taken from Appendix C of the DWARF 3 spec. For information on the encodings refer to section "7.6 - Variable Length Data". Return false on stream error, true on success.

Parameters

is	The input stream where the ULEB128 data is to be read from.
ret	Address to store the result.

ReleaseSemaphore()

bool wpi::ReleaseSemaphore	(	WPI_SemaphoreHandle	handle,
		int	releaseCount = 1,
		int *	prevCount = nullptr
	)

Releases N counts of a semaphore.

Parameters

handle	semaphore handle
releaseCount	amount to add to semaphore's internal counter; must be positive
prevCount	if non-null, previous count (output parameter)

Returns

True on successful release, false on failure (e.g. release count would exceed maximum value, or handle invalid)

remove_bad_alloc_error_handler()

void wpi::remove_bad_alloc_error_handler

(

)

Restores default bad alloc error handling behavior.

remove_fatal_error_handler()

void wpi::remove_fatal_error_handler

(

)

Restores default error handling behaviour.

report_bad_alloc_error()

void wpi::report_bad_alloc_error	(	const char *	Reason,
		bool	GenCrashDiag = true
	)

Reports a bad alloc error, calling any user defined bad alloc error handler.

In contrast to the generic 'report_fatal_error' functions, this function might not terminate, e.g. the user defined error handler throws an exception, but it won't return.

Note: When throwing an exception in the bad alloc handler, make sure that the following unwind succeeds, e.g. do not trigger additional allocations in the unwind chain.

If no error handler is installed (default), throws a bad_alloc exception if LLVM is compiled with exception support. Otherwise prints the error to standard error and calls abort().

report_fatal_error() [1/3]

void wpi::report_fatal_error	(	const char *	reason,
		bool	gen_crash_diag = true
	)

Reports a serious error, calling any installed error handler.

These functions are intended to be used for error conditions which are outside the control of the compiler (I/O errors, invalid user input, etc.)

If no error handler is installed the default is to print the message to standard error, followed by a newline. After the error handler is called this function will call abort(), it does not return.

report_fatal_error() [2/3]

void wpi::report_fatal_error	(	const std::string &	reason,
		bool	gen_crash_diag = true
	)

report_fatal_error() [3/3]

void wpi::report_fatal_error	(	std::string_view	reason,
		bool	gen_crash_diag = true
	)

ResetEvent()

void wpi::ResetEvent

(

WPI_EventHandle

handle

)

Sets an event to non-signaled state.

Parameters

handle

event handle

ResetSignalObject()

void wpi::ResetSignalObject

(

WPI_Handle

handle

)

Sets a handle to non-signaled state.

Parameters

handle

handle

reverseBits()

template<typename T >

T wpi::reverseBits

(

T

Val

)

Reverse the bits in Val.

rfind_lower() [1/3]

std::string_view::size_type wpi::rfind_lower ( std::string_view  str, char  ch, std::string_view::size_type  from = std::string_view::npos  )

noexcept

Search for the last character ch in str, ignoring case.

Returns

The index of the last occurrence of ch, or npos if not found.

rfind_lower() [2/3]

std::string_view::size_type wpi::rfind_lower ( std::string_view  str, const char *  other  )

inlinenoexcept

Search for the last string other in str, ignoring case.

Returns

The index of the last occurrence of other, or npos if not found.

rfind_lower() [3/3]

std::string_view::size_type wpi::rfind_lower ( std::string_view  str, std::string_view  other  )

noexcept

Search for the last string other in str, ignoring case.

Returns

The index of the last occurrence of other, or npos if not found.

rsplit() [1/2]

constexpr std::pair< std::string_view, std::string_view > wpi::rsplit ( std::string_view  str, char  separator  )

constexprnoexcept

Splits str into two substrings around the last occurrence of a separator character.

If separator is in the string, then the result is a pair (LHS, RHS) such that (str == LHS + separator + RHS) is true and RHS is minimal. If separator is not in the string, then the result is a pair (LHS, RHS) where (str == LHS) and (RHS == "").

Parameters

separator

The string to split on.

Returns

The split substrings.

rsplit() [2/2]

constexpr std::pair< std::string_view, std::string_view > wpi::rsplit ( std::string_view  str, std::string_view  separator  )

constexprnoexcept

Splits str into two substrings around the last occurrence of a separator string.

If separator is in the string, then the result is a pair (LHS, RHS) such that (str == LHS + separator + RHS) is true and RHS is minimal. If separator is not in the string, then the result is a pair (LHS, RHS) where (str == LHS) and (RHS == "").

Parameters

separator

The string to split on.

Returns

The split substrings.

rtrim() [1/2]

constexpr std::string_view wpi::rtrim ( std::string_view  str, char  ch  )

constexprnoexcept

Returns str with consecutive Char characters starting from the right removed.

rtrim() [2/2]

constexpr std::string_view wpi::rtrim ( std::string_view  str, std::string_view  chars = " \t\n\v\f\r"  )

constexprnoexcept

Returns str with consecutive characters in chars starting from the right removed.

safe_calloc()

LLVM_ATTRIBUTE_RETURNS_NONNULL void * wpi::safe_calloc ( size_t  Count, size_t  Sz  )

inline

safe_malloc()

LLVM_ATTRIBUTE_RETURNS_NONNULL void * wpi::safe_malloc ( size_t  Sz )

inline

safe_realloc()

LLVM_ATTRIBUTE_RETURNS_NONNULL void * wpi::safe_realloc ( void *  Ptr, size_t  Sz  )

inline

SaturatingAdd() [1/2]

template<typename T >

std::enable_if_t< std::is_unsigned_v< T >, T > wpi::SaturatingAdd	(	T	X,
		T	Y,
		bool *	ResultOverflowed = nullptr
	)

Add two unsigned integers, X and Y, of type T.

Clamp the result to the maximum representable value of T on overflow. ResultOverflowed indicates if the result is larger than the maximum representable value of type T.

SaturatingAdd() [2/2]

template<class T , class... Ts>

std::enable_if_t< std::is_unsigned_v< T >, T > wpi::SaturatingAdd	(	T	X,
		T	Y,
		T	Z,
		Ts...	Args
	)

Add multiple unsigned integers of type T.

Clamp the result to the maximum representable value of T on overflow.

SaturatingMultiply()

template<typename T >

std::enable_if_t< std::is_unsigned_v< T >, T > wpi::SaturatingMultiply	(	T	X,
		T	Y,
		bool *	ResultOverflowed = nullptr
	)

Multiply two unsigned integers, X and Y, of type T.

Clamp the result to the maximum representable value of T on overflow. ResultOverflowed indicates if the result is larger than the maximum representable value of type T.

SaturatingMultiplyAdd()

template<typename T >

std::enable_if_t< std::is_unsigned_v< T >, T > wpi::SaturatingMultiplyAdd	(	T	X,
		T	Y,
		T	A,
		bool *	ResultOverflowed = nullptr
	)

Multiply two unsigned integers, X and Y, and add the unsigned integer, A to the product.

Clamp the result to the maximum representable value of T on overflow. ResultOverflowed indicates if the result is larger than the maximum representable value of type T.

set_fixed_execution_hash_seed()

void wpi::set_fixed_execution_hash_seed

(

uint64_t

fixed_value

)

Override the execution seed with a fixed value.

This hashing library uses a per-execution seed designed to change on each run with high probability in order to ensure that the hash codes are not attackable and to ensure that output which is intended to be stable does not rely on the particulars of the hash codes produced.

That said, there are use cases where it is important to be able to reproduce exactly a specific behavior. To that end, we provide a function which will forcibly set the seed to a fixed value. This must be done at the start of the program, before any hashes are computed. Also, it cannot be undone. This makes it thread-hostile and very hard to use outside of immediately on start of a simple program designed for reproducible behavior.

SetEvent()

void wpi::SetEvent

(

WPI_EventHandle

handle

)

Sets an event to signaled state.

Parameters

handle

event handle

SetGetStackTraceImpl()

void wpi::SetGetStackTraceImpl

(

std::string(*)(int offset)

func

)

Set the implementation used by GetStackTrace().

Parameters

func	Function called by GetStackTrace().

SetNowImpl()

void wpi::SetNowImpl

(

uint64_t(*)()

func

)

Set the implementation used by Now().

The implementation must return monotonic time in microseconds to maintain the contract of Now().

Parameters

func	Function called by Now() to return the time.

SetSignalObject()

void wpi::SetSignalObject

(

WPI_Handle

handle

)

Sets a handle to signaled state.

Parameters

handle

handle

sgn()

template<typename T >

constexpr int wpi::sgn ( T  val )

constexpr

shouldReverseIterate()

template<class T = void *>

bool wpi::shouldReverseIterate

(

)

SignExtend32() [1/2]

template<unsigned B>

constexpr int32_t wpi::SignExtend32 ( uint32_t  X )

inlineconstexpr

Sign-extend the number in the bottom B bits of X to a 32-bit integer.

Requires 0 < B <= 32.

SignExtend32() [2/2]

int32_t wpi::SignExtend32 ( uint32_t  X, unsigned  B  )

inline

Sign-extend the number in the bottom B bits of X to a 32-bit integer.

Requires 0 < B <= 32.

SignExtend64() [1/2]

template<unsigned B>

constexpr int64_t wpi::SignExtend64 ( uint64_t  x )

inlineconstexpr

Sign-extend the number in the bottom B bits of X to a 64-bit integer.

Requires 0 < B <= 64.

SignExtend64() [2/2]

int64_t wpi::SignExtend64 ( uint64_t  X, unsigned  B  )

inline

Sign-extend the number in the bottom B bits of X to a 64-bit integer.

Requires 0 < B <= 64.

SizeUleb128()

uint64_t wpi::SizeUleb128

(

uint64_t

val

)

Get size of unsigned LEB128 data.

Determine the number of bytes required to encode an unsigned LEB128 datum. The algorithm is taken from Appendix C of the DWARF 3 spec. For information on the encodings refer to section "7.6 - Variable Length Data". Return the number of bytes required.

Parameters

val	LEB128 data.

slice()

constexpr std::string_view wpi::slice ( std::string_view  str, std::string_view::size_type  start, std::string_view::size_type  end  )

constexprnoexcept

Returns a reference to the substring of str from [start, end).

Parameters

start	The index of the starting character in the substring; if the index is npos or greater than the length of the string then the empty substring will be returned.
end	The index following the last character to include in the substring. If this is npos or exceeds the number of characters remaining in the string, the string suffix (starting with start) will be returned. If this is less than start, an empty string will be returned.

SocketErrno()

int wpi::SocketErrno

(

)

SocketStrerror() [1/2]

std::string wpi::SocketStrerror ( )

inline

SocketStrerror() [2/2]

std::string wpi::SocketStrerror

(

int

code

)

split() [1/4]

constexpr std::pair< std::string_view, std::string_view > wpi::split ( std::string_view  str, char  separator  )

constexprnoexcept

Splits str into two substrings around the first occurrence of a separator character.

If separator is in the string, then the result is a pair (LHS, RHS) such that (str == LHS + separator + RHS) is true and RHS is maximal. If separator is not in the string, then the result is a pair (LHS, RHS) where (str == LHS) and (RHS == "").

Parameters

separator

The character to split on.

Returns

The split substrings.

split() [2/4]

void wpi::split ( std::string_view  str, SmallVectorImpl< std::string_view > &  arr, char  separator, int  maxSplit = -1, bool  keepEmpty = true  )

noexcept

Splits str into substrings around the occurrences of a separator character.

Each substring is stored in arr. If maxSplit is >= 0, at most maxSplit splits are done and consequently <= maxSplit + 1 elements are added to arr. If keepEmpty is false, empty strings are not added to arr. They still count when considering maxSplit An useful invariant is that separator.join(arr) == str if maxSplit == -1 and keepEmpty == true

Parameters

arr	Where to put the substrings.
separator	The character to split on.
maxSplit	The maximum number of times the string is split.
keepEmpty	True if empty substring should be added.

split() [3/4]

void wpi::split ( std::string_view  str, SmallVectorImpl< std::string_view > &  arr, std::string_view  separator, int  maxSplit = -1, bool  keepEmpty = true  )

noexcept

Splits str into substrings around the occurrences of a separator string.

Each substring is stored in arr. If maxSplit is >= 0, at most maxSplit splits are done and consequently <= maxSplit + 1 elements are added to arr. If keepEmpty is false, empty strings are not added to arr. They still count when considering maxSplit An useful invariant is that separator.join(arr) == str if maxSplit == -1 and keepEmpty == true

Parameters

arr	Where to put the substrings.
separator	The string to split on.
maxSplit	The maximum number of times the string is split.
keepEmpty	True if empty substring should be added.

split() [4/4]

constexpr std::pair< std::string_view, std::string_view > wpi::split ( std::string_view  str, std::string_view  separator  )

constexprnoexcept

Splits str into two substrings around the first occurrence of a separator string.

If separator is in the string, then the result is a pair (LHS, RHS) such that (str == LHS + separator + RHS) is true and RHS is maximal. If separator is not in the string, then the result is a pair (LHS, RHS) where (str == LHS) and (RHS == "").

Parameters

separator

The string to split on.

Returns

The split substrings.

starts_with() [1/3]

constexpr bool wpi::starts_with ( std::string_view  str, char  prefix  )

constexprnoexcept

Checks if str starts with the given prefix.

starts_with() [2/3]

constexpr bool wpi::starts_with ( std::string_view  str, const char *  prefix  )

constexprnoexcept

Checks if str starts with the given prefix.

starts_with() [3/3]

constexpr bool wpi::starts_with ( std::string_view  str, std::string_view  prefix  )

constexprnoexcept

Checks if str starts with the given prefix.

starts_with_lower() [1/3]

constexpr bool wpi::starts_with_lower ( std::string_view  str, char  prefix  )

constexprnoexcept

Checks if str starts with the given prefix, ignoring case.

starts_with_lower() [2/3]

bool wpi::starts_with_lower ( std::string_view  str, const char *  prefix  )

inlinenoexcept

Checks if str starts with the given prefix, ignoring case.

starts_with_lower() [3/3]

bool wpi::starts_with_lower ( std::string_view  str, std::string_view  prefix  )

noexcept

Checks if str starts with the given prefix, ignoring case.

SubOverflow()

template<typename T >

std::enable_if_t< std::is_signed_v< T >, T > wpi::SubOverflow	(	T	X,
		T	Y,
		T &	Result
	)

Subtract two signed integers, computing the two's complement truncated result, returning true if an overflow ocurred.

substr()

constexpr std::string_view wpi::substr ( std::string_view  str, std::string_view::size_type  start, std::string_view::size_type  n = std::string_view::npos  )

constexprnoexcept

Returns the substring of str from [start, start + n).

Parameters

start	The index of the starting character in the substring; if the index is npos or greater than the length of the string then the empty substring will be returned.
n	The number of characters to included in the substring. If n exceeds the number of characters remaining in the string, the string suffix (starting with start) will be returned.

swap()

template<class T , class E , detail::enable_if_t<(std::is_void< T >::value||std::is_move_constructible< T >::value) &&detail::is_swappable< T >::value &&std::is_move_constructible< E >::value &&detail::is_swappable< E >::value > * = nullptr>

void wpi::swap ( expected< T, E > &  lhs, expected< T, E > &  rhs  )

noexcept

take_back() [1/2]

template<typename T , size_t N>

constexpr std::span< T > wpi::take_back ( std::span< T, N >  in, typename std::span< T >::size_type  n = 1  )

constexpr

Returns a span equal to in but with only the last n elements remaining.

If n is greater than the length of the span, the entire span is returned.

take_back() [2/2]

constexpr std::string_view wpi::take_back ( std::string_view  str, std::string_view::size_type  n = 1  )

constexprnoexcept

Returns a view equal to str but with only the last n elements remaining.

If n is greater than the length of the string, the entire string is returned.

take_front() [1/2]

template<typename T , size_t N>

constexpr std::span< T > wpi::take_front ( std::span< T, N >  in, typename std::span< T >::size_type  n = 1  )

constexpr

Returns a span equal to in but with only the first n elements remaining.

If n is greater than the length of the span, the entire span is returned.

take_front() [2/2]

constexpr std::string_view wpi::take_front ( std::string_view  str, std::string_view::size_type  n = 1  )

constexprnoexcept

Returns a view equal to str but with only the first n elements remaining.

If n is greater than the length of the string, the entire string is returned.

to_vector() [1/2]

template<unsigned Size, typename R >

SmallVector< ValueTypeFromRangeType< R >, Size > wpi::to_vector

(

R &&

Range

)

Given a range of type R, iterate the entire range and return a SmallVector with elements of the vector.

This is useful, for example, when you want to iterate a range and then sort the results.

to_vector() [2/2]

template<typename R >

SmallVector< ValueTypeFromRangeType< R > > wpi::to_vector

(

R &&

Range

)

to_vector_of() [1/2]

template<typename Out , unsigned Size, typename R >

SmallVector< Out, Size > wpi::to_vector_of

(

R &&

Range

)

to_vector_of() [2/2]

template<typename Out , typename R >

SmallVector< Out > wpi::to_vector_of

(

R &&

Range

)

toLower()

constexpr char wpi::toLower ( char  x )

constexprnoexcept

Returns the corresponding lowercase character if x is uppercase.

toUpper()

constexpr char wpi::toUpper ( char  x )

constexprnoexcept

Returns the corresponding uppercase character if x is lowercase.

transformOptional() [1/2]

template<typename T , typename Function >

auto wpi::transformOptional	(	const std::optional< T > &	O,
		const Function &	F
	)		-> std::optional<decltype(F(*O))>

transformOptional() [2/2]

template<typename T , typename Function >

auto wpi::transformOptional	(	std::optional< T > &&	O,
		const Function &	F
	)		-> std::optional<decltype(F(*std::move(O)))>

trim() [1/2]

constexpr std::string_view wpi::trim ( std::string_view  str, char  ch  )

constexprnoexcept

Returns str with consecutive ch characters starting from the left and right removed.

trim() [2/2]

constexpr std::string_view wpi::trim ( std::string_view  str, std::string_view  chars = " \t\n\v\f\r"  )

constexprnoexcept

Returns str with consecutive characters in chars starting from the left and right removed.

UnescapeCString()

std::pair< std::string_view, std::string_view > wpi::UnescapeCString	(	std::string_view	str,
		SmallVectorImpl< char > &	buf
	)

Unescapes a C-style string (reverse operation to raw_ostream::write_escaped).

Scans through str until either the end is reached or an unescaped double quote character is found.

Parameters

str	input string
buf	buffer for unescaped characters

Returns

pair of the unescaped string and any remaining input

UnescapeURI()

std::string_view wpi::UnescapeURI	(	std::string_view	str,
		SmallVectorImpl< char > &	buf,
		bool *	error
	)

unique_dyn_cast() [1/2]

template<class X , class Y >

auto wpi::unique_dyn_cast ( std::unique_ptr< Y > &&  Val )

inline

unique_dyn_cast() [2/2]

template<class X , class Y >

CastInfo< X, std::unique_ptr< Y > >::CastResultType wpi::unique_dyn_cast ( std::unique_ptr< Y > &  Val )

inline

unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>, taking ownership of the input pointer iff isa<X>(Val) is true.

If the cast is successful, From refers to nullptr on exit and the casted value is returned. If the cast is unsuccessful, the function returns nullptr and From is unchanged.

unique_dyn_cast_or_null() [1/2]

template<class X , class Y >

auto wpi::unique_dyn_cast_or_null ( std::unique_ptr< Y > &&  Val )

inline

unique_dyn_cast_or_null() [2/2]

template<class X , class Y >

CastInfo< X, std::unique_ptr< Y > >::CastResultType wpi::unique_dyn_cast_or_null ( std::unique_ptr< Y > &  Val )

inline

UnpackProtobuf()

template<ProtobufSerializable T>

T wpi::UnpackProtobuf ( const google::protobuf::Message &  msg )

inline

Unpack a serialized protobuf message.

Template Parameters

T	object type

Parameters

msg	protobuf message

Returns

Deserialized object

UnpackProtobufInto()

template<ProtobufSerializable T>

void wpi::UnpackProtobufInto ( T *  out, const google::protobuf::Message &  msg  )

inline

Unpack a serialized struct into an existing object, overwriting its contents.

Parameters

out	object (output)
msg	protobuf message

UnpackStruct() [1/2]

template<typename T , typename... I>
requires StructSerializable<T, I...>

T wpi::UnpackStruct ( std::span< const uint8_t >  data, const I &...  info  )

inline

Unpack a serialized struct.

Template Parameters

T	object type

Parameters

data	raw struct data
info	optional struct type info

Returns

Deserialized object

UnpackStruct() [2/2]

template<typename T , size_t Offset, typename... I>
requires StructSerializable<T, I...>

T wpi::UnpackStruct ( std::span< const uint8_t >  data, const I &...  info  )

inline

Unpack a serialized struct starting at a given offset within the data.

This is primarily useful in unpack implementations to unpack nested structs.

Template Parameters

T	object type
Offset	starting offset

Parameters

data	raw struct data
info	optional struct type info

Returns

Deserialized object

UnpackStructInto() [1/2]

template<typename T , typename... I>
requires StructSerializable<T, I...>

void wpi::UnpackStructInto ( T *  out, std::span< const uint8_t >  data, const I &...  info  )

inline

Unpack a serialized struct into an existing object, overwriting its contents.

Parameters

out	object (output)
data	raw struct data
info	optional struct type info

UnpackStructInto() [2/2]

template<size_t Offset, typename T , typename... I>
requires StructSerializable<T, I...>

void wpi::UnpackStructInto ( T *  out, std::span< const uint8_t >  data, const I &...  info  )

inline

Unpack a serialized struct into an existing object, overwriting its contents, and starting at a given offset within the data.

This is primarily useful in unpack implementations to unpack nested structs.

Template Parameters

Offset

starting offset

Parameters

out	object (output)
data	raw struct data
info	optional struct type info

utohexstr()

std::string wpi::utohexstr ( unsigned long long  val, bool  lowerCase = false  )

inline

WaitForObject() [1/2]

bool wpi::WaitForObject

(

WPI_Handle

handle

)

Waits for an handle to be signaled.

Parameters

handle

handle to wait on

Returns

True if handle was signaled, false otherwise (e.g. object was destroyed)

WaitForObject() [2/2]

bool wpi::WaitForObject	(	WPI_Handle	handle,
		double	timeout,
		bool *	timedOut
	)

Waits for an handle to be signaled, with timeout.

Parameters

handle	handle to wait on
timeout	timeout in seconds
timedOut	if non-null, set to true if timeout reached without handle being signaled; set to false otherwise (output)

Returns

True if handle was signaled, false otherwise (e.g. object was destroyed or timed out)

WaitForObjects() [1/4]

std::span< WPI_Handle > wpi::WaitForObjects ( std::initializer_list< WPI_Handle >  handles, std::span< WPI_Handle >  signaled  )

inline

Waits for one or more handles to be signaled.

Invalid handles are treated as signaled; the returned array will have the handle error bit set for any invalid handles.

Parameters

handles	array of handles to wait on
signaled	output array for storage of signaled handles; must be at least the size of the handles input array

Returns

array of signaled handles (points into signaled array)

WaitForObjects() [2/4]

std::span< WPI_Handle > wpi::WaitForObjects ( std::initializer_list< WPI_Handle >  handles, std::span< WPI_Handle >  signaled, double  timeout, bool *  timedOut  )

inline

Waits for one or more handles to be signaled, with timeout.

Invalid handles are treated as signaled; the returned array will have the handle error bit set for any invalid handles.

Parameters

handles	array of handles to wait on
signaled	output array for storage of signaled handles; must be at least the size of the handles input array
timeout	timeout in seconds
timedOut	if non-null, set to true if timeout reached without any handle being signaled; set to false otherwise (output)

Returns

array of signaled handles (points into signaled array)

WaitForObjects() [3/4]

std::span< WPI_Handle > wpi::WaitForObjects	(	std::span< const WPI_Handle >	handles,
		std::span< WPI_Handle >	signaled
	)

Waits for one or more handles to be signaled.

Invalid handles are treated as signaled; the returned array will have the handle error bit set for any invalid handles.

Parameters

handles	array of handles to wait on
signaled	output array for storage of signaled handles; must be at least the size of the handles input array

Returns

array of signaled handles (points into signaled array)

WaitForObjects() [4/4]

std::span< WPI_Handle > wpi::WaitForObjects	(	std::span< const WPI_Handle >	handles,
		std::span< WPI_Handle >	signaled,
		double	timeout,
		bool *	timedOut
	)

Waits for one or more handles to be signaled, with timeout.

Invalid handles are treated as signaled; the returned array will have the handle error bit set for any invalid handles.

Parameters

handles	array of handles to wait on
signaled	output array for storage of signaled handles; must be at least the size of the handles input array
timeout	timeout in seconds
timedOut	if non-null, set to true if timeout reached without any handle being signaled; set to false otherwise (output)

Returns

array of signaled handles (points into signaled array)

wpi_unreachable_internal()

void wpi::wpi_unreachable_internal	(	const char *	msg = nullptr,
		const char *	file = nullptr,
		unsigned	line = 0
	)

This function calls abort(), and prints the optional message to stderr.

Use the wpi_unreachable macro (that adds location info), instead of calling this function directly.

WriteUleb128() [1/2]

void wpi::WriteUleb128	(	raw_ostream &	os,
		uint64_t	val
	)

Write unsigned LEB128 data.

Encode an unsigned LEB128 encoded datum. The algorithm is taken from Appendix C of the DWARF 3 spec. For information on the encodings refer to section "7.6 - Variable Length Data".

Parameters

os	Output stream.
val	Value to be stored.

WriteUleb128() [2/2]

uint64_t wpi::WriteUleb128	(	SmallVectorImpl< char > &	dest,
		uint64_t	val
	)

Write unsigned LEB128 data.

Encode an unsigned LEB128 encoded datum. The algorithm is taken from Appendix C of the DWARF 3 spec. For information on the encodings refer to section "7.6 - Variable Length Data". Return the number of bytes written.

Parameters

dest	The address where the ULEB128 data is to be stored.
val	Value to be stored.

xxh3_64bits() [1/2]

uint64_t wpi::xxh3_64bits

(

std::span< const uint8_t >

data

)

xxh3_64bits() [2/2]

uint64_t wpi::xxh3_64bits ( std::string_view  data )

inline

xxHash64() [1/2]

uint64_t wpi::xxHash64

(

std::span< const uint8_t >

Data

)

xxHash64() [2/2]

uint64_t wpi::xxHash64

(

std::string_view

Data

)