Harlinn::Common::Core Namespace Reference

Namespaces
namespace	Atomic
namespace	BitConverter
	The BitConverter namespace contains methods for converting a SimpleByteSpanLike container to one of the base data types, as well as for converting a base data type to a vector of bytes.
namespace	Com
namespace	Concurrency
namespace	Crypto
namespace	CurrentProcess
namespace	CurrentThread
namespace	Data
namespace	Demangle
namespace	details
namespace	Doxygen
namespace	Environment
namespace	Ese
namespace	Formatting
namespace	Generators
namespace	Html
namespace	Http
namespace	Internal
namespace	IO
namespace	LMDB
namespace	LMDBEx
namespace	Logging
namespace	Math
namespace	Messaging
namespace	Meta
namespace	Net
namespace	Network
namespace	Persistent
namespace	RapidXml
namespace	Reflection
namespace	Resources
namespace	RtWorkQ
namespace	Runtime
namespace	Security
namespace	Services
namespace	SIMD
namespace	Test
namespace	Threading
namespace	ThreadPools
namespace	Types
namespace	Utf
namespace	Wbem
namespace	Xml
namespace	ZeroMq

Classes
class	_ICivicAddressReportFactoryEvents_Sink
class	_ILatLongReportFactoryEvents_Sink
class	AccessViolationException
class	AdviseSink
class	AdviseSink2
	The IAdviseSink2 interface is an extension of the IAdviseSink interface, adding the method OnLinkSrcChange to the contract to handle a change in the moniker of a linked object. This avoids overloading the implementation IAdviseSink::OnRename to handle the renaming of both embedded objects and linked objects. In applications where different blocks of code might execute depending on which of these two similar events has occurred, using the same method for both events complicates testing and debugging. More...
class	AdviseSinkEx
	This interface is derived from IAdviseSink to provide extensions for notifying the sink of changes in an object's view status. More...
class	AggregateException
class	Allocator
struct	AlwaysFalse
class	AppDomainUnloadedException
class	Application
class	ApplicationDirectories
class	ApplicationException
class	ApplicationOptions
class	ArgumentException
class	ArgumentNullException
class	ArgumentOutOfRangeException
class	ArithmeticException
class	ArrayReader
class	ArrayTypeMismatchException
class	ArrayWriter
class	AsyncAdviseSink
	Asynchronous implementation of IAdviseSink. More...
class	AsyncAdviseSink2
	Asynchronous implementation of IAdviseSink2. More...
class	AsyncUnknown
class	AtomicReferenceCount
class	AttachedSafeArray
class	AttachedSysString
class	BadImageFormatException
class	BasicString
	This is a reference counted string class. More...
class	BasicStringView
class	Binary
	A reference counted buffer, primarily intended for binary data. More...
class	BindCtx
	Provides access to a bind context, which is an object that stores information about a particular moniker binding operation. More...
struct	BitMask
class	Bits
	A type that holds a fixed number of bits. More...
union	Bits16
union	Bits32
union	Bits64
struct	Bits8
struct	BitTraits
struct	BitTraits< bool >
struct	BitTraits< Byte >
struct	BitTraits< char >
struct	BitTraits< Int16 >
struct	BitTraits< Int32 >
struct	BitTraits< Int64 >
struct	BitTraits< SByte >
struct	BitTraits< UInt16 >
struct	BitTraits< UInt32 >
struct	BitTraits< UInt64 >
struct	BitTraits< wchar_t >
struct	BitTraitsBase
class	BitVector
	A resizeable bit-vector. More...
class	BlockingConcurrentQueue
class	BlockingLock
	Provides a semaphore that can be used to provide temporarily exclusive access to a shared resource such as a file. More...
struct	BooleanBitTraits
class	BooleanSafeArray
class	ByteArray
	A Byte array for compile-time serialization of data. More...
struct	ByteBitTraits
class	CannotUnloadAppDomainException
struct	CharBitTraits
class	CivicAddressReport
class	CivicAddressReportFactory
class	ClassActivator
	Specifies a method that retrieves a class object. More...
class	ClassFactory
	Enables a class of objects to be created. More...
class	ClassFactory2
class	ComAllocator
	A C++ allocator that uses CoTaskMemAlloc and CoTaskMemFree. More...
class	ComBuffer
	A movable buffer class the handles memory management using CoTaskMemAlloc, CoTaskMemFree and CoTaskMemRealloc More...
class	ComInitialize
	Initializes the COM library for use by the calling thread, sets the thread's concurrency model, and creates a new apartment for the thread if one is required. Calls CoUninitialize() in the destructor. More...
class	ComPtr
	A generic smart pointer for managing COM interfaces. More...
class	ComString
	A simple string class that uses CoTaskMemAlloc and CoTaskMemFree. More...
class	ConcurrentQueue
struct	ConcurrentQueueDefaultTraits
class	ConditionVariable
	Condition variables are synchronization primitives that enable threads to wait until a particular condition occurs. Condition variables are user-mode objects that cannot be shared across processes. More...
class	ConnectData
	Describes a connection that exists to a given connection point. More...
class	ConnectionPoint
	Supports connection points for connectable objects. More...
class	ConnectionPointContainer
	Supports connection points for connectable objects. More...
class	Console
struct	ConsumerToken
class	ContextMarshalException
class	Continue
	Indicates whether or not to continue an operation. Used with remote procedure calls. More...
class	CreateErrorInfo
	Returns error information. More...
class	CreateObject_
class	CreateTypeInfo
	Provides the tools for creating and administering the type information defined through the type description. More...
class	CreateTypeInfo2
class	CreateTypeLib
	Provides the methods for creating and managing the component or file that contains type information. Type libraries are created from type descriptions using the MIDL compiler. These type libraries are accessed through the ITypeLib interface. More...
class	CreateTypeLib2
	Provides the methods for creating and managing the component or file that contains type information. Derives from ICreateTypeLib. The ICreateTypeInfo instance returned from ICreateTypeLib can be accessed through a QueryInterface call to ICreateTypeInfo2. More...
class	CriticalSection
	A critical section object provides synchronization similar to that provided by a mutex object, except that a critical section can be used only by the threads of a single process. Critical section objects cannot be shared across processes. More...
class	Currency
	Currency are stored as 64-bit integer, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right. More...
class	DataAdviseHolder
class	DataMisalignedException
class	DataObject
class	DataSource
class	DataSourceColumn
class	DateTime
class	DefaultExceptionReporter
	The default exception reporter implementation. More...
class	DefaultLocation
class	DelayedPropertyStoreFactory
class	DirectWriterLock
	The IDirectWriterLock interface enables a single writer to obtain exclusive write access to a root storage object opened in direct mode while allowing concurrent access by multiple readers. This single-writer, multiple-reader mode does not require the overhead of making a snapshot copy of the storage for the readers. More...
class	Dispatch
	Exposes objects, methods and properties to programming tools and other applications that support Automation. COM components implement the IDispatch interface to enable access by Automation clients. More...
class	DispatchEx
	Extends Dispatch with enhanced support for dynamic scripting languages. More...
class	DispCivicAddressReport
class	DispLatLongReport
class	DivideByZeroException
class	DllNotFoundException
class	DropSource
class	DropSourceNotify
	The IDropSourceNotify interface is implemented on an IDropSource object to receive notifications from OLE when a user drags the mouse into or out of a potential drop target window. More...
class	DropTarget
class	DuplicateWaitObjectException
class	EnterpriseDropTarget
	When implemented by the drop target application, this interface gives the OLE drag and drop engine the ability to determine whether the drop target application intends to evaluate enterprise protection policy and gives the OLE drag and drop engine a way to provide the enterprise ID of the drop source application to the drop target application. More...
class	EntryPointNotFoundException
class	Enum
class	EnumBase
class	EnumConnectionPoints
	Enumerates connection points. More...
class	EnumConnections
	Enumerates the current connections for a connectable object. More...
class	EnumFORMATETC
	Enumerates the FORMATETC structures that define the formats and media supported by a given data object. More...
class	EnumMoniker
	Enumerates the components of a moniker or the monikers in a table of monikers. More...
class	EnumOleUndoUnits
	Enumerates the undo units on the undo or redo stack. More...
class	EnumOLEVERB
	Enumerates the different verbs available for an object in order of ascending verb number. An enumerator that implements the IEnumOLEVERB interface is returned by IOleObject::EnumVerbs. More...
class	EnumShellItems
class	EnumSTATDATA
	Enumerates the advisory connection information for a data object. More...
class	EnumSTATSTG
	The IEnumSTATSTG interface enumerates an array of STATSTG structures. These structures contain statistical data about open storage, stream, or byte array objects. More...
class	EnumString
	Enumerate strings. LPOLESTR is the type that indicates a pointer to a zero-terminated string of wide, or Unicode, characters. More...
class	EnumUnknown
class	EnumVARIANT
class	EnumWbemClassObject
class	ErrorInfo
	Provides detailed contextual error information. More...
class	ErrorLog
	Communicates detailed error information between a client and an object. More...
class	EventWaitHandle
class	EventWaitHandleAccessMask
class	Exception
class	ExceptionData
class	ExceptionLocation
class	ExceptionLocationData
class	ExceptionReporter
	Mandatory base class for exception reporters. More...
class	ExecutionEngineException
class	FieldAccessException
class	FileMapping
	A file mapping is the association of a file's contents with a portion of the virtual address space of a process. More...
class	FillLockBytes
	The IFillLockBytes interface enables downloading code to write data asynchronously to a structured storage byte array. When the downloading code has new data available, it calls IFillLockBytes::FillAppend or IFillLockBytes::FillAt to write the data to the byte array. An application attempting to access this data, through calls to the ILockBytes interface, can do so even as the downloader continues to make calls to IFillLockBytes. If the application attempts to access data that has not already been downloaded through a call to IFillLockBytes, then ILockBytes returns a new error, E_PENDING. More...
struct	FilterSpecification
class	FixedBinary
class	FixedSizeMemoryManager
struct	FixedSizeMemoryManagerStatistics
class	FixedString
class	Flags
class	Font
class	FontDisp
class	FontEventsDisp
class	ForegroundTransfer
	Transfers the foreground window to the process hosting the COM server. More...
class	FormatException
class	Guid
	Represents a globally unique identifier (GUID). More...
class	Handle
class	IndexOutOfRangeException
class	InitializeWithFile
class	InitializeWithStream
class	InsufficientExecutionStackException
class	InsufficientMemoryException
struct	Int16BitTraits
struct	Int32BitTraits
struct	Int64BitTraits
class	Integer
	A typed wrapper for integral types. More...
class	InterlockedLinkedList
class	Interval
	A closed/open interval that works well with the boost Interval Container Library. More...
class	InvalidCastException
class	InvalidOperationException
class	InvalidProgramException
class	InvalidTimeZoneException
class	IWbemObjectSinkDispatcher
class	IWbemObjectSinkDispatcherBase
class	IWbemObjectSinkImplementationBase
class	LatLongReport
class	LatLongReportFactory
class	LayoutStorage
class	LightweightSemaphore
class	List
class	ListConstIterator
class	ListIterator
class	Location
class	LocationEventsSinkImpl
class	LocationPermissions
class	LocationPower
class	LocationReport
class	LocationReportFactory
class	LockBytes
	The ILockBytes interface is implemented on a byte array object that is backed by some physical storage, such as a disk file, global memory, or a database. It is used by a COM compound file storage object to give its root storage access to the physical device, while isolating the root storage from the details of accessing the physical storage. More...
class	Malloc
class	MallocaDeleter
class	MallocAllocator
class	Marshal
class	MemberAccessException
class	MessageFilter
	Provides COM servers and applications with the ability to selectively handle incoming and outgoing COM messages while waiting for responses from synchronous calls. Filtering messages helps to ensure that calls are handled in a manner that improves performance and avoids deadlocks. COM messages can be synchronous, asynchronous, or input-synchronized; the majority of interface calls are synchronous. More...
class	MethodAccessException
class	MissingFieldException
class	MissingMemberException
class	MissingMethodException
class	ModuleHandle
class	MofCompiler
class	Moniker
class	MulticastNotSupportedException
class	Mutex
class	MutexAccessMask
class	NamedPropertyStore
class	NotFiniteNumberException
class	NotImplementedException
class	NotSupportedException
class	NullReferenceException
class	ObjectWithPropertyKey
class	ObjectWithSite
class	Observable
class	OldVector
class	OleAdviseHolder
	Manages advisory connections and compound document notifications in an object server. Its methods are intended to be used to implement the advisory methods of IOleObject. IOleAdviseHolder is implemented on an advise holder object. Its methods establish and delete advisory connections from the object managed by the server to the object's container, which must contain an advise sink (support the IAdviseSink interface). The advise holder object must also keep track of which advise sinks are interested in which notifications and pass along the notifications as appropriate. More...
class	OleCache
	Provides control of the presentation data that gets cached inside of an object. Cached presentation data is available to the container of the object even when the server application is not running or is unavailable. More...
class	OleCache2
	Enables object clients to selectively update each cache that was created with IOleCache::Cache. More...
class	OleCacheControl
	Provides proper maintenance of caches. It maintains the caches by connecting the running object's IDataObject implementation to the cache, allowing the cache to receive notifications from the running object. More...
class	OleClientSite
	Provides the primary means by which an embedded object obtains information about the location and extent of its display site, its moniker, its user interface, and other resources provided by its container. An object server calls IOleClientSite to request services from the container. A container must provide one instance of IOleClientSite for every compound-document object it contains. More...
class	OleContainer
	Enumerates objects in a compound document or lock a container in the running state. Container and object applications both implement this interface. More...
class	OleControl
	Provides the features for supporting keyboard mnemonics, ambient properties, and events in control objects. More...
class	OleControlSite
	Provides the methods that enable a site object to manage each embedded control within a container. A site object provides IOleControlSite as well as other site interfaces such as IOleClientSite and IOleInPlaceSite. When a control requires the services expressed through this interface, it will query one of the other client site interfaces for IOleControlSite. More...
class	OleInPlaceActiveObject
	Provides a direct channel of communication between an in-place object and the associated application's outer-most frame window and the document window within the application that contains the embedded object. The communication involves the translation of messages, the state of the frame window (activated or deactivated), and the state of the document window (activated or deactivated). Also, it informs the object when it needs to resize its borders, and manages modeless dialog boxes. More...
class	OleInPlaceFrame
	Controls the container's top-level frame window. This control involves allowing the container to insert its menu group into the composite menu, install the composite menu into the appropriate window frame, and remove the container's menu elements from the composite menu. It sets and displays status text relevant to the in-place object. It also enables or disables the frame's modeless dialog boxes, and translates accelerator keystrokes intended for the container's frame. More...
class	OleInPlaceObject
class	OleInPlaceObjectWindowless
class	OleInPlaceSite
class	OleInPlaceSiteEx
class	OleInPlaceSiteWindowless
class	OleInPlaceUIWindow
	Implemented by container applications and used by object applications to negotiate border space on the document or frame window. The container provides a RECT structure in which the object can place toolbars and other similar controls, determines if tools can in fact be installed around the object's window frame, allocates space for the border, and establishes a communication channel between the object and each frame and document window. More...
class	OleItemContainer
class	OleLink
class	OleObject
	Serves as the principal means by which an embedded object provides basic functionality to, and communicates with, its container. More...
class	OleParentUndoUnit
class	OleUndoManager
	The IOleUndoManager interface enables containers to implement multi-level undo and redo operations for actions that occur within contained controls. More...
class	OleUndoUnit
class	OleWindow
	The IOleWindow interface provides methods that allow an application to obtain the handle to the various windows that participate in in-place activation, and also to enter and exit context-sensitive help mode. More...
class	OperationCanceledException
class	OutOfMemoryException
class	OverflowException
class	OwnerVector
class	ParseDisplayName
	Parses a displayable name string to convert it into a moniker for custom moniker implementations. More...
class	PerPropertyBrowsing
	Retrieves the information in the property pages offered by an object. More...
class	Persist
	Wrapper for the IPersist interface. IPersist provides the CLSID of an object that can be stored persistently in the system. Allows the object to specify which object handler to use in the client process, as it is used in the default implementation of marshaling. More...
class	PersistFile
	Enables an object to be loaded from or saved to a disk file, rather than a storage object or stream. Because the information needed to open a file varies greatly from one application to another, the implementation of IPersistFile::Load on the object must also open its disk file. More...
class	PersistMemory
	Saves and loads objects from a stream. More...
class	PersistPropertyBag
	Works with IPropertyBag and IErrorlog to define an individual property-based persistence mechanism. More...
class	PersistPropertyBag2
	Works with the IPropertyBag2 interface and the IErrorlog interface to define an individual property-based persistence mechanism. More...
class	PersistSerializedPropStorage
class	PersistSerializedPropStorage2
class	PersistStorage
	Enables a container application to pass a storage object to one of its contained objects and to load and save the storage object. This interface supports the structured storage model, in which each contained object has its own storage that is nested within the container's storage. More...
class	PersistStream
	Wrapper for the IPersistStream interface. IPersistStream enables the saving and loading of objects that use a simple serial stream for their storage needs. More...
class	PersistStreamInit
class	Picture
class	Picture2
class	PictureDisp
class	PlatformNotSupportedException
class	PointerInactive
class	PortableDeviceKeyCollection
class	PortableDevicePropVariantCollection
class	PortableDeviceValues
class	PortableDeviceValuesCollection
class	Process
class	ProcessAccessMask
class	ProcessLock
	Used by ISurrogateService to prevent the process from terminating due to a time-out. More...
class	ProcessOptions
struct	ProducerToken
class	ProgressNotify
	Enables applications and other objects to receive notifications of changes in the progress of a downloading operation. More...
class	PropertyBag
class	PropertyBag2
	Provides an object with a property bag in which the object can save its properties persistently. More...
class	PropertyChange
class	PropertyChangeArray
class	PropertyDescription
class	PropertyDescription2
class	PropertyDescriptionAliasInfo
class	PropertyDescriptionList
class	PropertyDescriptionRelatedPropertyInfo
class	PropertyDescriptionSearchInfo
class	PropertyEnumType
class	PropertyEnumType2
class	PropertyEnumTypeList
class	PropertyNotifySink
class	PropertyPage
class	PropertyPage2
class	PropertyPageSite
	Provides the main features for a property page site object. More...
class	PropertyStore
class	PropertyStoreCache
class	PropertyStoreCapabilities
class	PropertyStoreFactory
class	PropertySystem
class	PropertySystemChangeNotify
class	PropertyVariant
class	ProvideClassInfo
	Provides access to the type information for an object's coclass entry in its type library. More...
class	ProvideClassInfo2
	An extension to ProvideClassInfo (IProvideClassInfo) that makes is faster and easier to retrieve an object's outgoing interface IID for its default event set. More...
class	ProvideMultipleClassInfo
	An extension to IProvideClassInfo2 that makes it faster and easier to retrieve type information from a component that may have multiple coclasses that determine its behavior. More...
class	QuickActivate
	Enables controls and containers to avoid performance bottlenecks on loading controls. It combines the load-time or initialization-time handshaking between the control and its container into a single call. More...
class	RankException
class	RdtscConverter
class	RecordInfo
	Describes the structure of a particular UDT. You can use IRecordInfo any time you need to access the description of UDTs contained in type libraries. IRecordInfo can be reused as needed; there can be many instances of the UDT for a single IRecordInfo pointer. More...
class	ReferenceCounted
class	ReferenceCountedData
class	ReferenceCountedPtr
class	ReferenceCountedThreadSafe
class	RegistryHandle
class	RootStorage
	The IRootStorage interface contains a single method that switches a storage object to a different underlying file and saves the storage object to that file. The save operation occurs even with low-memory conditions and uncommitted changes to the storage object. A subsequent call to IStorage::Commit is guaranteed to not consume additional memory. More...
class	ROTData
	Implemented by monikers to enable the running object table (ROT) to compare monikers against each other. More...
class	RtwqAsyncCallback
class	RtwqAsyncResult
class	RtwqPlatformEvents
class	RunnableObject
	Enables a container to control the running of its embedded objects. In the case of an object implemented with a local server, calling the Run method launches the server's .EXE file. In the case of an object implemented with an in-process server, calling Run causes the object .DLL file to transition into the running state. More...
class	RunningObjectTable
	Manages access to the running object table (ROT), a globally accessible look-up table on each workstation. A workstation's ROT keeps track of those objects that can be identified by a moniker and that are currently running on the workstation. When a client tries to bind a moniker to an object, the moniker checks the ROT to see if the object is already running; this allows the moniker to bind to the current instance instead of loading a new one. More...
class	SafeArray
class	SafeArrayT
struct	SByteBitTraits
class	Semaphore
class	SemaphoreAccessMask
class	SemaphoreEx
class	Sensor
	Represents a sensor. More...
class	SensorCollection
class	SensorDataReport
class	SensorEventSink
class	SensorEventSinkBase
class	SensorManager
	Provides methods for discovering and retrieving available sensors and a method to request sensor manager events. More...
class	SensorManagerEventSink
class	SensorManagerEventSinkBase
class	SequentialStream
class	ServiceProvider
	Provides a generic access mechanism to locate a GUID-identified service. More...
struct	SevenBitDecode
struct	SevenBitEncode
class	ShellItem
class	ShellItemArray
class	Sign
	Represents the sign of a signed arithmetic type. More...
class	SimpleConcurrentQueue
	Simple blocking fixed size queue. More...
class	SimpleFrameSite
class	SlimReaderWriterLock
	Slim reader/writer (SRW) locks enable the threads of a single process to access shared resources; they are optimized for speed and occupy very little memory. Slim reader-writer locks cannot be shared across processes. More...
class	SpecifyPropertyPages
	Indicates that an object supports property pages. OLE property pages enable an object to display its properties in a tabbed dialog box known as a property sheet. An end user can then view and change the object's properties. An object can display its property pages independent of its client, or the client can manage the display of property pages from a number of contained objects in a single property sheet. Property pages also provide a means for notifying a client of changes in an object's properties. More...
class	Spinlock
class	StackOverflowException
class	StartupInfo
class	StgMedium
	Represents a generalized global memory handle used for data transfer operations by the IAdviseSink, IDataObject, and IOleCache interfaces. More...
class	Stopwatch
class	Storage
class	Stream
class	StringBuilder
class	SupportErrorInfo
	Ensures that error information can be propagated up the call chain correctly. Automation objects that use the error handling interfaces must implement ISupportErrorInfo. More...
class	SurrogateService
	Used to initialize, launch, and release a COM+ application. You can also refresh the catalog and shut down the process. More...
class	SynchronizationBarrier
	A synchronization barrier enables multiple threads to wait until all threads have all reached a particular point of execution before any thread continues. Synchronization barriers cannot be shared across processes. More...
class	SysString
class	SystemException
class	Thread
class	ThreadAbortException
	Thrown by Thread::Exit. More...
class	ThreadAccessMask
class	ThreadGroup
class	TimeBase
class	TimeoutException
class	TimerQueue
class	TimerQueueTimer
class	TimeSpan
	Represents a time interval. More...
class	Tuple
class	Tuple< T, Types... >
class	Tuple<>
struct	TupleElement
class	TypeAttributes
class	TypeChangeEvents
	Enables clients to subscribe to type change notifications on objects that implement the ITypeInfo, ITypeInfo2, ICreateTypeInfo, and ICreateTypeInfo2 interfaces. When ITypeChangeEvents is implemented on an object, it acts as an incoming interface that enables the object to receive calls from external clients and engage in bidirectional communication with those clients. More...
class	TypeComp
	The ITypeComp interface provides a fast way to access information that compilers need when binding to and instantiating structures and interfaces. Binding is the process of mapping names to types and type members. More...
class	TypeFactory
class	TypeInfo
	ITypeInfo is an interface used for reading information about objects. For example, an object browser tool can use ITypeInfo to extract information about the characteristics and capabilities of objects from type libraries. More...
class	TypeInfo2
	Used for reading information about objects. Can be cast to an ITypeInfo instead of using the calls QueryInterface and Release to allow quick opens and allocs. This only works for in-process cases. More...
class	TypeInitializationException
class	TypeLib
	Represents a type library, the data that describes a set of objects. A type library can be a stand-alone binary file (.TLB), a resource in a dynamic link library or executable file (.DLL, .OLB, or .EXE). More...
class	TypeLib2
	Represents a type library, the data that describes a set of objects. More...
class	TypeLibAttributes
class	TypeLibEntry
class	TypeLibRegistration
class	TypeLibRegistrationReader
class	TypeLoadException
class	TypeMarshal
class	TypeUnloadedException
struct	UInt16BitTraits
struct	UInt32BitTraits
struct	UInt64BitTraits
class	UnauthorizedAccessException
class	Unknown
	Base class for COM interface wrappers. More...
class	UnsecuredApartment
class	UriFormatException
class	UriTemplateMatchException
class	Variant
struct	VariantTypeTraits
struct	VariantTypeTraits< bool >
struct	VariantTypeTraits< double >
struct	VariantTypeTraits< float >
struct	VariantTypeTraits< int >
struct	VariantTypeTraits< long >
struct	VariantTypeTraits< long long >
struct	VariantTypeTraits< short >
struct	VariantTypeTraits< signed char >
struct	VariantTypeTraits< unsigned char >
struct	VariantTypeTraits< unsigned int >
struct	VariantTypeTraits< unsigned long >
struct	VariantTypeTraits< unsigned long long >
struct	VariantTypeTraits< unsigned short >
struct	VariantTypeTraits< wchar_t >
struct	VariantTypeTraits< WideString >
class	Vector
class	VectorBase
class	VectorConstIterator
class	VectorIterator
class	ViewObject
class	ViewObject2
class	ViewObjectEx
class	WaitableHandle
class	WaitableTimer
class	WaitableTimerAccessMask
class	WbemAddressResolution
class	WbemBackupRestore
class	WbemBackupRestoreEx
class	WbemCallResult
class	WbemClassObject
	The WbemClassObject contains and manipulates both class definitions and class object instances. More...
class	WbemClientConnectionTransport
class	WbemClientTransport
class	WbemConfigureRefresher
class	WbemConnectorLogin
class	WbemConstructClassObject
class	WbemContext
class	WbemDecoupledBasicEventProvider
class	WbemDecoupledRegistrar
class	WbemEventConsumerProvider
class	WbemEventProvider
class	WbemEventProviderQuerySink
class	WbemEventProviderSecurity
class	WbemEventSink
class	WbemHiPerfEnum
class	WbemHiPerfProvider
class	WbemLevel1Login
class	WbemLocator
class	WbemMethod
class	WbemMethodSignature
class	WbemObjectAccess
class	WbemObjectSink
	The IWbemObjectSink interface creates a sink interface that can receive all types of notifications within the WMI programming model. Clients must implement this interface to receive both the results of the asynchronous methods of WbemServices, and specific types of event notifications. Providers use, but do not implement this interface to provide events and objects to WMI. More...
class	WbemObjectSinkEx
class	WbemObjectTextSrc
class	WbemProperty
class	WbemPropertyProvider
class	WbemProviderIdentity
class	WbemProviderInit
class	WbemProviderInitSink
class	WbemQualifierSet
class	WbemRefresher
class	WbemServices
	The WbemServices is used by clients and providers to access WMI services. The interface is implemented by WMI and WMI providers, and is the primary WMI interface. More...
class	WbemShutdown
class	WbemStatusCodeText
class	WbemTransport
class	WbemUnboundObjectSink
class	WbemUnsecuredApartment
struct	WideCharBitTraits
class	WpdSerializer
	Used by the device driver to serialize IPortableDeviceValues interfaces to and from the raw data buffers used to communicate with the application. More...
class	XXH64Hasher

Concepts
concept	CharType
concept	ApiCharType
concept	SimpleSpanLike
	Matches most containers with sequential memory layout.
concept	SimpleCharSpanLike
	Matches most common string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	SimpleAnsiCharSpanLike
	Matches most common char string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	SimpleWideCharSpanLike
	Matches most common wchar_t string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	SimpleByteSpanLike
	Matches most common container classes with sequential memory layout.
concept	SpanLike
concept	CharSpanLike
	Matches most common string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	AnsiCharSpanLike
	Matches most common char string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	WideCharSpanLike
	Matches most common wchar_t string classes with sequential memory layout. Do not assume that they are zero terminated.
concept	SimpleStringLike
	Matches most common zero terminated C++ string classes with sequential memory layout.
concept	SimpleWideStringLike
	Matches most common zero terminated C++ wchar_t string classes with sequential memory layout.
concept	SimpleAnsiStringLike
	Matches most common zero terminated C++ char string classes with sequential memory layout.
concept	StringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for either char or wchar_t.
concept	WideStringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for wchar_t.
concept	AnsiStringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for char.
concept	SimpleComLike
concept	BinaryLike
concept	GuidType
concept	WideStringType

Typedefs
using	ApplicationMessage = Concurrency::Messages::Message<ApplicationMessageType>
template<ApplicationMessageType messageId>
using	SimpleApplicationMessage = Concurrency::Messages::SimpleMessage<ApplicationMessageType, messageId>
template<typename ValueT , ApplicationMessageType messageId>
using	SimpleApplicationValueMessage = Concurrency::Messages::SimpleValueMessage<ValueT, ApplicationMessageType, messageId>
using	ApplicationStopMessage = SimpleApplicationMessage<ApplicationMessageType::Stop>
using	ApplicationThreadAttachedMessage = SimpleApplicationValueMessage<UInt32, ApplicationMessageType::ThreadAttached>
using	ApplicationThreadDetachedMessage = SimpleApplicationValueMessage<UInt32, ApplicationMessageType::ThreadDetached>
using	WideString = BasicString<wchar_t>
using	AnsiString = BasicString<char>
using	WideStringView = BasicStringView<wchar_t>
using	AnsiStringView = BasicStringView<char>
using	Boolean = bool
using	Int8 = signed char
using	SByte = signed char
using	UInt8 = unsigned char
using	Byte = unsigned char
using	Int16 = short
using	UInt16 = unsigned short
using	ushort = unsigned short
using	Int32 = int
using	Int = int
using	UInt32 = unsigned int
using	UInt = unsigned int
using	ULong32 = unsigned long
using	Long32 = long
using	uint = unsigned int
using	DWord32 = unsigned long
using	DWord = unsigned long
using	Int64 = long long
using	Long64 = long long
using	LongLong = long long
using	UInt64 = unsigned long long
using	ULong64 = unsigned long long
using	ULongLong = unsigned long long
using	DWord64 = unsigned long
using	ssize_t = std::make_signed_t<size_t>
using	SSizeT = ssize_t
using	SizeT = size_t
using	Char = char
using	WideChar = wchar_t
using	Char8 = char
using	Char16 = wchar_t
using	Char32 = UInt32
using	Single = float
using	Double = double
template<typename T >
using	Nullable = std::optional<T>
template<size_t N>
using	BitMask_t = typename BitMask<N>::type
using	PropertyPageIds = std::vector<Guid>
template<size_t maxSize>
using	FixedWideString = FixedString<wchar_t, maxSize>
template<size_t maxSize>
using	FixedAnsiString = FixedString<char, maxSize>
template<typename ... Types>
using	TypeList = Meta::List<Types...>
template<typename Type , typename... TypeList>
using	IsAnyOf = std::disjunction<std::is_same<Type, TypeList>...>
template<typename T >
using	MakeUnsigned = typename Internal::MakeUnsignedHelper< sizeof(T) >::Type
template<typename T >
using	ElementTypeOf = std::remove_reference_t<decltype( *std::begin( std::declval<T&>( ) ) )>
template<class It >
using	IteratorValue_t = std::iter_value_t<It>
template<class It >
using	IteratorCategory_t = typename std::iterator_traits<It>::iterator_category
template<std::size_t index, typename... Args>
using	TupleElement_t = typename TupleElement<index, Args...>::type

Enumerations
enum class	ApplicationMessageType {   Unknown ,   Stop ,   ThreadAttached ,   ThreadDetached }
enum class	ThreadModel : DWORD {   Unknown = 0 ,   ApartmentThreaded = COINIT_APARTMENTTHREADED ,   MultiThreaded = COINIT_MULTITHREADED ,   DisableDDE = COINIT_DISABLE_OLE1DDE ,   SpeedOverMemory = COINIT_SPEED_OVER_MEMORY }
enum class	DayOfWeek {   Sunday = 0 ,   Monday = 1 ,   Tuesday = 2 ,   Wednesday = 3 ,   Thursday = 4 ,   Friday = 5 ,   Saturday = 6 }
enum class	DatePart {   Year = 0 ,   DayOfYear = 1 ,   Month = 2 ,   Day = 3 }
enum class	ExceptionType {   Unknown ,   exception ,   Exception ,   SystemException ,   AppDomainUnloadedException ,   ArrayTypeMismatchException ,   AccessViolationException ,   AggregateException ,   ApplicationException ,   ArgumentException ,   ArgumentNullException ,   ArgumentOutOfRangeException ,   ArithmeticException ,   BadImageFormatException ,   CannotUnloadAppDomainException ,   ContextMarshalException ,   DataMisalignedException ,   ExecutionEngineException ,   TypeLoadException ,   DivideByZeroException ,   DllNotFoundException ,   DuplicateWaitObjectException ,   EntryPointNotFoundException ,   MemberAccessException ,   FieldAccessException ,   FormatException ,   IndexOutOfRangeException ,   InsufficientExecutionStackException ,   OutOfMemoryException ,   InsufficientMemoryException ,   InvalidCastException ,   InvalidOperationException ,   InvalidProgramException ,   InvalidTimeZoneException ,   MethodAccessException ,   MissingMemberException ,   MissingFieldException ,   MissingMethodException ,   MulticastNotSupportedException ,   NotFiniteNumberException ,   NotImplementedException ,   NotSupportedException ,   NullReferenceException ,   OperationCanceledException ,   OverflowException ,   PlatformNotSupportedException ,   RankException ,   StackOverflowException ,   TimeoutException ,   TypeInitializationException ,   TypeUnloadedException ,   UnauthorizedAccessException ,   UriFormatException ,   UriTemplateMatchException ,   IOException ,   DirectoryNotFoundException ,   DriveNotFoundException ,   EndOfStreamException ,   FileLoadException ,   FileNotFoundException ,   PathTooLongException ,   PipeException ,   IsolatedStorageException ,   SocketException ,   CustomAttributeFormatException ,   InvalidFilterCriteriaException ,   ReflectionTypeLoadException ,   TargetException ,   TargetInvocationException ,   TargetParameterCountException ,   ExternalException ,   COMException ,   InvalidComObjectException ,   InvalidOleVariantTypeException ,   MarshalDirectiveException ,   SafeArrayTypeMismatchException ,   SafeArrayRankMismatchException ,   SEHException ,   RemotingException ,   RemotingTimeoutException ,   ServerException ,   SUDSGeneratorException ,   SUDSParserException ,   SerializationException ,   DbException ,   OracleException ,   ODBCException ,   MessageQueueException ,   MissingManifestResourceException ,   SecurityException ,   VerificationException ,   CryptographicException ,   CryptographicUnexpectedOperationException ,   PolicyException ,   SynchronizationLockException ,   ThreadAbortException ,   ThreadInterruptedException ,   ThreadStateException ,   ThreadStopException ,   WaitHandleCannotBeOpenedException }
enum class	PageFlags : DWORD {   NoAccess = PAGE_NOACCESS ,   Readonly = PAGE_READONLY ,   ReadWrite = PAGE_READWRITE ,   WriteCopy = PAGE_WRITECOPY ,   Execute = PAGE_EXECUTE ,   ExecuteRead = PAGE_EXECUTE_READ ,   ExecuteReadWrite = PAGE_EXECUTE_READWRITE ,   ExecuteWriteCopy = PAGE_EXECUTE_WRITECOPY ,   Guard = PAGE_GUARD ,   NoCache = PAGE_NOCACHE ,   WriteCombine = PAGE_WRITECOMBINE }
enum class	SectionFlags : DWORD {   None = 0 ,   PartitionOwnerHandle = SEC_PARTITION_OWNER_HANDLE ,   Pages64K = SEC_64K_PAGES ,   File = SEC_FILE ,   Image = SEC_IMAGE ,   ProtectedImage = SEC_PROTECTED_IMAGE ,   Reserve = SEC_RESERVE ,   Commit = SEC_COMMIT ,   NoCache = SEC_NOCACHE ,   WriteCombine = SEC_WRITECOMBINE ,   LargePages = SEC_LARGE_PAGES ,   ImageNoExecute = SEC_IMAGE_NO_EXECUTE }
enum class	MemoryMappedFileRights : DWORD {   CopyOnWrite = FILE_MAP_COPY ,   Write = FILE_MAP_WRITE ,   Read = FILE_MAP_READ ,   Execute = FILE_MAP_EXECUTE ,   Delete = DELETE ,   ReadPermissions = READ_CONTROL ,   ChangePermissions = WRITE_DAC ,   TakeOwnership = WRITE_OWNER ,   ReadWrite = Read | Write ,   ReadExecute = Read | Execute ,   ReadWriteExecute = Read | Write | Execute ,   FullControl = CopyOnWrite | Read | Write | Execute | Delete | ReadPermissions | ChangePermissions | TakeOwnership ,   AccessSystemSecurity = ACCESS_SYSTEM_SECURITY }
enum class	MemoryMappedFileAccess : DWORD {   ReadWrite = 0 ,   Read ,   Write ,   CopyOnWrite ,   ReadExecute ,   ReadWriteExecute }
enum class	MemoryMappedFileOptions : DWORD {   None = 0 ,   DelayAllocatePages = 0x4000000 }
enum class	FileMap : DWORD {   Read = FILE_MAP_READ ,   Write = FILE_MAP_WRITE ,   AllAccess = FILE_MAP_ALL_ACCESS ,   Execute = FILE_MAP_EXECUTE ,   Copy = FILE_MAP_COPY ,   Reserve = FILE_MAP_RESERVE ,   TargetsInvalid = FILE_MAP_TARGETS_INVALID ,   LargePages = FILE_MAP_LARGE_PAGES }
enum class	DropEffect : DWORD {   None = DROPEFFECT_NONE ,   Copy = DROPEFFECT_COPY ,   Move = DROPEFFECT_MOVE ,   Link = DROPEFFECT_LINK ,   Scroll = DROPEFFECT_SCROLL }
enum class	MarshalContext : DWORD {   Local = 0 ,   NoSharedMem = 1 ,   DifferentMachine = 2 ,   InProc = 3 ,   CrossCtx = 4 }
enum class	MarshalFlags : DWORD {   Normal = 0 ,   TableStrong = 1 ,   TableWeak = 2 ,   NoPing = 4 }
enum class	ProcessAccessRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Terminate = PROCESS_TERMINATE ,   CreateThread = PROCESS_CREATE_THREAD ,   WriteSessionId = PROCESS_SET_SESSIONID ,   AccessMemory = PROCESS_VM_OPERATION ,   ReadMemory = PROCESS_VM_READ ,   WriteMemory = PROCESS_VM_WRITE ,   DuplicateHandle = PROCESS_DUP_HANDLE ,   ExecuteProcess = PROCESS_CREATE_PROCESS ,   WriteQuota = PROCESS_SET_QUOTA ,   WriteInformation = PROCESS_SET_INFORMATION ,   ReadInformation = PROCESS_QUERY_INFORMATION ,   SuspenAndResume = PROCESS_SUSPEND_RESUME ,   ReadLimitedInformation = PROCESS_QUERY_LIMITED_INFORMATION ,   WriteLimitedInformation = PROCESS_SET_LIMITED_INFORMATION ,   FullControl = PROCESS_ALL_ACCESS }
enum class	ProcessCreationFlags : DWORD {   None = 0 ,   Debug = DEBUG_PROCESS ,   DebugOnlyThis = DEBUG_ONLY_THIS_PROCESS ,   Suspended = CREATE_SUSPENDED ,   Detached = DETACHED_PROCESS ,   CreateNewConsole = CREATE_NEW_CONSOLE ,   NormalPriority = NORMAL_PRIORITY_CLASS ,   IdlePriority = IDLE_PRIORITY_CLASS ,   HighPriority = HIGH_PRIORITY_CLASS ,   RealTimePriority = REALTIME_PRIORITY_CLASS ,   CreateNewProcessGroup = CREATE_NEW_PROCESS_GROUP ,   CreateUnicodeEnvironment = CREATE_UNICODE_ENVIRONMENT ,   CreateSeparateWowVdm = CREATE_SEPARATE_WOW_VDM ,   CreateSharedWowVdm = CREATE_SHARED_WOW_VDM ,   CreateForceDos = CREATE_FORCEDOS ,   BelowNormalPriority = BELOW_NORMAL_PRIORITY_CLASS ,   AboveNormalPriority = ABOVE_NORMAL_PRIORITY_CLASS ,   InheritParentAffinity = INHERIT_PARENT_AFFINITY ,   InheritCallerPriority = INHERIT_CALLER_PRIORITY ,   CreateProtectedProcess = CREATE_PROTECTED_PROCESS ,   ExtendedStartupInfoPresent = EXTENDED_STARTUPINFO_PRESENT ,   ProcessModeBackgroundBegin = PROCESS_MODE_BACKGROUND_BEGIN ,   ProcessModeBackgroundEnd = PROCESS_MODE_BACKGROUND_END ,   CreateSecureProcess = CREATE_SECURE_PROCESS ,   CreateBreakawayFromJob = CREATE_BREAKAWAY_FROM_JOB ,   CreatePreserveCodeAuthzLevel = CREATE_PRESERVE_CODE_AUTHZ_LEVEL ,   CreateDefaultErrorMode = CREATE_DEFAULT_ERROR_MODE ,   CreateNoWindow = CREATE_NO_WINDOW ,   ProfileUser = PROFILE_USER ,   ProfileKernel = PROFILE_KERNEL ,   ProfileServer = PROFILE_SERVER ,   CreateIgnoreSystemDefault = CREATE_IGNORE_SYSTEM_DEFAULT }
enum class	ProcessPriorityClass {   Normal = NORMAL_PRIORITY_CLASS ,   Idle = IDLE_PRIORITY_CLASS ,   High = HIGH_PRIORITY_CLASS ,   Realtime = REALTIME_PRIORITY_CLASS ,   BelowNormal = BELOW_NORMAL_PRIORITY_CLASS ,   AboveNormal = ABOVE_NORMAL_PRIORITY_CLASS }
enum class	RegistryValueType : DWORD {   None = REG_NONE ,   String = REG_SZ ,   ExpandString = REG_EXPAND_SZ ,   Binary = REG_BINARY ,   Int32 = REG_DWORD ,   LittleEndianInt32 = REG_DWORD_LITTLE_ENDIAN ,   BigEndianInt32 = REG_DWORD_BIG_ENDIAN ,   Link = REG_LINK ,   Strings = REG_MULTI_SZ ,   ResourceList = REG_RESOURCE_LIST ,   FullResourceDescriptor = REG_FULL_RESOURCE_DESCRIPTOR ,   ResourceRequirementsList = REG_RESOURCE_REQUIREMENTS_LIST ,   Int64 = REG_QWORD ,   LittleEndianInt64 = REG_QWORD_LITTLE_ENDIAN }
enum class	RequestPermissionsResult {   Ok ,   AccessDenied ,   Cancelled }
enum class	SynchronizationBarrierFlags : UInt32 {   None = 0 ,   BlockOnly = SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY ,   SpinOnly = SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY ,   NoDelete = SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE }
	Flags that control the behavior of threads that enter a barrier. More...
enum class	EventWaitHandleRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Modify = EVENT_MODIFY_STATE ,   FullControl = EVENT_ALL_ACCESS }
enum class	MutexRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Modify = MUTEX_MODIFY_STATE ,   FullControl = MUTEX_ALL_ACCESS }
enum class	SemaphoreRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Modify = SEMAPHORE_MODIFY_STATE ,   FullControl = SEMAPHORE_ALL_ACCESS }
enum class	WaitableTimerRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Query = TIMER_QUERY_STATE ,   Modify = TIMER_MODIFY_STATE ,   FullControl = TIMER_ALL_ACCESS }
enum class	TimerQueueTimerFlags : DWORD {   Default = WT_EXECUTEDEFAULT ,   ExecuteInTimerThread = WT_EXECUTEINTIMERTHREAD ,   ExecuteInPersistentThread = WT_EXECUTEINPERSISTENTTHREAD ,   ExecuteLongFunction = WT_EXECUTELONGFUNCTION ,   ExecuteOnlyOnce = WT_EXECUTEONLYONCE ,   TransferImpersonation = WT_TRANSFER_IMPERSONATION }
enum class	ThreadAccessRights : DWORD {   HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS ,   Terminate = THREAD_TERMINATE ,   SuspendAndResume = THREAD_SUSPEND_RESUME ,   GetContext = THREAD_GET_CONTEXT ,   SetContext = THREAD_SET_CONTEXT ,   ReadInformation = THREAD_QUERY_INFORMATION ,   WriteInformation = THREAD_SET_INFORMATION ,   WriteThreadToken = THREAD_SET_THREAD_TOKEN ,   Impersonate = THREAD_IMPERSONATE ,   ImpersonateClient = THREAD_DIRECT_IMPERSONATION ,   WriteLimitedInformation = THREAD_SET_LIMITED_INFORMATION ,   ReadLimitedInformation = THREAD_QUERY_LIMITED_INFORMATION ,   Resume = THREAD_RESUME ,   FullControl = THREAD_ALL_ACCESS }
enum class	ThreadPriority {   Idle = THREAD_PRIORITY_IDLE ,   Lowest = THREAD_PRIORITY_LOWEST ,   BelowNormal = THREAD_PRIORITY_BELOW_NORMAL ,   Normal = THREAD_PRIORITY_NORMAL ,   AboveNormal = THREAD_PRIORITY_ABOVE_NORMAL ,   Highest = THREAD_PRIORITY_HIGHEST ,   TimeCritical = THREAD_PRIORITY_TIME_CRITICAL ,   BackgroundBegin = THREAD_MODE_BACKGROUND_BEGIN ,   BackgroundEnd = THREAD_MODE_BACKGROUND_END }
enum class	VariantType : unsigned short {   Empty = 0 ,   Null = 1 ,   Int2 = 2 ,   Short = 2 ,   Int16 = 2 ,   Int4 = 3 ,   Long = 3 ,   Int32 = 3 ,   Real4 = 4 ,   Float = 4 ,   Single = 4 ,   Real8 = 5 ,   Double = 5 ,   Currency = 6 ,   DateTime = 7 ,   BStr = 8 ,   Dispatch = 9 ,   Error = 10 ,   Bool = 11 ,   Variant = 12 ,   Unknown = 13 ,   Decimal = 14 ,   Int1 = 16 ,   SByte = 16 ,   UInt1 = 17 ,   Byte = 17 ,   UInt2 = 18 ,   UShort = 18 ,   UInt16 = 18 ,   UInt4 = 19 ,   UInt32 = 19 ,   ULong = 19 ,   Int8 = 20 ,   Int64 = 20 ,   LongLong = 20 ,   UInt8 = 21 ,   UInt64 = 21 ,   ULongLong = 21 ,   Int = 22 ,   UInt = 23 ,   Void = 24 ,   HResult = 25 ,   Pointer = 26 ,   SafeArray = 27 ,   CArray = 28 ,   UserDefined = 29 ,   LPStr = 30 ,   LPWStr = 31 ,   Record = 36 ,   IntPtr = 37 ,   UIntPtr = 38 ,   FileTime = 64 ,   Blob = 65 ,   Stream = 66 ,   Storage = 67 ,   StreamedObject = 68 ,   StoredObject = 69 ,   BlobObject = 70 ,   CF = 71 ,   CLSID = 72 ,   VersionedStream = 73 ,   BStrBlob = 0xfff ,   Vector = 0x1000 ,   Array = 0x2000 ,   Byref = 0x4000 ,   Reserved = 0x8000 ,   Illegal = 0xffff ,   IllegalMasked = 0xfff ,   TypeMask = 0xfff }
enum class	WinError : unsigned int {   None = 0 ,   Success = 0 ,   NoError = 0 ,   InvalidFunction = ERROR_INVALID_FUNCTION ,   FileNotFound = ERROR_FILE_NOT_FOUND ,   PathNotFound = ERROR_PATH_NOT_FOUND ,   TooManyOpenFiles = ERROR_TOO_MANY_OPEN_FILES ,   AccessDenied = ERROR_ACCESS_DENIED ,   InvalidHandle = ERROR_INVALID_HANDLE ,   ArenaTrashed = ERROR_ARENA_TRASHED ,   NotEnoughMemory = ERROR_NOT_ENOUGH_MEMORY ,   InvalidBlock = ERROR_INVALID_BLOCK ,   BadEnvironment = ERROR_BAD_ENVIRONMENT ,   BadFormat = ERROR_BAD_FORMAT ,   InvalidAccess = ERROR_INVALID_ACCESS ,   InvalidData = ERROR_INVALID_DATA ,   OutOfMemory = ERROR_OUTOFMEMORY ,   InvalidDrive = ERROR_INVALID_DRIVE ,   CurrentDirectory = ERROR_CURRENT_DIRECTORY ,   NotSameDevice = ERROR_NOT_SAME_DEVICE ,   NoMoreFiles = ERROR_NO_MORE_FILES ,   WriteProtect = ERROR_WRITE_PROTECT ,   BadUnit = ERROR_BAD_UNIT ,   NotReady = ERROR_NOT_READY ,   BadCommand = ERROR_BAD_COMMAND ,   CyclicRedundancyCheck = ERROR_CRC ,   BadLength = ERROR_BAD_LENGTH ,   Seek = ERROR_SEEK ,   NotDosDisk = ERROR_NOT_DOS_DISK ,   SectorNotFound = ERROR_SECTOR_NOT_FOUND ,   OutOfPaper = ERROR_OUT_OF_PAPER ,   WriteFault = ERROR_WRITE_FAULT ,   ReadFault = ERROR_READ_FAULT ,   Failure = ERROR_GEN_FAILURE ,   SharingViolation = ERROR_SHARING_VIOLATION ,   LockViolation = ERROR_LOCK_VIOLATION ,   WrongDisk = ERROR_WRONG_DISK ,   SharingBufferExceeded = ERROR_SHARING_BUFFER_EXCEEDED ,   HandleEndOfFile = ERROR_HANDLE_EOF ,   HandleDiskFull = ERROR_HANDLE_DISK_FULL ,   NotSupported = ERROR_NOT_SUPPORTED ,   RemNotList = ERROR_REM_NOT_LIST ,   DuplicateName = ERROR_DUP_NAME ,   BadNetworkPath = ERROR_BAD_NETPATH ,   NetworkBusy = ERROR_NETWORK_BUSY ,   DeviceNotExist = ERROR_DEV_NOT_EXIST ,   TooManyCommands = ERROR_TOO_MANY_CMDS ,   AdapterHardwareError = ERROR_ADAP_HDW_ERR ,   BadNetworkResponse = ERROR_BAD_NET_RESP ,   UnexpectedNetworkError = ERROR_UNEXP_NET_ERR ,   BadRemoteAdapter = ERROR_BAD_REM_ADAP ,   PrinterQueueIsFull = ERROR_PRINTQ_FULL ,   NoSpoolSpace = ERROR_NO_SPOOL_SPACE ,   PrintCancelled = ERROR_PRINT_CANCELLED ,   NetworkNameDeleted = ERROR_NETNAME_DELETED ,   NetworkAccessDenied = ERROR_NETWORK_ACCESS_DENIED ,   BadDeviceType = ERROR_BAD_DEV_TYPE ,   BadNetworkName = ERROR_BAD_NET_NAME ,   TooManyNames = ERROR_TOO_MANY_NAMES ,   TooManySessions = ERROR_TOO_MANY_SESS ,   SharingPaused = ERROR_SHARING_PAUSED ,   RequestNotAccepted = ERROR_REQ_NOT_ACCEP ,   RedirectPaused = ERROR_REDIR_PAUSED ,   FileExists = ERROR_FILE_EXISTS ,   CannotMake = ERROR_CANNOT_MAKE ,   Int24Failure = ERROR_FAIL_I24 ,   OutOfStructures = ERROR_OUT_OF_STRUCTURES ,   AlreadyAssigned = ERROR_ALREADY_ASSIGNED ,   InvalidPassword = ERROR_INVALID_PASSWORD ,   InvalidParameter = ERROR_INVALID_PARAMETER ,   NetworkWriteFault = ERROR_NET_WRITE_FAULT ,   NoProcessSlots = ERROR_NO_PROC_SLOTS ,   TooManySemaphores = ERROR_TOO_MANY_SEMAPHORES ,   ExclusiveSemaphoreAlreadyOwned = ERROR_EXCL_SEM_ALREADY_OWNED ,   SemaphoreIsSet = ERROR_SEM_IS_SET ,   TooManySemaphoreRequests = ERROR_TOO_MANY_SEM_REQUESTS ,   InvalidAtInterruptTime = ERROR_INVALID_AT_INTERRUPT_TIME ,   SemaphoreOwnerDied = ERROR_SEM_OWNER_DIED ,   SemaphoreUserLimit = ERROR_SEM_USER_LIMIT ,   DiskChange = ERROR_DISK_CHANGE ,   DriveLocked = ERROR_DRIVE_LOCKED ,   BrokenPipe = ERROR_BROKEN_PIPE ,   OpenFailed = ERROR_OPEN_FAILED ,   BufferOverflow = ERROR_BUFFER_OVERFLOW ,   DiskFull = ERROR_DISK_FULL ,   NoMoreSearchHandles = ERROR_NO_MORE_SEARCH_HANDLES ,   InvalidTargetHandle = ERROR_INVALID_TARGET_HANDLE ,   InvalidCategory = ERROR_INVALID_CATEGORY ,   InvalidVerifySwitch = ERROR_INVALID_VERIFY_SWITCH ,   BadDriverLevel = ERROR_BAD_DRIVER_LEVEL ,   CallNotImplemented = ERROR_CALL_NOT_IMPLEMENTED ,   SemaphoreTimeout = ERROR_SEM_TIMEOUT ,   InsufficientBuffer = ERROR_INSUFFICIENT_BUFFER ,   InvalidName = ERROR_INVALID_NAME ,   InvalidLevel = ERROR_INVALID_LEVEL ,   NoVolumeLabel = ERROR_NO_VOLUME_LABEL ,   ModuleNotFound = ERROR_MOD_NOT_FOUND ,   ProcedureNotFound = ERROR_PROC_NOT_FOUND ,   WaitNoChildren = ERROR_WAIT_NO_CHILDREN ,   ChildNotComplete = ERROR_CHILD_NOT_COMPLETE ,   DirectAccessHandle = ERROR_DIRECT_ACCESS_HANDLE ,   NegativeSeek = ERROR_NEGATIVE_SEEK ,   SeekOnDevice = ERROR_SEEK_ON_DEVICE ,   IsJoinTarget = ERROR_IS_JOIN_TARGET ,   IsJoined = ERROR_IS_JOINED ,   IsSubsted = ERROR_IS_SUBSTED ,   NotJoined = ERROR_NOT_JOINED ,   NotSubsted = ERROR_NOT_SUBSTED ,   JoinToJoin = ERROR_JOIN_TO_JOIN ,   SubstToSubst = ERROR_SUBST_TO_SUBST ,   JoinToSubst = ERROR_JOIN_TO_SUBST ,   SubstToJoin = ERROR_SUBST_TO_JOIN ,   BusyDrive = ERROR_BUSY_DRIVE ,   SameDrive = ERROR_SAME_DRIVE ,   DirectoryNotRoot = ERROR_DIR_NOT_ROOT ,   DirectoryNotEmpty = ERROR_DIR_NOT_EMPTY ,   IsSubstPath = ERROR_IS_SUBST_PATH ,   IsJoinPath = ERROR_IS_JOIN_PATH ,   PathBusy = ERROR_PATH_BUSY ,   IsSubstTarget = ERROR_IS_SUBST_TARGET ,   SystemTrace = ERROR_SYSTEM_TRACE ,   InvalidEventCount = ERROR_INVALID_EVENT_COUNT ,   TooManyMuxWaiters = ERROR_TOO_MANY_MUXWAITERS ,   InvalidListFormat = ERROR_INVALID_LIST_FORMAT ,   LabelTooLong = ERROR_LABEL_TOO_LONG ,   TooManyThreadControlBlocks = ERROR_TOO_MANY_TCBS ,   SignalRefused = ERROR_SIGNAL_REFUSED ,   Discarded = ERROR_DISCARDED ,   NotLocked = ERROR_NOT_LOCKED ,   BadThreadIdAddress = ERROR_BAD_THREADID_ADDR ,   BadArguments = ERROR_BAD_ARGUMENTS ,   BadPathname = ERROR_BAD_PATHNAME ,   SignalPending = ERROR_SIGNAL_PENDING ,   MaxThreadsReached = ERROR_MAX_THRDS_REACHED ,   LockFailed = ERROR_LOCK_FAILED ,   Busy = ERROR_BUSY ,   DeviceSupportInProgress = ERROR_DEVICE_SUPPORT_IN_PROGRESS ,   CancelViolation = ERROR_CANCEL_VIOLATION ,   AtomicLocksNotSupported = ERROR_ATOMIC_LOCKS_NOT_SUPPORTED ,   InvalidSegmentNumber = ERROR_INVALID_SEGMENT_NUMBER ,   InvalidOrdinal = ERROR_INVALID_ORDINAL ,   AlreadyExists = ERROR_ALREADY_EXISTS ,   InvalidFlagNumber = ERROR_INVALID_FLAG_NUMBER ,   SemaphoreNotFound = ERROR_SEM_NOT_FOUND ,   InvalidStartingCodeSegment = ERROR_INVALID_STARTING_CODESEG ,   InvalidStackSegment = ERROR_INVALID_STACKSEG ,   InvalidModuleType = ERROR_INVALID_MODULETYPE ,   InvalidExeSignature = ERROR_INVALID_EXE_SIGNATURE ,   ExeMarkedInvalid = ERROR_EXE_MARKED_INVALID ,   BadExeFormat = ERROR_BAD_EXE_FORMAT ,   IteratedDataExceeds64k = ERROR_ITERATED_DATA_EXCEEDS_64k ,   InvalidMinAllocSize = ERROR_INVALID_MINALLOCSIZE ,   DynlinkFromInvalidRing = ERROR_DYNLINK_FROM_INVALID_RING ,   IoplNotEnabled = ERROR_IOPL_NOT_ENABLED ,   InvalidSegDpl = ERROR_INVALID_SEGDPL ,   AutoDataSegExceeds64k = ERROR_AUTODATASEG_EXCEEDS_64k ,   Ring2SegMustBeMovable = ERROR_RING2SEG_MUST_BE_MOVABLE ,   RelocChainXeedsSegLim = ERROR_RELOC_CHAIN_XEEDS_SEGLIM ,   InfLoopInRelocChain = ERROR_INFLOOP_IN_RELOC_CHAIN ,   EnvVarNotFound = ERROR_ENVVAR_NOT_FOUND ,   NoSignalSent = ERROR_NO_SIGNAL_SENT ,   FilenameExcedRange = ERROR_FILENAME_EXCED_RANGE ,   Ring2StackInUse = ERROR_RING2_STACK_IN_USE ,   MetaExpansionTooLong = ERROR_META_EXPANSION_TOO_LONG ,   InvalidSignalNumber = ERROR_INVALID_SIGNAL_NUMBER ,   Thread1Inactive = ERROR_THREAD_1_INACTIVE ,   Locked = ERROR_LOCKED ,   TooManyModules = ERROR_TOO_MANY_MODULES ,   NestingNotAllowed = ERROR_NESTING_NOT_ALLOWED ,   ExeMachineTypeMismatch = ERROR_EXE_MACHINE_TYPE_MISMATCH ,   IoIncomplete = ERROR_IO_INCOMPLETE ,   IoPending = ERROR_IO_PENDING ,   OperationAborted = ERROR_OPERATION_ABORTED ,   StatusCancelled = std::bit_cast<unsigned int>(STATUS_CANCELLED) ,   StatusLocalDisconnect = std::bit_cast<unsigned int>(STATUS_LOCAL_DISCONNECT) ,   StatusRemoteDisconnect = std::bit_cast<unsigned int>(STATUS_REMOTE_DISCONNECT) ,   WsaInterrupted = WSAEINTR ,   WsaBadFileHandle = WSAEBADF ,   WsaAccess = WSAEACCES ,   WsaInvalidPointer = WSAEFAULT ,   WsaInvalidArgument = WSAEINVAL ,   WsaToManyOpenSockets = WSAEMFILE ,   WsaWouldBlock = WSAEWOULDBLOCK ,   WsaInProgress = WSAEINPROGRESS ,   WsaAlready = WSAEALREADY ,   WsaNotSocket = WSAENOTSOCK ,   WsaDestinationAddressRequired = WSAEDESTADDRREQ ,   WsaMessageSize = WSAEMSGSIZE ,   WsaProtocolType = WSAEPROTOTYPE ,   WsaInvalidProtocolOptionId = WSAENOPROTOOPT ,   WsaProtocolNotSupported = WSAEPROTONOSUPPORT ,   WsaSocketTypeNotSupportedByAddressFamily = WSAESOCKTNOSUPPORT ,   WsaOperationNotSupported = WSAEOPNOTSUPP ,   WsaProtocolFamilyNotSupported = WSAEPFNOSUPPORT ,   WsaAddressIncompatibleWithProtocol = WSAEAFNOSUPPORT ,   WsaAddressInUse = WSAEADDRINUSE ,   WsaAddressNotAvailable = WSAEADDRNOTAVAIL ,   WsaNetworkDown = WSAENETDOWN ,   WsaNetworkUnreachable = WSAENETUNREACH ,   WsaNetworkReset = WSAENETRESET ,   WsaConnectionAborted = WSAECONNABORTED ,   WsaConnectionReset = WSAECONNRESET ,   WsaNoBuffers = WSAENOBUFS ,   WsaIsConnected = WSAEISCONN ,   WsaNotConnected = WSAENOTCONN ,   WsaShutdown = WSAESHUTDOWN ,   WsaTooManyReferences = WSAETOOMANYREFS ,   WsaTimedout = WSAETIMEDOUT ,   WsaConnectionRefused = WSAECONNREFUSED ,   WsaLoop = WSAELOOP ,   WsaNameTooLong = WSAENAMETOOLONG ,   WsaHostIsDown = WSAEHOSTDOWN ,   WsaHostUnreachable = WSAEHOSTUNREACH ,   WsaNotEmpty = WSAENOTEMPTY ,   WsaProcessLimit = WSAEPROCLIM ,   WsaUsers = WSAEUSERS ,   WsaDiskQuota = WSAEDQUOT ,   WsaStale = WSAESTALE ,   WsaRemote = WSAEREMOTE ,   WsaSystemNotReady = WSASYSNOTREADY ,   WsaVersionNotSupported = WSAVERNOTSUPPORTED ,   WsaNotInitialised = WSANOTINITIALISED ,   WsaDisconnected = WSAEDISCON ,   WsaNoMore = WSAENOMORE ,   WsaNoMore2 = WSA_E_NO_MORE ,   WsaCancelled = WSAECANCELLED ,   WsaCancelled2 = WSA_E_CANCELLED ,   WsaInvalidProcedureCallTable = WSAEINVALIDPROCTABLE ,   WsaInvalidServiceProvider = WSAEINVALIDPROVIDER ,   WsaProviderInitializationFailed = WSAEPROVIDERFAILEDINIT ,   WsaSystemCallFailure = WSASYSCALLFAILURE ,   WsaServiceNotFound = WSASERVICE_NOT_FOUND ,   WsaTypeNotFound = WSATYPE_NOT_FOUND ,   WsaRefused = WSAEREFUSED ,   WsaHostNotFound = WSAHOST_NOT_FOUND ,   WsaTryAgain = WSATRY_AGAIN ,   WsaNoRecovery = WSANO_RECOVERY ,   WsaNoData = WSANO_DATA }

Functions
constexpr size_t	SizeOf7BitEncodedValue (UInt64 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 64-bit unsigned integer.
constexpr size_t	SizeOf7BitEncodedValue (Int64 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 64-bit signed integer.
constexpr size_t	SizeOf7BitEncodedValue (UInt32 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 32-bit unsigned integer.
constexpr size_t	SizeOf7BitEncodedValue (Int32 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 32-bit signed integer.
constexpr size_t	SizeOf7BitEncodedValue (UInt16 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 16-bit unsigned integer.
constexpr size_t	SizeOf7BitEncodedValue (Int16 value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 16-bit signed integer.
constexpr size_t	SizeOf7BitEncodedValue (wchar_t value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 16-bit wchar_t.
constexpr size_t	SizeOf7BitEncodedValue (Byte value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 8-bit unsigned integer.
constexpr size_t	SizeOf7BitEncodedValue (SByte value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 8-bit signed integer.
constexpr size_t	SizeOf7BitEncodedValue (char value) noexcept
	Calculates the size, in bytes, required to store a 7-bit encoded 8-bit char.
constexpr size_t	Write7BitEncodedValue (UInt64 value, Byte *dest) noexcept
	Encodes a 64-bit unsigned integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (Int64 value, Byte *dest) noexcept
	Encodes a 64-bit signed integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (UInt32 value, Byte *dest) noexcept
	Encodes a 32-bit unsigned integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (Int32 value, Byte *dest) noexcept
	Encodes a 32-bit signed integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (UInt16 value, Byte *dest) noexcept
	Encodes a 16-bit unsigned integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (Int16 value, Byte *dest) noexcept
	Encodes a 16-bit signed integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (wchar_t value, Byte *dest) noexcept
	Encodes a 16-bit wchar_t as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (Byte value, Byte *dest) noexcept
	Encodes a 8-bit unsigned integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (SByte value, Byte *dest) noexcept
	Encodes a 8-bit signed integer as a 7-bit encoded value.
constexpr size_t	Write7BitEncodedValue (char value, Byte *dest) noexcept
	Encodes a 8-bit char as a 7-bit encoded value.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, UInt64 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 64-bit unsigned integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, Int64 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 64-bit signed integer referenced by resultValue.
template<typename Reader > requires requires( Reader r, Byte& b) { { r.Read( b ) }; }
constexpr UInt64	Read7BitEncodedUInt64 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr Int64	Read7BitEncodedInt64 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, UInt32 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 32-bit unsigned integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, Int32 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 32-bit signed integer referenced by resultValue.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr UInt32	Read7BitEncodedUInt32 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr Int32	Read7BitEncodedInt32 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, UInt16 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit unsigned integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, Int16 &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit signed integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, wchar_t &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit wchar_t referenced by resultValue.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr UInt16	Read7BitEncodedUInt16 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr Int16	Read7BitEncodedInt16 (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr wchar_t	Read7BitEncodedWChar (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, Byte &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit unsigned integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, SByte &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit signed integer referenced by resultValue.
constexpr size_t	Read7BitEncodedValue (const Byte *buffer, size_t offset, char &resultValue) noexcept
	Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit char referenced by resultValue.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr Byte	Read7BitEncodedByte (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr SByte	Read7BitEncodedSByte (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename Reader > requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }
constexpr char	Read7BitEncodedChar (Reader &reader) noexcept
	Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.
template<typename T , size_t N1, size_t N2>
constexpr std::array< T, N1+N2 >	operator+ (const std::array< T, N1 > &lhs, const std::array< T, N2 > &rhs) noexcept
	Concatenation of arrays.
template<typename ... Args>
	ByteArray (Args...) -> ByteArray< Internal::_ByteSizeOf_v< Args... > >
template<size_t N>
constexpr ByteArray< N >	Write7BitEncodedValue (UInt64 value) noexcept
template<size_t N>
constexpr UInt64	Read7BitEncodedValue (const ByteArray< N > &byteArray) noexcept
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr bool	BitsToBool (const BitsT bits, const UInt32 startIndex)
	Extracts the value of a bit at a bit index from an integer value.
template<typename ResultT , typename BitsT > requires ( std::is_integral_v<BitsT> && std::is_enum_v<ResultT> )
constexpr ResultT	BitsToEnum (const BitsT bits, const UInt32 startIndex, const UInt32 bitCount)
template<typename ResultT , typename BitsT > requires ( std::is_integral_v<BitsT>&& std::is_integral_v<ResultT>&& std::is_unsigned_v<ResultT> )
constexpr ResultT	BitsToUnsigned (const BitsT bits, const UInt32 startIndex, const UInt32 bitCount)
template<typename ResultT , typename BitsT > requires ( std::is_integral_v<BitsT>&& std::is_integral_v<ResultT>&& std::is_signed_v<ResultT> )
constexpr ResultT	BitsToSigned (const BitsT bits, const UInt32 startIndex, const UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr Byte	BitsToByte (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr SByte	BitsToSByte (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr UInt16	BitsToUInt16 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr Int16	BitsToInt16 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr UInt32	BitsToUInt32 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr Int32	BitsToInt32 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr UInt64	BitsToUInt64 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename BitsT > requires std::is_integral_v<BitsT>
constexpr Int64	BitsToInt64 (const BitsT bits, UInt32 startIndex, UInt32 bitCount)
template<typename T > requires (std::is_integral_v<T> && std::is_unsigned_v<T>)
constexpr T	GrayEncode (T value)
template<typename T > requires ( std::is_integral_v<T>&& std::is_signed_v<T> )
constexpr T	GrayEncode (T value)
template<typename T > requires ( std::is_integral_v<T>&& std::is_unsigned_v<T> )
constexpr T	GrayDecode (T value)
template<typename T > requires ( std::is_integral_v<T>&& std::is_signed_v<T> )
constexpr T	GrayDecode (T value)
template<size_t N>
constexpr Bits< N >	operator| (const Bits< N > &lhs, const Bits< N > &rhs) noexcept
template<size_t N>
constexpr Bits< N >	operator& (const Bits< N > &lhs, const Bits< N > &rhs) noexcept
template<size_t N>
constexpr Bits< N >	operator^ (const Bits< N > &lhs, const Bits< N > &rhs) noexcept
template<typename T , size_t N> requires std::is_integral_v<T>
constexpr Bits< N >	operator<< (const Bits< N > &lhs, const T &rhs) noexcept
template<typename T , size_t N> requires std::is_integral_v<T>
constexpr Bits< N >	operator>> (const Bits< N > &lhs, const T &rhs) noexcept
template<typename VectorT , typename VectorU >
Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type	operator& (const BitVector< VectorT > &lhs, const BitVector< VectorU > &rhs)
template<typename VectorT , typename VectorU >
Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type	operator| (const BitVector< VectorT > &lhs, const BitVector< VectorU > &rhs)
template<typename VectorT , typename VectorU >
Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type	operator^ (const BitVector< VectorT > &lhs, const BitVector< VectorU > &rhs)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (ThreadModel, DWORD)
template<typename T , typename Traits >
void	swap (typename ConcurrentQueue< T, Traits >::ImplicitProducerKVP &a, typename ConcurrentQueue< T, Traits >::ImplicitProducerKVP &b) noexcept
template<typename T , typename Traits >
void	swap (ConcurrentQueue< T, Traits > &a, ConcurrentQueue< T, Traits > &b) noexcept
void	swap (ProducerToken &a, ProducerToken &b) noexcept
void	swap (ConsumerToken &a, ConsumerToken &b) noexcept
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, ArgumentType>
constexpr ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs no conversion since ResultType must be the same as ArgumentType.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, double>&& std::is_same_v<ArgumentType, float> )
constexpr ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from float to double.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, float>&& std::is_same_v<ArgumentType, double> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from double to float. Throws an ArgumentOutOfRangeException if the argument cannot safely be converted to a float.
template<typename ResultType , typename ArgumentType > requires (requires( ArgumentType a ) { { ToWideString( a ) } -> std::same_as<WideString>; } && IsWideString<ResultType> && std::is_same_v<Variant, ArgumentType> == false && std::is_same_v<Currency, ArgumentType> == false )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from any type for which there exists an overload of ToWideString, except for Variant and Currency, to WideString.
template<typename ResultType , typename ArgumentType > requires ( requires( ArgumentType a ) { { ToAnsiString( a ) } -> std::same_as<AnsiString>; } && IsAnsiString<ResultType> && std::is_same_v<Variant, ArgumentType> == false && std::is_same_v<Currency, ArgumentType> == false )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from any type for which there exists an overload of ToAnsiString, except for Variant and Currency, to AnsiString.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, bool> && std::is_arithmetic_v<ArgumentType> && IsNotBoolean<ArgumentType> )
constexpr ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from an integer or floating point type, but not bool, to a bool.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ArgumentType, bool> && std::is_arithmetic_v<ResultType> && IsNotBoolean<ResultType> )
constexpr ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a bool to an integer or floating point type, but not a bool type.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, bool> && ( std::is_same_v<DateTime, ArgumentType> || std::is_same_v<TimeSpan, ArgumentType> ) )
constexpr ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a DateTime or TimeSpan to a bool.
template<typename ResultType , SimpleStringLike ArgumentType> requires requires( const ArgumentType& a ) { { Parse<ResultType>( a ) }->std::same_as<ResultType>; }
ResultType	ConvertTo (const ArgumentType &arg)
	A ConvertTo template that performs conversion from a type that satisfies the SimpleStringLike concept to a type for which there exist a Parse<> specialization that accepts the argument type.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, bool> && std::is_same_v<Guid, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a Guid to a bool.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<ResultType, bool> && std::is_same_v<Currency, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a Currency to a bool.
template<typename ResultType , typename ArgumentType > requires ( std::is_same_v<Variant, ArgumentType> && std::is_same_v <Variant,ResultType> == false ) && requires ( Variant v ) { { v.As<ResultType>( ) }->std::same_as<ResultType>; }
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a Variant to a type for Which there exist a specialization of Variant::As<ResultType>.
template<typename ResultType , typename ArgumentType > requires ( ((IsSignedInteger<ResultType> && IsSignedInteger<ArgumentType>) || ( IsUnsignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> ) ) && size_is_less< ResultType, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a narrowing conversion from an integer type to another.
template<typename ResultType , typename ArgumentType > requires ( ((IsSignedInteger<ResultType> && IsSignedInteger<ArgumentType>) || ( IsUnsignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> ) ) && size_is_greater_or_equal< ResultType, ArgumentType> && std::is_same_v<ResultType, ArgumentType> == false )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a widening conversion from an integer type to another integer type with the same signedness.
template<typename ResultType , typename ArgumentType > requires ( IsSignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> && size_is_less_or_equal< ResultType, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a narrowing conversion from an unsigned integer type to a signed integer type.
template<typename ResultType , typename ArgumentType > requires ( IsSignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> && size_is_greater< ResultType, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a widening conversion from an unsigned integer type to a signed integer type.
template<typename ResultType , typename ArgumentType > requires ( IsUnsignedInteger<ResultType> && IsSignedInteger<ArgumentType> && size_is_less< ResultType, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a narrowing conversion from a signed integer type to an unsigned integer type.
template<typename ResultType , typename ArgumentType > requires ( IsUnsignedInteger<ResultType> && IsSignedInteger<ArgumentType> && size_is_greater_or_equal< ResultType, ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs a widening conversion from a signed integer type to an unsigned integer type.
template<typename ResultType , typename ArgumentType > requires IsInteger<ResultType> && IsFloatingPoint<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a floating point type to an integer type.
template<typename ResultType , typename ArgumentType > requires (IsInteger<ResultType> || IsFloatingPoint<ResultType> || IsAnsiString<ResultType> || IsWideString<ResultType> ) && std::is_same_v<ArgumentType,Currency>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a Currency value to an integer, floating point, AnsiString or WideString type.
template<typename ResultType , typename ArgumentType > requires IsInteger<ResultType> && IsAnyOf_v<ArgumentType,DateTime, TimeSpan>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a DateTime or TimeSpan value to an integer type.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, TimeSpan> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*>)
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a c style zero terminated string value to a TimeSpan.
template<typename ResultType , SimpleStringLike ArgumentType> requires std::is_same_v<ResultType, TimeSpan>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a type that matches the SimpleStringLike concept to a TimeSpan.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, TimeSpan> && IsFloatingPoint<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a TimeSpan to a floating point type.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, TimeSpan> && std::is_same_v<ArgumentType,Currency>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a Currency value to a TimeSpan value.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, DateTime>&& IsInteger<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from an integer type to a DateTime value.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, TimeSpan>&& IsInteger<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from an integer type to a TimeSpan value.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, DateTime> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*>)
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a c style zero terminated string value to a DateTime.
template<typename ResultType , SimpleStringLike ArgumentType> requires std::is_same_v<ResultType, DateTime>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a type that matches the SimpleStringLike concept to a DateTime.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, DateTime> && IsFloatingPoint<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a floating point type to a DateTime value.
template<typename ResultType , typename ArgumentType > requires IsFloatingPoint<ResultType> && std::is_same_v<ArgumentType, DateTime>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a DateTime value to a floating point type.
template<typename ResultType , typename ArgumentType > requires IsFloatingPoint<ResultType> && std::is_same_v<ArgumentType, TimeSpan>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a TimeSpan value to a floating point type.
template<typename ResultType , typename ArgumentType > requires (std::is_same_v<ResultType, TimeSpan>&& std::is_same_v<ArgumentType, DateTime>) || ( std::is_same_v<ResultType, DateTime> && std::is_same_v<ArgumentType, TimeSpan> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a TimeSpan value to DataTime value, or a conversion from a DataTime value to TimeSpan value.
template<typename ResultType , typename ArgumentType > requires std::is_same_v<ResultType, Guid> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*> || SimpleStringLike<ArgumentType> )
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from a c style zero terminated string value, or a type that matches the SimpleStringLike concept, to a Guid.
template<typename ResultType , typename ArgumentType > requires IsFloatingPoint<ResultType> && IsInteger<ArgumentType>
ResultType	ConvertTo (ArgumentType arg)
	A ConvertTo template that performs conversion from an integer to a floating point value.
HCC_EXPORT uint32_t	crc32 (const void *buffer, size_t bufferSize, uint32_t crc=0)
HCC_EXPORT uint32_t	crc32c (const uint8_t *input, size_t length, uint32_t crc=0)
HCC_EXPORT uint32_t	crc32c_sw (const uint8_t *input, size_t length, uint32_t crc=0)
HCC_EXPORT uint32_t	crc32c_hw (const uint8_t *input, size_t length, uint32_t crc=0)
HCC_EXPORT int	crc32c_hw_available ()
constexpr UInt32	crc24q (const uint8_t *input, size_t length, UInt32 crc=0)
static uint32_t	shift_crc (uint32_t shift_table[][256], uint32_t crc)
void	crc32c_init ()
template<typename T > requires IsCurrency<T>
constexpr T	ByteSwap (const T value) noexcept
HCC_EXPORT std::ostream &	operator<< (std::ostream &stream, const TimeSpan &timeSpan)
std::ostream &	operator<< (std::ostream &stream, const DateTime &dateTime)
template<typename T > requires IsTimeSpan<T>
constexpr T	ByteSwap (const T value) noexcept
template<typename T > requires IsDateTime<T>
constexpr T	ByteSwap (const T value) noexcept
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT> && std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsAllOf (EnumT flags, Args &&... args)
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsNoneOf (EnumT flags, Args ... args)
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsAnyOf (EnumT flags, Args ... args)
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT> && std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	IsSet (EnumT flags, Args &&... args)
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	IsNotSet (EnumT flags, Args ... args)
constexpr unsigned long long	operator""_gb (unsigned long long value)
constexpr unsigned long long	operator""_mb (unsigned long long value)
constexpr unsigned long long	operator""_kb (unsigned long long value)
HCC_EXPORT void	CheckHRESULT (HRESULT hresult)
HCC_EXPORT void	ThrowHRESULT (HRESULT hresult)
HCC_EXPORT void	CheckHRESULT (HRESULT hresult, IUnknown *itf)
HCC_EXPORT void	CheckHRESULT (HRESULT hresult, const wchar_t *function, const wchar_t *filename, int lineNumber)
HCC_EXPORT void	CheckHRESULT (HRESULT hresult, IUnknown *itf, const wchar_t *function, const wchar_t *filename, int lineNumber)
HCC_EXPORT WideString	FormatError (DWORD errorId)
HCC_EXPORT AnsiString	FormatErrorA (DWORD errorId)
HCC_EXPORT void	ThrowLastOSError ()
HCC_EXPORT void	ThrowOSError (DWORD errorId)
HCC_EXPORT void	ThrowNoInterface ()
HCC_EXPORT void	ThrowPointerIsNULL ()
HCC_EXPORT void	ThrowInvalidHandle ()
HCC_EXPORT void	ThrowNullReferenceException ()
HCC_EXPORT void	ThrowNullReferenceException (const char *message)
HCC_EXPORT void	ThrowNullReferenceException (const wchar_t *message)
HCC_EXPORT HRESULT	HRESULTFromException (const std::exception &exception)
template<typename T >
void	CheckPointerNotNull (T *ptr)
HCC_EXPORT void	ReportException (const Exception &exception, const wchar_t *function, const wchar_t *filename, int lineNumber)
HCC_EXPORT void	ReportException (const std::exception &exception, const wchar_t *function, const wchar_t *filename, int lineNumber)
HCC_EXPORT void	ReportUnknownException (const wchar_t *function, const wchar_t *filename, int lineNumber)
HCC_EXPORT WideString	ToWideString (Doxygen::MemberKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::MemberKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::MemberKind value)
AnsiString	ToAnsiString (Doxygen::MemberKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::MemberKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::MemberKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::MemberKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxGraphRelation value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxGraphRelation value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxGraphRelation value)
AnsiString	ToAnsiString (Doxygen::DoxGraphRelation value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxGraphRelation &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxGraphRelation, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxGraphRelation, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxRefKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxRefKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxRefKind value)
AnsiString	ToAnsiString (Doxygen::DoxRefKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxRefKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxRefKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxRefKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxMemberKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxMemberKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxMemberKind value)
AnsiString	ToAnsiString (Doxygen::DoxMemberKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxMemberKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxMemberKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxMemberKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxProtectionKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxProtectionKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxProtectionKind value)
AnsiString	ToAnsiString (Doxygen::DoxProtectionKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxProtectionKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxProtectionKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxProtectionKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxRefQualifierKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxRefQualifierKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxRefQualifierKind value)
AnsiString	ToAnsiString (Doxygen::DoxRefQualifierKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxRefQualifierKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxRefQualifierKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxRefQualifierKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxLanguage value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxLanguage value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxLanguage value)
AnsiString	ToAnsiString (Doxygen::DoxLanguage value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxLanguage &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxLanguage, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxLanguage, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxVirtualKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxVirtualKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxVirtualKind value)
AnsiString	ToAnsiString (Doxygen::DoxVirtualKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxVirtualKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxVirtualKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxVirtualKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCompoundKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCompoundKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxCompoundKind value)
AnsiString	ToAnsiString (Doxygen::DoxCompoundKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxCompoundKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxCompoundKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxCompoundKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxSectionKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxSectionKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxSectionKind value)
AnsiString	ToAnsiString (Doxygen::DoxSectionKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxSectionKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxSectionKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxSectionKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxHighlightClass value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxHighlightClass value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxHighlightClass value)
AnsiString	ToAnsiString (Doxygen::DoxHighlightClass value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxHighlightClass &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxHighlightClass, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxHighlightClass, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxSimpleSectKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxSimpleSectKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxSimpleSectKind value)
AnsiString	ToAnsiString (Doxygen::DoxSimpleSectKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxSimpleSectKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxSimpleSectKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxSimpleSectKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCheck value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCheck value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxCheck value)
AnsiString	ToAnsiString (Doxygen::DoxCheck value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxCheck &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxCheck, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxCheck, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxImageKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxImageKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxImageKind value)
AnsiString	ToAnsiString (Doxygen::DoxImageKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxImageKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxImageKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxImageKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxPlantumlEngine value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxPlantumlEngine value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxPlantumlEngine value)
AnsiString	ToAnsiString (Doxygen::DoxPlantumlEngine value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxPlantumlEngine &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxPlantumlEngine, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxPlantumlEngine, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxParamListKind value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxParamListKind value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxParamListKind value)
AnsiString	ToAnsiString (Doxygen::DoxParamListKind value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxParamListKind &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxParamListKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxParamListKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxParamDir value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxParamDir value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxParamDir value)
AnsiString	ToAnsiString (Doxygen::DoxParamDir value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxParamDir &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxParamDir, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxParamDir, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxAccessor value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxAccessor value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxAccessor value)
AnsiString	ToAnsiString (Doxygen::DoxAccessor value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxAccessor &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxAccessor, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxAccessor, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxAlign value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxAlign value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxAlign value)
AnsiString	ToAnsiString (Doxygen::DoxAlign value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxAlign &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxAlign, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxAlign, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxVerticalAlign value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxVerticalAlign value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxVerticalAlign value)
AnsiString	ToAnsiString (Doxygen::DoxVerticalAlign value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxVerticalAlign &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxVerticalAlign, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxVerticalAlign, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxOlType value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxOlType value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxOlType value)
AnsiString	ToAnsiString (Doxygen::DoxOlType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxOlType &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxOlType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxOlType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCmdGroupType value)
HCC_EXPORT WideString	ToWideString (Doxygen::DoxCmdGroupType value, const WideString &defaultResult)
AnsiString	ToAnsiString (Doxygen::DoxCmdGroupType value)
AnsiString	ToAnsiString (Doxygen::DoxCmdGroupType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Doxygen::DoxCmdGroupType &value)
template<typename T , typename StringT > requires std::is_same_v<Doxygen::DoxCmdGroupType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const StringT &str)
template<typename T , typename CharT > requires std::is_same_v<Doxygen::DoxCmdGroupType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
WideString	ToWideString (MemberKind value)
WideString	ToWideString (MemberKind value, const WideString &defaultResult)
WideString	ToWideString (DoxGraphRelation value)
WideString	ToWideString (DoxGraphRelation value, const WideString &defaultResult)
WideString	ToWideString (DoxRefKind value)
WideString	ToWideString (DoxRefKind value, const WideString &defaultResult)
WideString	ToWideString (DoxMemberKind value)
WideString	ToWideString (DoxMemberKind value, const WideString &defaultResult)
WideString	ToWideString (DoxProtectionKind value)
WideString	ToWideString (DoxProtectionKind value, const WideString &defaultResult)
WideString	ToWideString (DoxRefQualifierKind value)
WideString	ToWideString (DoxRefQualifierKind value, const WideString &defaultResult)
WideString	ToWideString (DoxLanguage value)
WideString	ToWideString (DoxLanguage value, const WideString &defaultResult)
WideString	ToWideString (DoxVirtualKind value)
WideString	ToWideString (DoxVirtualKind value, const WideString &defaultResult)
WideString	ToWideString (DoxCompoundKind value)
WideString	ToWideString (DoxCompoundKind value, const WideString &defaultResult)
WideString	ToWideString (DoxSectionKind value)
WideString	ToWideString (DoxSectionKind value, const WideString &defaultResult)
WideString	ToWideString (DoxHighlightClass value)
WideString	ToWideString (DoxHighlightClass value, const WideString &defaultResult)
WideString	ToWideString (DoxSimpleSectKind value)
WideString	ToWideString (DoxSimpleSectKind value, const WideString &defaultResult)
WideString	ToWideString (DoxCheck value)
WideString	ToWideString (DoxCheck value, const WideString &defaultResult)
WideString	ToWideString (DoxImageKind value)
WideString	ToWideString (DoxImageKind value, const WideString &defaultResult)
WideString	ToWideString (DoxPlantumlEngine value)
WideString	ToWideString (DoxPlantumlEngine value, const WideString &defaultResult)
WideString	ToWideString (DoxParamListKind value)
WideString	ToWideString (DoxParamListKind value, const WideString &defaultResult)
WideString	ToWideString (DoxParamDir value)
WideString	ToWideString (DoxParamDir value, const WideString &defaultResult)
WideString	ToWideString (DoxAccessor value)
WideString	ToWideString (DoxAccessor value, const WideString &defaultResult)
WideString	ToWideString (DoxAlign value)
WideString	ToWideString (DoxAlign value, const WideString &defaultResult)
WideString	ToWideString (DoxVerticalAlign value)
WideString	ToWideString (DoxVerticalAlign value, const WideString &defaultResult)
WideString	ToWideString (DoxOlType value)
WideString	ToWideString (DoxOlType value, const WideString &defaultResult)
WideString	ToWideString (DoxCmdGroupType value)
WideString	ToWideString (DoxCmdGroupType value, const WideString &defaultResult)
WideString	ToWideString (ColumnType value)
WideString	ToWideString (ColumnType value, const WideString &defaultResult)
WideString	ToWideString (ColumnFlags value)
WideString	ToWideString (ColumnFlags value, const WideString &defaultResult)
WideString	ToWideString (IndexFlags value)
WideString	ToWideString (IndexFlags value, const WideString &defaultResult)
WideString	ToWideString (RetrieveFlags value)
WideString	ToWideString (RetrieveFlags value, const WideString &defaultResult)
WideString	ToWideString (SetFlags value)
WideString	ToWideString (SetFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::ColumnInfoLevel value)
WideString	ToWideString (Ese::ColumnInfoLevel value, const WideString &defaultResult)
WideString	ToWideString (Ese::PrepareUpdateOptions value)
WideString	ToWideString (Ese::PrepareUpdateOptions value, const WideString &defaultResult)
WideString	ToWideString (Ese::KeyFlags value)
WideString	ToWideString (Ese::KeyFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::SeekFlags value)
WideString	ToWideString (Ese::SeekFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::IndexRangeFlags value)
WideString	ToWideString (Ese::IndexRangeFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::SetCurrentIndexFlags value)
WideString	ToWideString (Ese::SetCurrentIndexFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::TableOptions value)
WideString	ToWideString (Ese::TableOptions value, const WideString &defaultResult)
WideString	ToWideString (Ese::ObjectFlags value)
WideString	ToWideString (Ese::ObjectFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::SequentialFlags value)
WideString	ToWideString (Ese::SequentialFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::ExceptionAction value)
WideString	ToWideString (Ese::ExceptionAction value, const WideString &defaultResult)
WideString	ToWideString (Ese::OpenTableFlags value)
WideString	ToWideString (Ese::OpenTableFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::TransactionFlags value)
WideString	ToWideString (Ese::TransactionFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::AttachDatabaseFlags value)
WideString	ToWideString (Ese::AttachDatabaseFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::DetachDatabaseFlags value)
WideString	ToWideString (Ese::DetachDatabaseFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::CreateDatabaseFlags value)
WideString	ToWideString (Ese::CreateDatabaseFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::OpenDatabaseFlags value)
WideString	ToWideString (Ese::OpenDatabaseFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::InitFlags value)
WideString	ToWideString (Ese::InitFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::OnlineDefragFlags value)
WideString	ToWideString (Ese::OnlineDefragFlags value, const WideString &defaultResult)
WideString	ToWideString (Ese::BackupFlags value)
WideString	ToWideString (Ese::BackupFlags value, const WideString &defaultResult)
HCC_EXPORT WideString	ToWideString (Ese::ColumnType value)
HCC_EXPORT WideString	ToWideString (Ese::ColumnType value, const WideString &defaultResult)
AnsiString	ToAnsiString (Ese::ColumnType value)
AnsiString	ToAnsiString (Ese::ColumnType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT,WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::ColumnType &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::ColumnType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::ColumnType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Ese::ColumnFlags value)
HCC_EXPORT WideString	ToWideString (Ese::ColumnFlags value, const WideString &defaultResult)
AnsiString	ToAnsiString (Ese::ColumnFlags value)
AnsiString	ToAnsiString (Ese::ColumnFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::ColumnFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::ColumnFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::ColumnFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Ese::IndexFlags value)
HCC_EXPORT WideString	ToWideString (Ese::IndexFlags value, const WideString &defaultResult)
AnsiString	ToAnsiString (Ese::IndexFlags value)
AnsiString	ToAnsiString (Ese::IndexFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::IndexFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::IndexFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::IndexFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Ese::RetrieveFlags value)
HCC_EXPORT WideString	ToWideString (Ese::RetrieveFlags value, const WideString &defaultResult)
AnsiString	ToAnsiString (Ese::RetrieveFlags value)
AnsiString	ToAnsiString (Ese::RetrieveFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::RetrieveFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::RetrieveFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::RetrieveFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
HCC_EXPORT WideString	ToWideString (Ese::SetFlags value)
HCC_EXPORT WideString	ToWideString (Ese::SetFlags value, const WideString &defaultResult)
AnsiString	ToAnsiString (Ese::SetFlags value)
AnsiString	ToAnsiString (Ese::SetFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::SetFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::SetFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::SetFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::ColumnInfoLevel value)
AnsiString	ToAnsiString (Ese::ColumnInfoLevel value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::ColumnInfoLevel &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::ColumnInfoLevel, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::ColumnInfoLevel, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::PrepareUpdateOptions value)
AnsiString	ToAnsiString (Ese::PrepareUpdateOptions value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::PrepareUpdateOptions &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::PrepareUpdateOptions, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::PrepareUpdateOptions, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::KeyFlags value)
AnsiString	ToAnsiString (Ese::KeyFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::KeyFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::KeyFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::KeyFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::SeekFlags value)
AnsiString	ToAnsiString (Ese::SeekFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::SeekFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::SeekFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::SeekFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::IndexRangeFlags value)
AnsiString	ToAnsiString (Ese::IndexRangeFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::IndexRangeFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::IndexRangeFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::IndexRangeFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::SetCurrentIndexFlags value)
AnsiString	ToAnsiString (Ese::SetCurrentIndexFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::SetCurrentIndexFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::SetCurrentIndexFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::SetCurrentIndexFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::TableOptions value)
AnsiString	ToAnsiString (Ese::TableOptions value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::TableOptions &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::TableOptions, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::TableOptions, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::ObjectFlags value)
AnsiString	ToAnsiString (Ese::ObjectFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::ObjectFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::ObjectFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::ObjectFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::SequentialFlags value)
AnsiString	ToAnsiString (Ese::SequentialFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::SequentialFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::SequentialFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::SequentialFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::ExceptionAction value)
AnsiString	ToAnsiString (Ese::ExceptionAction value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::ExceptionAction &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::ExceptionAction, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::ExceptionAction, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::OpenTableFlags value)
AnsiString	ToAnsiString (Ese::OpenTableFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::OpenTableFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::OpenTableFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::OpenTableFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::TransactionFlags value)
AnsiString	ToAnsiString (Ese::TransactionFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::TransactionFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::TransactionFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::TransactionFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::AttachDatabaseFlags value)
AnsiString	ToAnsiString (Ese::AttachDatabaseFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::AttachDatabaseFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::AttachDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::AttachDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::DetachDatabaseFlags value)
AnsiString	ToAnsiString (Ese::DetachDatabaseFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::DetachDatabaseFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::DetachDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::DetachDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::CreateDatabaseFlags value)
AnsiString	ToAnsiString (Ese::CreateDatabaseFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::CreateDatabaseFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::CreateDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::CreateDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::OpenDatabaseFlags value)
AnsiString	ToAnsiString (Ese::OpenDatabaseFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::OpenDatabaseFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::OpenDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::OpenDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::InitFlags value)
AnsiString	ToAnsiString (Ese::InitFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::InitFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::InitFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::InitFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::OnlineDefragFlags value)
AnsiString	ToAnsiString (Ese::OnlineDefragFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::OnlineDefragFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::OnlineDefragFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::OnlineDefragFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Ese::BackupFlags value)
AnsiString	ToAnsiString (Ese::BackupFlags value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Ese::BackupFlags &value)
template<typename T , typename StringT > requires std::is_same_v<Ese::BackupFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Ese::BackupFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
void	LogStackTrace ()
	__declspec (thread) wchar_t ExceptionFormatBuffer[1024] = { 0, }
HCC_EXPORT std::ostream &	operator<< (std::ostream &stream, const Guid &guid)
template<typename T > requires IsGuid<T>
constexpr T	ByteSwap (const T &guid) noexcept
	Implements ByteSwap for a Guid.
WideString	ToWideString (const IO::MemoryStream &stream, bool convertToUnicode=false)
AnsiString	ToAnsiString (const IO::MemoryStream &stream, bool convertFromUnicode=false)
template<typename T > requires IsInteger<std::remove_cvref_t<T>>
constexpr T	ByteSwap (T value)
template<typename T , size_t N> requires IsUnsignedInteger<T> && (N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskTrailingOnes ()
	Creates a bitmask with the N right-most bits set to 1, and all other bits set to 0.
template<typename T , size_t N> requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskLeadingOnes ()
	Creates a bitmask with the N left-most bits set to 1, and all other bits set to 0.
template<typename T , size_t N> requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskTrailingZeros ()
	Creates a bitmask with the N right-most bits set to 0, and all other bits set to 1.
template<typename T , size_t N> requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskLeadingZeros ()
	Creates a bitmask with the N left-most bits set to 0, and all other bits set to 1.
constexpr Byte	ReverseBits (Byte b) noexcept
	Reverses the order of the bits of a byte.
constexpr SByte	ReverseBits (SByte b) noexcept
	Reverses the order of the bits of a SByte.
constexpr char	ReverseBits (char b) noexcept
	Reverses the order of the bits of a char.
constexpr UInt16	ReverseBits (UInt16 val) noexcept
	Reverses the order of the bits of an UInt16.
constexpr Int16	ReverseBits (Int16 val) noexcept
	Reverses the order of the bits of an Int16.
constexpr wchar_t	ReverseBits (wchar_t val) noexcept
constexpr UInt32	ReverseBits (UInt32 val) noexcept
	Reverses the order of the bits of an UInt32.
constexpr Int32	ReverseBits (Int32 val) noexcept
	Reverses the order of the bits of an Int32.
constexpr long	ReverseBits (long val) noexcept
	Reverses the order of the bits of a long.
constexpr unsigned long	ReverseBits (unsigned long val) noexcept
	Reverses the order of the bits of an unsigned long.
constexpr UInt64	ReverseBits (UInt64 val) noexcept
	Reverses the order of the bits of an UInt64.
constexpr Int64	ReverseBits (Int64 val) noexcept
	Reverses the order of the bits of an Int64.
constexpr Single	ReverseBits (float val) noexcept
	Reverses the order of the bits of a float.
constexpr Double	ReverseBits (double val) noexcept
	Reverses the order of the bits of a double.
template<typename T > requires std::is_integral_v<T>
constexpr bool	IndexOfBitFromMSB (unsigned long *index, T bits)
constexpr UInt64	CreateBitMask64 (unsigned numberOfBitsToSet) noexcept
	Creates a bit-mask.
constexpr UInt32	CreateBitMask32 (unsigned numberOfBitsToSet) noexcept
	Creates a bit-mask with all the bits - up to, and including, the bit at bitIndex.
constexpr UInt64	ExtractBits64 (UInt64 value, UInt32 start, UInt32 len) noexcept
	Extracts contiguous bits from value.
constexpr UInt32	ExtractBits32 (UInt32 value, UInt32 start, UInt32 len) noexcept
	Extracts contiguous bits from value.
template<size_t N>
const void *	AlignTo (const void *address)
	Calculates the address that is aligned on an N byte boundary greater, or equal, to address.
template<size_t N>
void *	AlignTo (void *address)
	Calculates the address that is aligned on an N byte boundary greater, or equal, to address.
template<size_t N>
size_t	AlignedPaddingFor (const void *address)
	Calculates the number of bytes between the argument address and an address that is aligned on an N byte boundary greater, or equal, to address.
template<typename T > requires IsGUID<T>
constexpr T	ByteSwap (const T &guid) noexcept
	Swaps the bytes of the Data1, Data2 and Data3 fields of a Guid or GUID, while leaving Data4 as it is.
template<typename T > requires (IsFloatingPoint<std::remove_cvref_t<T>> || std::is_enum_v<std::remove_cvref_t<T>> )
constexpr T	ByteSwap (const T value) noexcept
	Reverses the bytes of a floating point value, or an enum.
template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }
constexpr T1	GetHigh32Bits (T2 val) noexcept
template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }
constexpr T2	SetHigh32Bits (T2 x, T1 value) noexcept
template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }
constexpr T1	GetLow32Bits (T2 val) noexcept
template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }
constexpr T2	SetLow32Bits (T2 x, T1 value) noexcept
template<typename T1 , typename T2 , typename T3 > requires ( sizeof( T1 ) == 8 ) && ( std::is_same_v<Int32, T2> || std::is_same_v<UInt32, T2> ) && ( std::is_same_v<Int32, T3> || std::is_same_v<UInt32, T3> ) && requires( UInt64 v1 ) { { std::bit_cast<T1>( v1 ) }->std::same_as<T1>; }
constexpr T1	From32BitsTo64Bits (T2 high32Bits, T3 low32Bits) noexcept
constexpr int	Exponent (double value) noexcept
constexpr int	Exponent (float v) noexcept
constexpr UInt64	Significand (double value) noexcept
constexpr int	Significand (float v) noexcept
constexpr UInt64	SignBit (double value)
constexpr uint32_t	SignBit (float v)
constexpr double	FlipSign (double a, double b)
constexpr float	FlipSign (float a, float b)
void	MemCopy (char *dest, const char *source, size_t length) noexcept
void	MemCopy (wchar_t *dest, const wchar_t *source, size_t length) noexcept
void	MemMove (char *dest, const char *source, size_t length) noexcept
void	MemMove (wchar_t *dest, const wchar_t *source, size_t length) noexcept
void	MemSet (char *dest, char value, size_t length) noexcept
void	MemSet (wchar_t *dest, wchar_t value, size_t length) noexcept
int	MemCmp (const char *first, const char *second, size_t length)
int	MemCmp (const wchar_t *first, const wchar_t *second, size_t length)
char *	MemChr (char *buffer, int value, size_t bufferSize) noexcept
const char *	MemChr (const char *buffer, int value, size_t bufferSize) noexcept
wchar_t *	MemChr (wchar_t *buffer, int value, size_t bufferSize) noexcept
const wchar_t *	MemChr (const wchar_t *buffer, int value, size_t bufferSize) noexcept
char	ToUpper (char c) noexcept
wchar_t	ToUpper (wchar_t c) noexcept
char	ToLower (char c) noexcept
wchar_t	ToLower (wchar_t c) noexcept
void	ToUpper (char *s)
void	ToUpper (wchar_t *s)
void	ToLower (char *s)
void	ToLower (wchar_t *s)
void	ToUpper (char *s, size_t size)
void	ToUpper (wchar_t *s, size_t size)
void	ToLower (char *s, size_t size)
void	ToLower (wchar_t *s, size_t size)
char *	MemIChr (char *buffer, int value, size_t bufferSize) noexcept
const char *	MemIChr (const char *buffer, int value, size_t bufferSize) noexcept
wchar_t *	MemIChr (wchar_t *buffer, int value, size_t bufferSize) noexcept
const wchar_t *	MemIChr (const wchar_t *buffer, int value, size_t bufferSize) noexcept
template<typename T , size_t N> requires ( std::is_same_v<char,std::remove_cv_t<T>> == false && std::is_same_v<wchar_t, std::remove_cv_t<T>> == false )
constexpr size_t	LengthOf (T(&array)[N]) noexcept
template<typename T > requires requires( T container ) { { container.size( ) } -> std::convertible_to<size_t>; }
constexpr size_t	LengthOf (const T &container) noexcept
template<typename T > requires std::is_same_v<T,char> || std::is_same_v<T, wchar_t>
constexpr size_t	LengthOf (const T *str) noexcept
constexpr int	Compare (nullptr_t s1, nullptr_t s2) noexcept
constexpr int	Compare (nullptr_t s1, const char *s2) noexcept
constexpr int	Compare (const char *s1, nullptr_t s2) noexcept
constexpr int	Compare (const char *s1, const char *s2) noexcept
constexpr int	Compare (nullptr_t s1, const wchar_t *s2) noexcept
constexpr int	Compare (const wchar_t *s1, nullptr_t s2) noexcept
constexpr int	Compare (const wchar_t *s1, const wchar_t *s2) noexcept
template<typename T > requires std::is_integral_v<T> || std::is_floating_point_v<T>
constexpr int	Compare (T v1, T v2) noexcept
template<typename T > requires std::is_same_v<DateTime, std::remove_cvref_t<T>> || std::is_same_v<TimeSpan, std::remove_cvref_t<T>> || std::is_same_v<Currency, std::remove_cvref_t<T>>
constexpr int	Compare (T v1, T v2) noexcept
template<typename T1 , typename T2 > requires ((std::is_same_v<Guid, std::remove_cvref_t<T1>> || std::is_same_v<GUID, std::remove_cvref_t<T1>> ) && ( std::is_same_v<Guid, std::remove_cvref_t<T2>> || std::is_same_v<GUID, std::remove_cvref_t<T2>> ) )
constexpr int	Compare (const T1 &v1, const T2 &v2) noexcept
template<typename T1 , typename T2 > requires requires( const T1& t1, const T2& t2 ) { { t1.compare( t2 ) } ->std::convertible_to<int>; }
int	Compare (const T1 &v1, const T2 &v2) noexcept
template<typename FirstT , typename SecondT > requires requires( FirstT f, SecondT s ) { { Compare( f, s ) } ->std::convertible_to<int>; }
int	Compare (const FirstT *first, size_t firstLength, const SecondT *second, size_t secondLength)
template<typename FirstT , typename SecondT , typename ConversionFunc > requires requires( FirstT f, SecondT s, ConversionFunc func ) { { Compare( f, s ) } ->std::convertible_to<int>; { func(s) } ->std::convertible_to<FirstT>; }
int	Compare (const FirstT *first, size_t firstLength, const SecondT *second, size_t secondLength, ConversionFunc converter)
template<typename FirstT , typename SecondT , typename CompareFunc > requires requires( FirstT f, SecondT s, CompareFunc func ) { { func( f, s ) } ->std::convertible_to<int>; }
int	CompareEx (const FirstT *first, size_t firstLength, const SecondT *second, size_t secondLength, CompareFunc compare)
template<SimpleSpanLike T1, SimpleSpanLike T2, typename ConversionFunc >
int	Compare (const T1 &first, const T2 &second, ConversionFunc converter)
template<SimpleSpanLike T1, SimpleSpanLike T2> requires (std::is_same_v< typename T1::value_type, typename T2::value_type > && ( IsBasicString<T1> == false ) )
int	Compare (const T1 &first, const T2 &second)
template<typename T > requires std::is_floating_point_v<T>
constexpr bool	AreNearlyEqual (T a, T b, T smallNumber=static_cast< T >(0.0001)) noexcept
template<typename T > requires IsInteger<T>
constexpr bool	IsPowerOfTwo (T v) noexcept
template<typename T > requires IsInteger<T>
constexpr bool	IsPowerOf2 (T v) noexcept
template<typename T > requires std::is_enum_v<std::remove_cvref_t<T>>
constexpr bool	IsPowerOfTwo (T v) noexcept
template<typename T > requires std::is_enum_v<std::remove_cvref_t<T>>
constexpr bool	IsPowerOf2 (T v) noexcept
constexpr Byte	NextPowerOfTwo (Byte v) noexcept
constexpr SByte	NextPowerOfTwo (SByte v) noexcept
constexpr Int16	NextPowerOfTwo (Int16 v) noexcept
constexpr UInt16	NextPowerOfTwo (UInt16 v) noexcept
constexpr Int32	NextPowerOfTwo (Int32 v) noexcept
constexpr UInt32	NextPowerOfTwo (UInt32 v) noexcept
constexpr Int64	NextPowerOfTwo (Int64 v) noexcept
constexpr UInt64	NextPowerOfTwo (UInt64 v) noexcept
template<typename CharType >
bool	HexToBinary (CharType c, Byte &result)
template<typename CharType >
bool	HexToBinary (const CharType *text, size_t textLength, std::vector< Byte > &result)
template<typename PointerT >
constexpr auto	UnwrapPointer (const PointerT &pointer) noexcept
	Extracts a plain pointer from a smart pointer.
template<typename PointerT >
constexpr auto	UnwrapPointer (PointerT &pointer) noexcept
	Extracts a plain pointer from a smart pointer.
template<typename T >
constexpr T *	UnwrapPointer (T *pointer) noexcept
	ensure no conversion for regular pointers
template<typename PointerT , std::enable_if_t<!std::is_pointer_v< PointerT >, int > = 0>
constexpr PointerT	WrapPointer (typename std::pointer_traits< PointerT >::element_type *pointer) noexcept
template<typename PointerT , std::enable_if_t< std::is_pointer_v< PointerT >, int > = 0>
constexpr PointerT	WrapPointer (PointerT pointer) noexcept
	ensure no conversion for regular pointers
template<SimpleComLike T, typename... Args>
ReferenceCountedPtr< T >	MakeReferenceCounted (Args &&... args)
template<SimpleComLike T>
ReferenceCountedPtr< T >	WrapReferenceCounted (T *ptr, bool addRef=false)
PageFlags	GetPageFlags (MemoryMappedFileAccess access)
DWORD	GetFileMapAccess (MemoryMappedFileAccess access)
IO::FileSystemRights	GetFileSystemRights (MemoryMappedFileAccess access)
IO::FileAccess	GetFileAccess (MemoryMappedFileAccess access)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (PageFlags, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (SectionFlags, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (MemoryMappedFileRights, DWORD)
PageFlags	GetPageAccess (MemoryMappedFileAccess access)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (MemoryMappedFileOptions, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (FileMap, DWORD)
WideString	ToWideString (const DL_EUI48 *ethernetAddress)
AnsiString	ToAnsiString (const DL_EUI48 *ethernetAddress)
bool	TryParse (const wchar_t *str, const wchar_t **end, DL_EUI48 *ethernetAddress)
bool	TryParse (const wchar_t *str, DL_EUI48 *ethernetAddress)
bool	TryParse (const char *str, const char **end, DL_EUI48 *ethernetAddress)
bool	TryParse (const char *str, DL_EUI48 *ethernetAddress)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, DL_EUI48 *ethernetAddress)
WideString	ToWideString (const in_addr *addr)
AnsiString	ToAnsiString (const in_addr *addr)
bool	TryParse (const wchar_t *str, bool strict, const wchar_t **end, in_addr *addr)
bool	TryParse (const wchar_t *str, const wchar_t **end, in_addr *addr)
bool	TryParse (const wchar_t *str, in_addr *addr)
bool	TryParse (const char *str, bool strict, const char **end, in_addr *addr)
bool	TryParse (const char *str, const char **end, in_addr *addr)
bool	TryParse (const char *str, in_addr *addr)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, in_addr *addr)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, typename StringT::size_type &end, in_addr *addr)
WideString	ToWideString (const in_addr *addr, UInt16 port)
AnsiString	ToAnsiString (const in_addr *addr, UInt16 port)
WideString	ToWideString (const in6_addr *addr, UInt32 scopeId, UInt16 port)
AnsiString	ToAnsiString (const in6_addr *addr, UInt32 scopeId, UInt16 port)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (DropEffect, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (MarshalFlags, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (ProcessAccessRights, DWORD)
WideString	ToWideString (Services::ServiceAccessRights value)
WideString	ToWideString (Services::ServiceAccessRights value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceControlManagerAccessRights value)
WideString	ToWideString (Services::ServiceControlManagerAccessRights value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceType value)
WideString	ToWideString (Services::ServiceType value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceStartType value)
WideString	ToWideString (Services::ServiceStartType value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceEnumerationState value)
WideString	ToWideString (Services::ServiceEnumerationState value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceState value)
WideString	ToWideString (Services::ServiceState value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceControl value)
WideString	ToWideString (Services::ServiceControl value, const WideString &defaultResult)
WideString	ToWideString (Services::ServiceControlAccepted value)
WideString	ToWideString (Services::ServiceControlAccepted value, const WideString &defaultResult)
WideString	ToWideString (Services::DeviceEventType value)
WideString	ToWideString (Services::DeviceEventType value, const WideString &defaultResult)
WideString	ToWideString (Services::HardwareProfileChangeEventType value)
WideString	ToWideString (Services::HardwareProfileChangeEventType value, const WideString &defaultResult)
WideString	ToWideString (Services::PowerEventType value)
WideString	ToWideString (Services::PowerEventType value, const WideString &defaultResult)
AnsiString	ToAnsiString (Services::ServiceAccessRights value)
AnsiString	ToAnsiString (Services::ServiceAccessRights value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceAccessRights &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceAccessRights, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceAccessRights, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceControlManagerAccessRights value)
AnsiString	ToAnsiString (Services::ServiceControlManagerAccessRights value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceControlManagerAccessRights &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceControlManagerAccessRights, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceControlManagerAccessRights, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceType value)
AnsiString	ToAnsiString (Services::ServiceType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceType &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceStartType value)
AnsiString	ToAnsiString (Services::ServiceStartType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceStartType &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceStartType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceStartType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceEnumerationState value)
AnsiString	ToAnsiString (Services::ServiceEnumerationState value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceEnumerationState &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceEnumerationState, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceEnumerationState, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceState value)
AnsiString	ToAnsiString (Services::ServiceState value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceState &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceState, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceState, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceControl value)
AnsiString	ToAnsiString (Services::ServiceControl value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceControl &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceControl, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceControl, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::ServiceControlAccepted value)
AnsiString	ToAnsiString (Services::ServiceControlAccepted value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::ServiceControlAccepted &value)
template<typename T , typename StringT > requires std::is_same_v<Services::ServiceControlAccepted, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::ServiceControlAccepted, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::DeviceEventType value)
AnsiString	ToAnsiString (Services::DeviceEventType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::DeviceEventType &value)
template<typename T , typename StringT > requires std::is_same_v<Services::DeviceEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::DeviceEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::HardwareProfileChangeEventType value)
AnsiString	ToAnsiString (Services::HardwareProfileChangeEventType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::HardwareProfileChangeEventType &value)
template<typename T , typename StringT > requires std::is_same_v<Services::HardwareProfileChangeEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::HardwareProfileChangeEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
AnsiString	ToAnsiString (Services::PowerEventType value)
AnsiString	ToAnsiString (Services::PowerEventType value, const AnsiString &defaultResult)
template<typename StringT > requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>
bool	TryParse (const StringT &str, Services::PowerEventType &value)
template<typename T , typename StringT > requires std::is_same_v<Services::PowerEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )
T	Parse (const WideString &str)
template<typename T , typename CharT > requires std::is_same_v<Services::PowerEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )
T	Parse (const CharT *str)
WideString	ToWideString (bool value)
WideString	ToWideString (SByte value, int base)
WideString	ToWideString (Byte value, int base)
WideString	ToWideString (Int16 value, int base)
WideString	ToWideString (UInt16 value, int base)
WideString	ToWideString (Int32 value, int base)
WideString	ToWideString (UInt32 value, int base)
WideString	ToWideString (Int64 value, int base)
WideString	ToWideString (UInt64 value, int base)
WideString	ToWideStringInvariant (Single value, int width, int precision)
WideString	ToWideStringInvariant (Single value)
WideString	ToWideString (Single value)
WideString	ToWideString (Single value, int width, int precision)
WideString	ToWideString (Single value, const std::locale &locale)
WideString	ToWideString (Single value, int width, int precision, const std::locale &locale)
WideString	ToWideString (Double value)
WideString	ToWideString (const DateTime &value)
WideString	ToWideString (const TimeSpan &value)
WideString	ToWideString (const Guid &value)
WideString	ToWideString (const Currency &value)
WideString	ToWideString (const Variant &value)
WideString	ToWideString (const FixedSizeMemoryManagerStatistics &statistics)
AnsiString	ToAnsiString (bool value)
AnsiString	ToAnsiString (SByte value, int base)
AnsiString	ToAnsiString (Byte value, int base)
AnsiString	ToAnsiString (Int16 value, int base)
AnsiString	ToAnsiString (UInt16 value, int base)
AnsiString	ToAnsiString (Int32 value, int base)
AnsiString	ToAnsiString (UInt32 value, int base)
AnsiString	ToAnsiString (Int64 value, int base)
AnsiString	ToAnsiString (UInt64 value, int base)
AnsiString	ToAnsiString (Single value)
AnsiString	ToAnsiStringInvariant (Single value, int width, int precision)
AnsiString	ToAnsiStringInvariant (Single value)
AnsiString	ToAnsiString (Single value, int width, int precision)
AnsiString	ToAnsiString (Single value, const std::locale &locale)
AnsiString	ToAnsiString (Single value, int width, int precision, const std::locale &locale)
AnsiString	ToAnsiStringInvariant (Double value, int width, int precision)
AnsiString	ToAnsiStringInvariant (Double value)
AnsiString	ToAnsiString (Double value)
AnsiString	ToAnsiString (Double value, const std::locale &locale)
AnsiString	ToAnsiString (Double value, int width, int precision)
AnsiString	ToAnsiString (Double value, int width, int precision, const std::locale &locale)
AnsiString	ToAnsiString (const DateTime &value)
AnsiString	ToAnsiString (const TimeSpan &value)
AnsiString	ToAnsiString (const Guid &value)
AnsiString	ToAnsiString (const Currency &value)
AnsiString	ToAnsiString (const Variant &value)
AnsiString	ToAnsiString (const FixedSizeMemoryManagerStatistics &statistics)
bool	ParseBoolean (const wchar_t *str) noexcept
bool	ParseBoolean (const char *str) noexcept
bool	TryParseBoolean (const wchar_t *str, bool &value) noexcept
bool	TryParseBoolean (const char *str, bool &value) noexcept
Byte	ParseByte (const wchar_t *str, int radix)
Byte	ParseByte (const char *str, int radix)
bool	TryParseByte (const wchar_t *str, Byte &value, int radix) noexcept
bool	TryParseByte (const char *str, Byte &value, int radix) noexcept
SByte	ParseSByte (const wchar_t *str, int radix)
SByte	ParseSByte (const char *str, int radix)
bool	TryParseSByte (const wchar_t *str, SByte &value, int radix) noexcept
bool	TryParseSByte (const char *str, SByte &value, int radix) noexcept
Int16	ParseInt16 (const wchar_t *str, int radix)
Int16	ParseInt16 (const char *str, int radix)
bool	TryParseInt16 (const wchar_t *str, Int16 &value, int radix) noexcept
bool	TryParseInt16 (const char *str, Int16 &value, int radix) noexcept
UInt16	ParseUInt16 (const wchar_t *str, int radix)
UInt16	ParseUInt16 (const char *str, int radix)
bool	TryParseUInt16 (const wchar_t *str, UInt16 &value, int radix) noexcept
bool	TryParseUInt16 (const char *str, UInt16 &value, int radix) noexcept
Int32	ParseInt32 (const wchar_t *str, int radix)
Int32	ParseInt32 (const char *str, int radix)
bool	TryParseInt32 (const wchar_t *str, Int32 &value, int radix) noexcept
bool	TryParseInt32 (const char *str, Int32 &value, int radix) noexcept
UInt32	ParseUInt32 (const wchar_t *str, int radix)
UInt32	ParseUInt32 (const char *str, int radix)
bool	TryParseUInt32 (const wchar_t *str, UInt32 &value, int radix) noexcept
bool	TryParseUInt32 (const char *str, UInt32 &value, int radix) noexcept
Int64	ParseInt64 (const wchar_t *str, int radix)
Int64	ParseInt64 (const char *str, int radix)
bool	TryParseInt64 (const wchar_t *str, Int64 &value, int radix) noexcept
bool	TryParseInt64 (const char *str, Int64 &value, int radix) noexcept
UInt64	ParseUInt64 (const wchar_t *str, int radix)
UInt64	ParseUInt64 (const char *str, int radix)
bool	TryParseUInt64 (const wchar_t *str, UInt64 &value, int radix) noexcept
bool	TryParseUInt64 (const char *str, UInt64 &value, int radix) noexcept
Single	ParseSingle (const wchar_t *str)
Single	ParseSingle (const char *str)
bool	TryParseSingle (const wchar_t *str, float &value) noexcept
bool	TryParseSingle (const char *str, float &value) noexcept
Single	ParseSingleInvariant (const wchar_t *str)
Single	ParseSingleInvariant (const char *str)
bool	TryParseSingleInvariant (const wchar_t *str, float &value) noexcept
bool	TryParseSingleInvariant (const char *str, float &value) noexcept
Double	ParseDouble (const wchar_t *str)
Double	ParseDouble (const char *str)
bool	TryParseDouble (const wchar_t *str, double &value) noexcept
bool	TryParseDouble (const char *str, double &value) noexcept
double	ParseDoubleInvariant (const wchar_t *str)
double	ParseDoubleInvariant (const char *str)
bool	TryParseDoubleInvariant (const wchar_t *str, double &value) noexcept
bool	TryParseDoubleInvariant (const char *str, double &value) noexcept
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const BasicString< CharT > &str)
template<class CharT , class CharTraitsT >
std::basic_istream< CharT, CharTraitsT > &	operator>> (std::basic_istream< CharT, CharTraitsT > &inputStream, BasicString< CharT > &str)
template<WideStringLike StringT>
void	ToWideString (const char *source, size_t length, unsigned codePage, unsigned flags, StringT &dest)
template<WideStringLike StringT>
void	ToWideString (const char *source, size_t length, StringT &dest)
template<AnsiStringLike AnsiStringT, WideStringLike WideStringT>
void	ToWideString (const AnsiStringT &source, WideStringT &dest)
WideString	ToWideString (const std::string &source)
WideString	ToWideString (const AnsiString &source)
WideString	ToWideString (const std::string_view &source)
WideString	ToWideString (const char *source)
WideString	ToWideString (const wchar_t *source)
template<AnsiStringLike StringT>
void	ToAnsiString (const wchar_t *source, size_t length, unsigned codePage, unsigned flags, StringT &dest)
template<AnsiStringLike StringT>
void	ToAnsiString (const wchar_t *source, size_t length, StringT &dest)
template<WideStringLike WideStringT, AnsiStringLike AnsiStringT>
void	ToAnsiString (const WideStringT &source, AnsiStringT &dest)
template<AnsiStringLike AnsiStringT = AnsiString, WideStringLike WideStringT>
AnsiStringT	ToAnsiString (const WideStringT &source)
void	ToAnsiString (const std::wstring_view &source, AnsiString &dest)
AnsiString	ToAnsiString (const std::wstring_view &source)
AnsiString	ToAnsiString (const wchar_t *source)
template<AnsiStringLike StringT = AnsiString>
StringT	ToAnsiString (const wchar_t *source)
template<AnsiStringLike StringT = AnsiString>
StringT	ToAnsiString (const char *source)
AnsiString	ToAnsiString (const std::string &source)
template<SimpleStringLike StringT>
bool	ParseBoolean (const StringT &str) noexcept
template<SimpleStringLike StringT>
bool	TryParseBoolean (const StringT &str, bool &value) noexcept
template<typename T > requires std::is_same_v<char,T> || std::is_same_v<wchar_t, T>
bool	TryParse (const T *str, bool &value)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, bool &value) noexcept
template<typename T , typename CharT > requires std::is_same_v<bool,T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<bool, T>
T	Parse (const StringT &str)
template<SimpleStringLike StringT>
Byte	ParseByte (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseByte (const StringT &str, Byte &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, Byte &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, Byte &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<Byte, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<Byte, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
SByte	ParseSByte (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseSByte (const StringT &str, SByte &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, SByte &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, SByte &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<SByte, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<SByte, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
Int16	ParseInt16 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseInt16 (const StringT &str, Int16 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, Int16 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, Int16 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<Int16, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<Int16, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
UInt16	ParseUInt16 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseUInt16 (const StringT &str, UInt16 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, UInt16 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, UInt16 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<UInt16, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<UInt16, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
Int32	ParseInt32 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseInt32 (const StringT &str, Int32 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, Int32 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, Int32 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<Int32, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<Int32, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
UInt32	ParseUInt32 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseUInt32 (const StringT &str, UInt32 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, UInt32 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, UInt32 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<UInt32, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<UInt32, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
Int64	ParseInt64 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseInt64 (const StringT &str, Int64 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, Int64 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, Int64 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<Int64, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<Int64, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
UInt64	ParseUInt64 (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
bool	TryParseUInt64 (const StringT &str, UInt64 &value, int radix=10) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, UInt64 &value, int radix=10)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, UInt64 &value, int radix=10) noexcept
template<typename T , typename CharT > requires std::is_same_v<UInt64, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str, int radix=10)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<UInt64, T>
T	Parse (const StringT &str, int radix=10)
template<SimpleStringLike StringT>
Single	ParseSingle (const StringT &str)
template<SimpleStringLike StringT>
bool	TryParseSingle (const StringT &str, float &value) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, float &value)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, float &value) noexcept
template<typename T , typename CharT > requires std::is_same_v<float, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<float, T>
T	Parse (const StringT &str)
template<SimpleStringLike StringT>
Single	ParseSingleInvariant (std::locale locale, const StringT &str)
template<SimpleStringLike StringT>
bool	TryParseSingleInvariant (const StringT &str, float &value) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParseInvariant (const CharT *str, float &value)
template<SimpleStringLike StringT>
bool	TryParseInvariant (const StringT &str, float &value) noexcept
template<typename T , typename CharT > requires std::is_same_v<float, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	ParseInvariant (const CharT *str)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<float, T>
T	ParseInvariant (const StringT &str)
template<SimpleStringLike StringT>
Double	ParseDouble (const StringT &str)
template<SimpleStringLike StringT>
bool	TryParseDouble (const StringT &str, double &value) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParse (const CharT *str, double &value)
template<SimpleStringLike StringT>
bool	TryParse (const StringT &str, double &value) noexcept
template<typename T , typename CharT > requires std::is_same_v<double, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	Parse (const CharT *str)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<double, T>
T	Parse (const StringT &str)
template<SimpleStringLike StringT>
Double	ParseDoubleInvariant (const StringT &str)
template<SimpleStringLike StringT>
bool	TryParseDoubleInvariant (const StringT &str, double &value) noexcept
template<typename CharT > requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>
bool	TryParseInvariant (const CharT *str, double &value)
template<SimpleStringLike StringT>
bool	TryParseInvariant (const StringT &str, double &value) noexcept
template<typename T , typename CharT > requires std::is_same_v<double, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )
T	ParseInvariant (const CharT *str)
template<typename T , SimpleStringLike StringT> requires std::is_same_v<double, T>
T	ParseInvariant (const StringT &str)
bool	IsAlnum (wchar_t c)
bool	IsAlnum (char c)
bool	IsAlpha (wchar_t c)
bool	IsAlpha (char c)
bool	IsBlank (wchar_t c)
bool	IsBlank (char c)
bool	IsCntrl (wchar_t c)
bool	IsCntrl (char c)
bool	IsDigit (wchar_t c)
bool	IsDigit (char c)
bool	IsGraph (wchar_t c)
bool	IsGraph (char c)
bool	IsLower (wchar_t c)
bool	IsLower (char c)
bool	IsPrint (wchar_t c)
bool	IsPrint (char c)
bool	IsPunct (wchar_t c)
bool	IsPunct (char c)
bool	IsSpace (wchar_t c)
bool	IsSpace (char c)
bool	IsUpper (wchar_t c)
bool	IsUpper (char c)
bool	IsXDigit (wchar_t c)
bool	IsXDigit (char c)
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	TrimTrailing (const T &str, bool(testFunction)(typename T::value_type c))
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	TrimTrailing (const T &str)
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	Trim (const T &str, bool(testFunction)(typename T::value_type c))
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	Trim (const T &str)
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	TrimLeading (const T &str, bool(testFunction)(typename T::value_type c))
template<typename T > requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )
T	TrimLeading (const T &str)
template<typename T > requires ( IsStdBasicString<T> || IsBasicString<T> )
T	Strip (const T &str, bool(testFunction)(typename T::value_type c))
template<typename T > requires ( IsStdBasicString<T> )
T	ToLower (const T &str)
template<typename T > requires ( IsBasicString<T> )
T	ToLower (const T &str)
template<typename T > requires ( IsStdBasicString<T> )
T	ToUpper (const T &str)
template<typename T > requires ( IsBasicString<T> )
T	ToUpper (const T &str)
template<SimpleCharSpanLike SpanT>
bool	StartsWith (const SpanT &span, typename SpanT::value_type value)
template<SimpleCharSpanLike SpanT>
bool	EndsWith (const SpanT &span, typename SpanT::value_type value)
AnsiString	FormatV (const std::string_view fmt, const std::format_args args)
WideString	FormatV (const std::wstring_view fmt, const std::wformat_args args)
AnsiString	FormatV (const std::locale &locale, const std::string_view fmt, const std::format_args args)
WideString	FormatV (const std::locale &locale, const std::wstring_view fmt, const std::wformat_args args)
template<class... Types>
AnsiString	Format (const std::format_string< Types... > fmt, Types &&... args)
template<class... Types>
WideString	Format (const std::wformat_string< Types... > fmt, Types &&... args)
template<class... Types>
AnsiString	Format (const std::locale &locale, const std::format_string< Types... > fmt, Types &&... args)
template<class... Types>
WideString	Format (const std::locale &locale, const std::wformat_string< Types... > fmt, Types &&... args)
template<class... Types>
void	PrintLn (const std::format_string< Types... > fmt, Types &&... args)
template<class... Types>
void	PrintLn (const std::wformat_string< Types... > fmt, Types &&... args)
template<class... Types>
void	PrintLn (const std::locale &locale, const std::format_string< Types... > fmt, Types &&... args)
template<class... Types>
void	PrintLn (const std::locale &locale, const std::wformat_string< Types... > fmt, Types &&... args)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (SynchronizationBarrierFlags, UInt32)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (EventWaitHandleRights, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (MutexRights, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (SemaphoreRights, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (WaitableTimerRights, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (TimerQueueTimerFlags, DWORD)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (ThreadAccessRights, DWORD)
template<typename... Args>
	Tuple (Args... args) -> Tuple< Args... >
template<typename... Args>
	Tuple (const Tuple< Args... > &args) -> Tuple< Args... >
template<std::size_t index, typename... Args>
constexpr TupleElement_t< index, Args... > &	get (Tuple< Args... > &tuple)
template<std::size_t index, typename... Args>
constexpr const TupleElement_t< index, Args... > &	get (const Tuple< Args... > &tuple)
template<std::size_t index, typename... Args>
constexpr TupleElement_t< index, Args... > &&	get (Tuple< Args... > &&tuple)
template<std::size_t index, typename... Args>
constexpr const TupleElement_t< index, Args... > &&	get (const Tuple< Args... > &&tuple)
template<class CallableT , class TupleT >
constexpr decltype(auto)	Apply (CallableT &&callable, TupleT &&tuple)
template<class... Args>
constexpr Tuple< Internal::ToReferenceIfReferenceWrapper_t< Args >... >	MakeTuple (Args &&... args)
	Creates a Tuple from the arguments.
template<class... Args>
constexpr Tuple< Args &... >	Tie (Args &... args) noexcept
	Creates a Tuple of references from arguments.
template<class... Args>
constexpr Tuple< Args &&... >	ForwardAsTuple (Args &&... args) noexcept
template<typename... Tuples>
constexpr Core::Internal::TupleCatTraits< Tuples... >::type	TupleCat (Tuples &&... tuples)
	HCC_DEFINE_ENUM_FLAG_OPERATORS (VariantType, unsigned short)
template<typename It > requires IsIterator_v<It>
	Vector (It, It) -> Vector< IteratorValue_t< It > >

Variables
constexpr UInt64	MaxOneByteValue = 0x7FULL
constexpr UInt64	MaxTwoByteValue = 0x3FFFULL
constexpr UInt64	MaxThreeByteValue = 0x1FFFFFULL
constexpr UInt64	MaxFourByteValue = 0xFFFFFFFULL
constexpr UInt64	MaxFiveByteValue = 0x7FFFFFFFFULL
constexpr UInt64	MaxSixByteValue = 0x3FFFFFFFFFFULL
constexpr UInt64	MaxSevenByteValue = 0x1FFFFFFFFFFFFULL
constexpr UInt64	MaxEightByteValue = 0xFFFFFFFFFFFFFFULL
constexpr UInt64	MaxNineByteValue = 0xFFFFFFFFFFFFFFFFULL
template<UInt64 N>
constexpr size_t	SizeOf7BitEncoded_v = SizeOf7BitEncodedValue( N )
	Calculates the size, in bytes, required to store a 7-bit encoded 64-bit unsigned integer.
static UInt64	applicationThreadId = 0xFFFFFFFFFFFFFFFF
static UInt64	mainThreadId = 0xFFFFFFFFFFFFFFFF
union {
uint32_t   Harlinn::Common::Core::dword_table [16][256]
uint64_t   Harlinn::Common::Core::qword_array [2048]
}	table
union {
uint32_t   Harlinn::Common::Core::dword_table [4][256]
uint64_t   Harlinn::Common::Core::qword_array [512]
}	long_shifts
union {
uint32_t   Harlinn::Common::Core::dword_table [4][256]
uint64_t   Harlinn::Common::Core::qword_array [512]
}	short_shifts
uint32_t(*	crc32cImpl )(const uint8_t *, size_t, uint32_t) = crc32c_sw
template<typename T >
constexpr bool	IsCurrency = std::is_same_v<std::remove_cv_t<T>, Currency>
template<typename T >
constexpr bool	IsTimeSpan = std::is_same_v<std::remove_cv_t<T>, TimeSpan>
template<typename T >
constexpr bool	IsDateTime = std::is_same_v<std::remove_cv_t<T>, DateTime>
constexpr UInt8	MaxUInt8 = ( (UInt8)~( (UInt8)0 ) )
constexpr Int8	MaxInt8 = ( (Int8)( MaxUInt8 >> 1 ) )
constexpr Int8	MinInt8 = ( (Int8)~MaxInt8 )
constexpr UInt16	MaxUInt16 = ( (UInt16)~( (UInt16)0 ) )
constexpr Int16	MaxInt16 = ( (Int16)( MaxUInt16 >> 1 ) )
constexpr Int16	MinInt16 = ( (Int16)~MaxInt16 )
constexpr UInt32	MaxUInt32 = ( (UInt32)~( (UInt32)0 ) )
constexpr Int32	MaxInt32 = ( (Int32)( MaxUInt32 >> 1 ) )
constexpr Int32	MinInt32 = ( (Int32)~MaxInt32 )
constexpr UInt64	MaxUInt64 = ( (UInt64)~( (UInt64)0 ) )
constexpr Int64	MaxInt64 = ( (Int64)( MaxUInt64 >> 1 ) )
constexpr Int64	MinInt64 = ( (Int64)~MaxInt64 )
constexpr ULong32	MaxULong32 = ( (ULong32)~( (ULong32)0 ) )
constexpr Long32	MaxLong32 = ( (Long32)( MaxULong32 >> 1 ) )
constexpr Long32	MinLong32 = ( (Long32)~MaxLong32 )
constexpr ULong64	MaxULong64 = ( (ULong64)~( (ULong64)0 ) )
constexpr Long64	MaxLong64 = ( (Long64)( MaxULong64 >> 1 ) )
constexpr Long64	MinLong64 = ( (Long64)~MaxLong64 )
constexpr ULongLong	MaxULongLong = ( (ULongLong)~( (ULongLong)0 ) )
constexpr LongLong	MaxLongLong = ( (LongLong)( MaxULongLong >> 1 ) )
constexpr LongLong	MinLongLong = ( (LongLong)~MaxLongLong )
constexpr SizeT	MaxSizeT = ( (SizeT)~( (SizeT)0 ) )
constexpr SSizeT	MaxSSizeT = ( (SSizeT)( MaxSizeT >> 1 ) )
constexpr SSizeT	MinSSizeT = ( (SSizeT)~MaxSSizeT )
constexpr UInt	MaxUInt = ( (UInt)~( (UInt)0 ) )
constexpr Int	MaxInt = ( (Int)( MaxUInt >> 1 ) )
constexpr Int	MinInt = ( (Int)~MaxInt )
constexpr DWord32	MaxDWord32 = ( (DWord32)~( (DWord32)0 ) )
constexpr DWord64	MaxDWord64 = ( (DWord64)~( (DWord64)0 ) )
template<typename T >
constexpr bool	False_v = false
template<typename T >
constexpr bool	True_v = true
template<typename T >
constexpr bool	IsGuid = std::is_same_v<std::remove_cv_t<T>, Guid>
template<size_t N>
constexpr auto	BitMask_v = BitMask<N>::value
template<typename T >
constexpr bool	IsGUID = std::is_same_v<std::remove_cv_t<T>, GUID>
template<class , template< class... > class>
constexpr bool	IsSpecializationOf = false
template<template< class... > class T, class... Args>
constexpr bool	IsSpecializationOf< T< Args... >, T > = true
template<typename Type , typename... TypeList>
constexpr bool	IsAnyOf_v = IsAnyOf<Type, TypeList...>::value
template<typename T >
constexpr bool	IsPointer = std::is_same_v< std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>, std::remove_pointer_t<std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>>> == false
template<typename T >
constexpr bool	IsConst = std::is_same_v<std::remove_reference_t<std::remove_volatile_t<T>>, std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>> == false
template<typename T >
constexpr bool	IsVolatile = std::is_same_v<std::remove_reference_t<std::remove_const_t<T>>, std::remove_volatile_t<std::remove_reference_t<std::remove_const_t<T>>>> == false
template<typename T >
constexpr bool	IsReference = std::is_same_v< std::remove_volatile_t<std::remove_const_t<T>> , std::remove_reference_t<std::remove_volatile_t<std::remove_const_t<T>>>> == false
template<typename T >
constexpr bool	IsArray = std::is_array_v<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdArray = Core::Internal::IsStdArrayImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdVector = Core::Internal::IsStdVectorImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdVectorBool = Core::Internal::IsStdVectorBoolImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdDeque = Core::Internal::IsStdDequeImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdForwardList = Core::Internal::IsStdForwardListImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdList = Core::Internal::IsStdListImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdSet = Core::Internal::IsStdSetImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdMap = Core::Internal::IsStdMapImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdMultiset = Core::Internal::IsStdMultisetImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdMultimap = Core::Internal::IsStdMultimapImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdUnorderedSet = Core::Internal::IsStdUnorderedSetImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdUnorderedMap = Core::Internal::IsStdUnorderedMapImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdUnorderedMultiset = Core::Internal::IsStdUnorderedMultisetImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdUnorderedMultimap = Core::Internal::IsStdUnorderedMultimapImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdStack = Core::Internal::IsStdStackImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdQueue = Core::Internal::IsStdQueueImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdPriorityQueue = Core::Internal::IsStdPriorityQueueImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdSpan = Core::Internal::IsStdSpanImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdBasicString = Core::Internal::IsStdBasicStringImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsBasicString = Core::Internal::IsBasicStringImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdBasicStringView = Core::Internal::IsStdBasicStringViewImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsBasicStringView = Core::Internal::IsBasicStringViewImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsCoreByteArray = Core::Internal::IsCoreByteArrayImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsCoreVector = Core::Internal::IsCoreVectorImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsContainer
template<typename T >
constexpr bool	IsArrayContainer = IsStdArray<T> || IsCoreByteArray<T>
template<typename T >
constexpr bool	IsVectorContainer = IsStdVector<T> || IsCoreVector<T>
template<typename T >
constexpr bool	IsStdOptional = Core::Internal::IsStdOptionalImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdAny = Core::Internal::IsStdAnyImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdSharedPtr = Core::Internal::IsStdSharedPtrImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdUniquePtr = Core::Internal::IsStdUniquePtrImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdPair = Core::Internal::IsStdPairImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdTuple = Core::Internal::IsStdTupleImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsStdVariant = Core::Internal::IsStdVariantImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsCoreTuple = Core::Internal::IsCoreTupleImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsTupleType = IsStdPair<T> || IsStdTuple<T> || IsCoreTuple<T>
template<typename T >
constexpr bool	IsBasicType = Core::Internal::IsBasicTypeImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsString = std::is_pointer_v<T> && ( std::is_same_v<char, std::remove_cvref_t< std::remove_pointer_t<T>>> || std::is_same_v<wchar_t, std::remove_cvref_t< std::remove_pointer_t<T>>> )
template<typename T >
constexpr bool	IsCharString = std::is_pointer_v<T> && std::is_same_v<char, std::remove_cvref_t< std::remove_pointer_t<T>>>
template<typename T >
constexpr bool	IsWideCharString = std::is_pointer_v<T> && std::is_same_v<wchar_t, std::remove_cvref_t< std::remove_pointer_t<T>>>
template<typename T >
constexpr bool	IsTypeList = Core::Internal::IsTypeListImpl<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsNotBoolean = std::is_same_v<std::remove_cvref_t<T>, bool> == false
template<typename T >
constexpr bool	IsBoolean = std::is_same_v<std::remove_cvref_t<T>, bool>
template<typename T >
constexpr bool	IsInteger = std::is_integral_v<std::remove_cvref_t<T>> && IsBoolean<T> == false
template<typename T >
constexpr bool	IsSignedInteger = IsInteger<std::remove_cvref_t<T>> && std::is_signed_v<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsUnsignedInteger = IsInteger<T> && std::is_unsigned_v<std::remove_cvref_t<T>>
template<typename T >
constexpr bool	IsFloatingPoint = std::is_floating_point_v<std::remove_cvref_t<T>>
template<typename T >
constexpr std::remove_cvref_t< T >	SignMask
template<>
constexpr UInt32	SignMask< float > = 0x80000000UL
template<>
constexpr UInt64	SignMask< double > = 0x8000000000000000ULL
template<typename T >
constexpr T	ValueMask = ~SignMask<T>
template<>
constexpr UInt32	ValueMask< float > = 0x7FFFFFFFUL
template<>
constexpr UInt64	ValueMask< double > = 0x7FFFFFFFFFFFFFFFULL
template<typename T >
constexpr bool	IsStdComplex = Core::Internal::IsStdComplexImpl<std::remove_cvref_t<T>>
template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>
constexpr U	FractionMask = std::numeric_limits<std::remove_cvref_t<T>>::max( )
template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>
constexpr U	ExponentMask = 0
template<>
constexpr UInt32	FractionMask< float, UInt32 > = std::bit_cast<UInt32>( 0b00000000011111111111111111111111 )
template<>
constexpr UInt32	ExponentMask< float, UInt32 > = std::bit_cast<UInt32>( 0b01111111100000000000000000000000 )
template<>
constexpr UInt64	FractionMask< double, UInt64 > = std::bit_cast<UInt64>( 0b0000000000001111111111111111111111111111111111111111111111111111 )
template<>
constexpr UInt64	ExponentMask< double, UInt64 > = std::bit_cast<UInt64>( 0b0111111111110000000000000000000000000000000000000000000000000000 )
template<typename ty1 , typename ty2 >
constexpr bool	size_is_greater_or_equal = sizeof( ty1 ) >= sizeof( ty2 ) ? true : false
template<typename ty1 , typename ty2 >
constexpr bool	size_is_greater = sizeof( ty1 ) > sizeof( ty2 ) ? true : false
template<typename ty1 , typename ty2 >
constexpr bool	size_is_less = sizeof( ty1 ) < sizeof( ty2 ) ? true : false
template<typename ty1 , typename ty2 >
constexpr bool	size_is_less_or_equal = sizeof( ty1 ) <= sizeof( ty2 ) ? true : false
template<typename T >
constexpr bool	IsAnsiString = std::is_base_of_v<AnsiString,T>
template<typename T >
constexpr bool	IsWideString = std::is_base_of_v<WideString, T>
template<typename T >
constexpr bool	IsAnsiStringView = std::is_base_of_v<AnsiStringView, T>
template<typename T >
constexpr bool	IsWideStringView = std::is_base_of_v<WideStringView, T>
template<typename T >
constexpr bool	IsNotString = IsAnsiString<T> == false && IsWideString<T> == false
template<class It , class = void>
constexpr bool	IsIterator_v = false
template<class It >
constexpr bool	IsInputIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::input_iterator_tag>
template<class It >
constexpr bool	IsForwardIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::forward_iterator_tag>
template<class It >
constexpr bool	IsBidirectionalIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::bidirectional_iterator_tag>
template<class It >
constexpr bool	IsRandomAccessIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::random_access_iterator_tag>
template<class It >
constexpr bool	IsContiguousIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::contiguous_iterator_tag>

Typedef Documentation

AnsiString

using Harlinn::Common::Core::AnsiString = BasicString<char>

AnsiStringView

using Harlinn::Common::Core::AnsiStringView = BasicStringView<char>

ApplicationMessage

using Harlinn::Common::Core::ApplicationMessage = Concurrency::Messages::Message<ApplicationMessageType>

ApplicationStopMessage

using Harlinn::Common::Core::ApplicationStopMessage = SimpleApplicationMessage<ApplicationMessageType::Stop>

ApplicationThreadAttachedMessage

using Harlinn::Common::Core::ApplicationThreadAttachedMessage = SimpleApplicationValueMessage<UInt32, ApplicationMessageType::ThreadAttached>

ApplicationThreadDetachedMessage

using Harlinn::Common::Core::ApplicationThreadDetachedMessage = SimpleApplicationValueMessage<UInt32, ApplicationMessageType::ThreadDetached>

BitMask_t

template<size_t N>

using Harlinn::Common::Core::BitMask_t = typename BitMask<N>::type

Boolean

using Harlinn::Common::Core::Boolean = bool

Byte

using Harlinn::Common::Core::Byte = unsigned char

Char

using Harlinn::Common::Core::Char = char

Char16

using Harlinn::Common::Core::Char16 = wchar_t

Char32

using Harlinn::Common::Core::Char32 = UInt32

Char8

using Harlinn::Common::Core::Char8 = char

Double

using Harlinn::Common::Core::Double = double

DWord

using Harlinn::Common::Core::DWord = unsigned long

DWord32

using Harlinn::Common::Core::DWord32 = unsigned long

DWord64

using Harlinn::Common::Core::DWord64 = unsigned long

ElementTypeOf

template<typename T >

using Harlinn::Common::Core::ElementTypeOf = std::remove_reference_t<decltype( *std::begin( std::declval<T&>( ) ) )>

FixedAnsiString

template<size_t maxSize>

using Harlinn::Common::Core::FixedAnsiString = FixedString<char, maxSize>

FixedWideString

template<size_t maxSize>

using Harlinn::Common::Core::FixedWideString = FixedString<wchar_t, maxSize>

Int

using Harlinn::Common::Core::Int = int

Int16

using Harlinn::Common::Core::Int16 = short

Int32

using Harlinn::Common::Core::Int32 = int

Int64

using Harlinn::Common::Core::Int64 = long long

Int8

using Harlinn::Common::Core::Int8 = signed char

IsAnyOf

template<typename Type , typename... TypeList>

using Harlinn::Common::Core::IsAnyOf = std::disjunction<std::is_same<Type, TypeList>...>

IteratorCategory_t

template<class It >

using Harlinn::Common::Core::IteratorCategory_t = typename std::iterator_traits<It>::iterator_category

IteratorValue_t

template<class It >

using Harlinn::Common::Core::IteratorValue_t = std::iter_value_t<It>

Long32

using Harlinn::Common::Core::Long32 = long

Long64

using Harlinn::Common::Core::Long64 = long long

LongLong

using Harlinn::Common::Core::LongLong = long long

MakeUnsigned

template<typename T >

using Harlinn::Common::Core::MakeUnsigned = typename Internal::MakeUnsignedHelper< sizeof(T) >::Type

Nullable

template<typename T >

using Harlinn::Common::Core::Nullable = std::optional<T>

PropertyPageIds

using Harlinn::Common::Core::PropertyPageIds = std::vector<Guid>

SByte

using Harlinn::Common::Core::SByte = signed char

SimpleApplicationMessage

template<ApplicationMessageType messageId>

using Harlinn::Common::Core::SimpleApplicationMessage = Concurrency::Messages::SimpleMessage<ApplicationMessageType, messageId>

SimpleApplicationValueMessage

template<typename ValueT , ApplicationMessageType messageId>

using Harlinn::Common::Core::SimpleApplicationValueMessage = Concurrency::Messages::SimpleValueMessage<ValueT, ApplicationMessageType, messageId>

Single

using Harlinn::Common::Core::Single = float

SizeT

using Harlinn::Common::Core::SizeT = size_t

ssize_t

using Harlinn::Common::Core::ssize_t = std::make_signed_t<size_t>

SSizeT

using Harlinn::Common::Core::SSizeT = ssize_t

TupleElement_t

template<std::size_t index, typename... Args>

using Harlinn::Common::Core::TupleElement_t = typename TupleElement<index, Args...>::type

TypeList

template<typename ... Types>

using Harlinn::Common::Core::TypeList = Meta::List<Types...>

UInt

using Harlinn::Common::Core::UInt = unsigned int

uint

using Harlinn::Common::Core::uint = unsigned int

UInt16

using Harlinn::Common::Core::UInt16 = unsigned short

UInt32

using Harlinn::Common::Core::UInt32 = unsigned int

UInt64

using Harlinn::Common::Core::UInt64 = unsigned long long

UInt8

using Harlinn::Common::Core::UInt8 = unsigned char

ULong32

using Harlinn::Common::Core::ULong32 = unsigned long

ULong64

using Harlinn::Common::Core::ULong64 = unsigned long long

ULongLong

using Harlinn::Common::Core::ULongLong = unsigned long long

ushort

using Harlinn::Common::Core::ushort = unsigned short

WideChar

using Harlinn::Common::Core::WideChar = wchar_t

WideString

using Harlinn::Common::Core::WideString = BasicString<wchar_t>

WideStringView

using Harlinn::Common::Core::WideStringView = BasicStringView<wchar_t>

Enumeration Type Documentation

ApplicationMessageType

enum class Harlinn::Common::Core::ApplicationMessageType

strong

Enumerator
Unknown
Stop
ThreadAttached
ThreadDetached

DatePart

enum class Harlinn::Common::Core::DatePart

strong

Enumerator
Year
DayOfYear
Month
Day

DayOfWeek

enum class Harlinn::Common::Core::DayOfWeek

strong

Enumerator
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

DropEffect

enum class Harlinn::Common::Core::DropEffect : DWORD

strong

Enumerator
None
Copy
Move
Link
Scroll

EventWaitHandleRights

enum class Harlinn::Common::Core::EventWaitHandleRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Modify
FullControl

ExceptionType

enum class Harlinn::Common::Core::ExceptionType

strong

Enumerator
Unknown
exception
Exception
SystemException
AppDomainUnloadedException
ArrayTypeMismatchException
AccessViolationException
AggregateException
ApplicationException
ArgumentException
ArgumentNullException
ArgumentOutOfRangeException
ArithmeticException
BadImageFormatException
CannotUnloadAppDomainException
ContextMarshalException
DataMisalignedException
ExecutionEngineException
TypeLoadException
DivideByZeroException
DllNotFoundException
DuplicateWaitObjectException
EntryPointNotFoundException
MemberAccessException
FieldAccessException
FormatException
IndexOutOfRangeException
InsufficientExecutionStackException
OutOfMemoryException
InsufficientMemoryException
InvalidCastException
InvalidOperationException
InvalidProgramException
InvalidTimeZoneException
MethodAccessException
MissingMemberException
MissingFieldException
MissingMethodException
MulticastNotSupportedException
NotFiniteNumberException
NotImplementedException
NotSupportedException
NullReferenceException
OperationCanceledException
OverflowException
PlatformNotSupportedException
RankException
StackOverflowException
TimeoutException
TypeInitializationException
TypeUnloadedException
UnauthorizedAccessException
UriFormatException
UriTemplateMatchException
IOException
DirectoryNotFoundException
DriveNotFoundException
EndOfStreamException
FileLoadException
FileNotFoundException
PathTooLongException
PipeException
IsolatedStorageException
SocketException
CustomAttributeFormatException
InvalidFilterCriteriaException
ReflectionTypeLoadException
TargetException
TargetInvocationException
TargetParameterCountException
ExternalException
COMException
InvalidComObjectException
InvalidOleVariantTypeException
MarshalDirectiveException
SafeArrayTypeMismatchException
SafeArrayRankMismatchException
SEHException
RemotingException
RemotingTimeoutException
ServerException
SUDSGeneratorException
SUDSParserException
SerializationException
DbException
OracleException
ODBCException
MessageQueueException
MissingManifestResourceException
SecurityException
VerificationException
CryptographicException
CryptographicUnexpectedOperationException
PolicyException
SynchronizationLockException
ThreadAbortException
ThreadInterruptedException
ThreadStateException
ThreadStopException
WaitHandleCannotBeOpenedException

FileMap

enum class Harlinn::Common::Core::FileMap : DWORD

strong

Enumerator
Read
Write
AllAccess
Execute
Copy
Reserve
TargetsInvalid
LargePages

MarshalContext

enum class Harlinn::Common::Core::MarshalContext : DWORD

strong

Enumerator
Local
NoSharedMem
DifferentMachine
InProc
CrossCtx

MarshalFlags

enum class Harlinn::Common::Core::MarshalFlags : DWORD

strong

Enumerator
Normal
TableStrong
TableWeak
NoPing

MemoryMappedFileAccess

enum class Harlinn::Common::Core::MemoryMappedFileAccess : DWORD

strong

Enumerator
ReadWrite
Read
Write
CopyOnWrite
ReadExecute
ReadWriteExecute

MemoryMappedFileOptions

enum class Harlinn::Common::Core::MemoryMappedFileOptions : DWORD

strong

Enumerator
None
DelayAllocatePages

MemoryMappedFileRights

enum class Harlinn::Common::Core::MemoryMappedFileRights : DWORD

strong

Enumerator
CopyOnWrite
Write
Read
Execute
Delete
ReadPermissions
ChangePermissions
TakeOwnership
ReadWrite
ReadExecute
ReadWriteExecute
FullControl
AccessSystemSecurity

MutexRights

enum class Harlinn::Common::Core::MutexRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Modify
FullControl

PageFlags

enum class Harlinn::Common::Core::PageFlags : DWORD

strong

Enumerator
NoAccess	Disables all access to the committed region of pages. An attempt to read from, write to, or execute the committed region results in an access violation. This flag is not supported by the CreateFileMapping function.
Readonly	Enables read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation. If Data Execution Prevention is enabled, an attempt to execute code in the committed region results in an access violation.
ReadWrite
WriteCopy
Execute	Enables execute access to the committed region of pages. An attempt to write to the committed region results in an access violation. This flag is not supported by the CreateFileMapping function.
ExecuteRead	Enables execute or read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation.
ExecuteReadWrite	Enables execute, read-only, or read/write access to the committed region of pages.
ExecuteWriteCopy	Enables execute, read-only, or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as ExecuteReadWrite, and the change is written to the new page. This flag is not supported by the VirtualAlloc or VirtualAllocEx functions.
Guard	Pages in the region become guard pages. Any attempt to access a guard page causes the system to raise a STATUS_GUARD_PAGE_VIOLATION exception and turn off the guard page status. Guard pages thus act as a one-time access alarm. When an access attempt leads the system to turn off guard page status, the underlying page protection takes over. If a guard page exception occurs during a system service, the service typically returns a failure status indicator. This value cannot be used with NoAccess. This flag is not supported by the CreateFileMapping function.
NoCache	Sets all pages to be non-cachable. Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception. The NoCache flag cannot be used with the Guard, NoAccess, or WriteCombine flags. The NoCache flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions. To enable non-cached memory access for shared memory, specify the SEC_NOCACHE flag when calling the CreateFileMapping function.
WriteCombine	Sets all pages to be write-combined. Applications should not use this attribute except when explicitly required for a device.Using the interlocked functions with memory that is mapped as write - combined can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception. The PAGE_WRITECOMBINE flag cannot be specified with the PAGE_NOACCESS, PAGE_GUARD, and PAGE_NOCACHE flags. The PAGE_WRITECOMBINE flag can be used only when allocating private memory with the VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions.To enable write - combined memory access for shared memory, specify the SEC_WRITECOMBINE flag when calling the CreateFileMapping function.

ProcessAccessRights

enum class Harlinn::Common::Core::ProcessAccessRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Terminate
CreateThread
WriteSessionId
AccessMemory
ReadMemory
WriteMemory
DuplicateHandle
ExecuteProcess
WriteQuota
WriteInformation
ReadInformation
SuspenAndResume
ReadLimitedInformation
WriteLimitedInformation
FullControl

ProcessCreationFlags

enum class Harlinn::Common::Core::ProcessCreationFlags : DWORD

strong

Enumerator
None
Debug
DebugOnlyThis
Suspended
Detached
CreateNewConsole
NormalPriority
IdlePriority
HighPriority
RealTimePriority
CreateNewProcessGroup
CreateUnicodeEnvironment
CreateSeparateWowVdm
CreateSharedWowVdm
CreateForceDos
BelowNormalPriority
AboveNormalPriority
InheritParentAffinity
InheritCallerPriority
CreateProtectedProcess
ExtendedStartupInfoPresent
ProcessModeBackgroundBegin
ProcessModeBackgroundEnd
CreateSecureProcess
CreateBreakawayFromJob
CreatePreserveCodeAuthzLevel
CreateDefaultErrorMode
CreateNoWindow
ProfileUser
ProfileKernel
ProfileServer
CreateIgnoreSystemDefault

ProcessPriorityClass

enum class Harlinn::Common::Core::ProcessPriorityClass

strong

Enumerator
Normal
Idle
High
Realtime
BelowNormal
AboveNormal

RegistryValueType

enum class Harlinn::Common::Core::RegistryValueType : DWORD

strong

Enumerator
None
String
ExpandString
Binary
Int32
LittleEndianInt32
BigEndianInt32
Link
Strings
ResourceList
FullResourceDescriptor
ResourceRequirementsList
Int64
LittleEndianInt64

RequestPermissionsResult

enum class Harlinn::Common::Core::RequestPermissionsResult

strong

Enumerator
Ok
AccessDenied	The user chose to disable the sensors.
Cancelled	The user canceled the dialog box or refused elevation of permission to show the dialog box.

SectionFlags

enum class Harlinn::Common::Core::SectionFlags : DWORD

strong

Enumerator
None
PartitionOwnerHandle
Pages64K
File
Image
ProtectedImage
Reserve
Commit
NoCache
WriteCombine
LargePages
ImageNoExecute

SemaphoreRights

enum class Harlinn::Common::Core::SemaphoreRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Modify
FullControl

SynchronizationBarrierFlags

enum class Harlinn::Common::Core::SynchronizationBarrierFlags : UInt32

strong

Flags that control the behavior of threads that enter a barrier.

Enumerator
None
BlockOnly	Specifies that the thread entering the barrier should block immediately until the last thread enters the barrier.
SpinOnly	Specifies that the thread entering the barrier should spin until the last thread enters the barrier, even if the spinning thread exceeds the barrier's maximum spin count.
NoDelete	Specifies that the function can skip the work required to ensure that it is safe to delete the barrier, which can improve performance. All threads that enter this barrier must specify the flag; otherwise, the flag is ignored.

ThreadAccessRights

enum class Harlinn::Common::Core::ThreadAccessRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Terminate
SuspendAndResume
GetContext
SetContext
ReadInformation
WriteInformation
WriteThreadToken
Impersonate
ImpersonateClient
WriteLimitedInformation
ReadLimitedInformation
Resume
FullControl

ThreadModel

enum class Harlinn::Common::Core::ThreadModel : DWORD

strong

Enumerator
Unknown
ApartmentThreaded
MultiThreaded
DisableDDE
SpeedOverMemory

ThreadPriority

enum class Harlinn::Common::Core::ThreadPriority

strong

Enumerator
Idle
Lowest
BelowNormal
Normal
AboveNormal
Highest
TimeCritical
BackgroundBegin
BackgroundEnd

TimerQueueTimerFlags

enum class Harlinn::Common::Core::TimerQueueTimerFlags : DWORD

strong

Enumerator
Default	By default, the callback function is queued to a non-I/O worker thread.
ExecuteInTimerThread	The callback function is invoked by the timer thread itself. This flag should be used only for short tasks or it could affect other timer operations. The callback function is queued as an APC. It should not perform alertable wait operations.
ExecuteInPersistentThread	The callback function is queued to a thread that never terminates. It does not guarantee that the same thread is used each time. This flag should be used only for short tasks or it could affect other timer operations. This flag must be set if the thread calls functions that use APCs.
ExecuteLongFunction	The callback function can perform a long wait. This flag helps the system to decide if it should create a new thread.
ExecuteOnlyOnce	The timer will be set to the signaled state only once. If this flag is set, the Period parameter must be zero.
TransferImpersonation	Callback functions will use the current access token, whether it is a process or impersonation token. If this flag is not specified, callback functions execute only with the process token.

VariantType

enum class Harlinn::Common::Core::VariantType : unsigned short

strong

Enumerator
Empty
Null
Int2
Short
Int16
Int4
Long
Int32
Real4
Float
Single
Real8
Double
Currency
DateTime
BStr
Dispatch
Error
Bool
Variant
Unknown
Decimal
Int1
SByte
UInt1
Byte
UInt2
UShort
UInt16
UInt4
UInt32
ULong
Int8
Int64
LongLong
UInt8
UInt64
ULongLong
Int
UInt
Void
HResult
Pointer
SafeArray
CArray
UserDefined
LPStr
LPWStr
Record
IntPtr
UIntPtr
FileTime
Blob
Stream
Storage
StreamedObject
StoredObject
BlobObject
CF
CLSID
VersionedStream
BStrBlob
Vector
Array
Byref
Reserved
Illegal
IllegalMasked
TypeMask

WaitableTimerRights

enum class Harlinn::Common::Core::WaitableTimerRights : DWORD

strong

Enumerator
HCC_COMMON_CORE_SECURITY_BASE_ENUM_ACCESS_RIGHTS
Query
Modify
FullControl

WinError

enum class Harlinn::Common::Core::WinError : unsigned int

strong

Enumerator
None
Success
NoError
InvalidFunction	Incorrect function.
FileNotFound	The system cannot find the file specified.
PathNotFound	The system cannot find the path specified.
TooManyOpenFiles	The system cannot open the file.
AccessDenied	Access is denied.
InvalidHandle	The handle is invalid.
ArenaTrashed	The storage control blocks were destroyed.
NotEnoughMemory	Not enough memory resources are available to process this command.
InvalidBlock	The storage control block address is invalid.
BadEnvironment	The environment is incorrect.
BadFormat	An attempt was made to load a program with an incorrect format.
InvalidAccess	The access code is invalid.
InvalidData	The data is invalid.
OutOfMemory	Not enough memory resources are available to complete this operation.
InvalidDrive	The system cannot find the drive specified.
CurrentDirectory	The directory cannot be removed.
NotSameDevice	The system cannot move the file to a different disk drive.
NoMoreFiles	There are no more files.
WriteProtect	The media is write protected.
BadUnit	The system cannot find the device specified.
NotReady	The device is not ready.
BadCommand	The device does not recognize the command.
CyclicRedundancyCheck	Data error (cyclic redundancy check).
BadLength	The program issued a command but the command length is incorrect.
Seek	The drive cannot locate a specific area or track on the disk.
NotDosDisk	The specified disk or diskette cannot be accessed.
SectorNotFound	The drive cannot find the sector requested.
OutOfPaper	The printer is out of paper.
WriteFault	The system cannot write to the specified device.
ReadFault	The system cannot read from the specified device.
Failure	A device attached to the system is not functioning.
SharingViolation	The process cannot access the file because it is being used by another process.
LockViolation	The process cannot access the file because another process has locked a portion of the file.
WrongDisk	The wrong diskette is in the drive. Insert %2 (Volume Serial Number: %3) into drive %1.
SharingBufferExceeded	Too many files opened for sharing.
HandleEndOfFile	Reached the end of the file.
HandleDiskFull	The disk is full.
NotSupported	The request is not supported.
RemNotList	Windows cannot find the network path. Verify that the network path is correct and the destination computer is not busy or turned off. If Windows still cannot find the network path, contact your network administrator.
DuplicateName	You were not connected because a duplicate name exists on the network. If joining a domain, go to System in Control Panel to change the computer name and try again. If joining a workgroup, choose another workgroup name.
BadNetworkPath	The network path was not found.
NetworkBusy	The network is busy.
DeviceNotExist	The specified network resource or device is no longer available.
TooManyCommands	The network BIOS command limit has been reached.
AdapterHardwareError	A network adapter hardware error occurred.
BadNetworkResponse	The specified server cannot perform the requested operation.
UnexpectedNetworkError	An unexpected network error occurred.
BadRemoteAdapter	The remote adapter is not compatible.
PrinterQueueIsFull	The printer queue is full.
NoSpoolSpace	Space to store the file waiting to be printed is not available on the server.
PrintCancelled	Your file waiting to be printed was deleted.
NetworkNameDeleted	The specified network name is no longer available.
NetworkAccessDenied	Network access is denied.
BadDeviceType	The network resource type is not correct.
BadNetworkName	The network name cannot be found.
TooManyNames	The name limit for the local computer network adapter card was exceeded.
TooManySessions	The network BIOS session limit was exceeded.
SharingPaused	The remote server has been paused or is in the process of being started.
RequestNotAccepted	No more connections can be made to this remote computer at this time because there are already as many connections as the computer can accept.
RedirectPaused	The specified printer or disk device has been paused.
FileExists	The file exists.
CannotMake	The directory or file cannot be created.
Int24Failure	Fail on INT 24.
OutOfStructures	Storage to process this request is not available.
AlreadyAssigned	The local device name is already in use.
InvalidPassword	The specified network password is not correct.
InvalidParameter	The parameter is incorrect.
NetworkWriteFault	A write fault occurred on the network.
NoProcessSlots	The system cannot start another process at this time.
TooManySemaphores	Cannot create another system semaphore.
ExclusiveSemaphoreAlreadyOwned	The exclusive semaphore is owned by another process.
SemaphoreIsSet	The semaphore is set and cannot be closed.
TooManySemaphoreRequests	The semaphore cannot be set again.
InvalidAtInterruptTime	Cannot request exclusive semaphores at interrupt time.
SemaphoreOwnerDied	The previous ownership of this semaphore has ended.
SemaphoreUserLimit
DiskChange	The program stopped because an alternate diskette was not inserted.
DriveLocked	The disk is in use or locked by another process.
BrokenPipe	The pipe has been ended.
OpenFailed	The system cannot open the device or file specified.
BufferOverflow	The file name is too long.
DiskFull	There is not enough space on the disk.
NoMoreSearchHandles	No more internal file identifiers available.
InvalidTargetHandle	The target internal file identifier is incorrect.
InvalidCategory	The IOCTL call made by the application program is not correct.
InvalidVerifySwitch	The verify-on-write switch parameter value is not correct.
BadDriverLevel	The system does not support the command requested.
CallNotImplemented	This function is not supported on this system.
SemaphoreTimeout	The semaphore timeout period has expired.
InsufficientBuffer	The data area passed to a system call is too small.
InvalidName	The filename, directory name, or volume label syntax is incorrect.
InvalidLevel	The system call level is not correct.
NoVolumeLabel	The disk has no volume label.
ModuleNotFound	The specified module could not be found.
ProcedureNotFound	The specified procedure could not be found.
WaitNoChildren	There are no child processes to wait for.
ChildNotComplete	The %1 application cannot be run in Win32 mode.
DirectAccessHandle	Attempt to use a file handle to an open disk partition for an operation other than raw disk I/O.
NegativeSeek	An attempt was made to move the file pointer before the beginning of the file.
SeekOnDevice	The file pointer cannot be set on the specified device or file.
IsJoinTarget	A JOIN or SUBST command cannot be used for a drive that contains previously joined drives.
IsJoined	An attempt was made to use a JOIN or SUBST command on a drive that has already been joined.
IsSubsted	An attempt was made to use a JOIN or SUBST command on a drive that has already been substituted.
NotJoined	The system tried to delete the JOIN of a drive that is not joined.
NotSubsted	The system tried to delete the substitution of a drive that is not substituted.
JoinToJoin	The system tried to join a drive to a directory on a joined drive.
SubstToSubst	The system tried to substitute a drive to a directory on a substituted drive.
JoinToSubst	The system tried to join a drive to a directory on a substituted drive.
SubstToJoin	The system tried to SUBST a drive to a directory on a joined drive.
BusyDrive	The system cannot perform a JOIN or SUBST at this time.
SameDrive	The system cannot join or substitute a drive to or for a directory on the same drive.
DirectoryNotRoot	The directory is not a subdirectory of the root directory.
DirectoryNotEmpty	The directory is not empty.
IsSubstPath	The path specified is being used in a substitute.
IsJoinPath	Not enough resources are available to process this command.
PathBusy	The path specified cannot be used at this time.
IsSubstTarget	An attempt was made to join or substitute a drive for which a directory on the drive is the target of a previous substitute.
SystemTrace	System trace information was not specified in your CONFIG.SYS file, or tracing is disallowed.
InvalidEventCount	The number of specified semaphore events for DosMuxSemWait is not correct.
TooManyMuxWaiters	DosMuxSemWait did not execute; too many semaphores are already set.
InvalidListFormat	The DosMuxSemWait list is not correct.
LabelTooLong	The volume label you entered exceeds the label character limit of the target file system.
TooManyThreadControlBlocks	Cannot create another thread.
SignalRefused	The recipient process has refused the signal.
Discarded	The segment is already discarded and cannot be locked.
NotLocked	The segment is already unlocked.
BadThreadIdAddress	The address for the thread ID is not correct.
BadArguments	One or more arguments are not correct.
BadPathname	The specified path is invalid.
SignalPending	A signal is already pending.
MaxThreadsReached	No more threads can be created in the system.
LockFailed	Unable to lock a region of a file.
Busy	The requested resource is in use.
DeviceSupportInProgress	Device's command support detection is in progress.
CancelViolation	A lock request was not outstanding for the supplied cancel region.
AtomicLocksNotSupported	The file system does not support atomic changes to the lock type.
InvalidSegmentNumber	The system detected a segment number that was not correct.
InvalidOrdinal	The operating system cannot run %1.
AlreadyExists	Cannot create a file when that file already exists.
InvalidFlagNumber	The flag passed is not correct.
SemaphoreNotFound	The specified system semaphore name was not found.
InvalidStartingCodeSegment	The operating system cannot run %1.
InvalidStackSegment	The operating system cannot run %1.
InvalidModuleType	The operating system cannot run %1.
InvalidExeSignature	Cannot run %1 in Win32 mode.
ExeMarkedInvalid	The operating system cannot run %1.
BadExeFormat	%1 is not a valid Win32 application.
IteratedDataExceeds64k	The operating system cannot run %1.
InvalidMinAllocSize	The operating system cannot run %1.
DynlinkFromInvalidRing	The operating system cannot run this application program.
IoplNotEnabled	The operating system is not presently configured to run this application.
InvalidSegDpl	The operating system cannot run %1.
AutoDataSegExceeds64k	The operating system cannot run this application program.
Ring2SegMustBeMovable	The code segment cannot be greater than or equal to 64K.
RelocChainXeedsSegLim	The operating system cannot run %1.
InfLoopInRelocChain	The operating system cannot run %1.
EnvVarNotFound	The system could not find the environment option that was entered.
NoSignalSent	No process in the command subtree has a signal handler.
FilenameExcedRange	The filename or extension is too long.
Ring2StackInUse	The ring 2 stack is in use.
MetaExpansionTooLong	The global filename characters, * or ?, are entered incorrectly or too many global filename characters are specified.
InvalidSignalNumber	The signal being posted is not correct.
Thread1Inactive	The signal handler cannot be set.
Locked	The segment is locked and cannot be reallocated.
TooManyModules	Too many dynamic-link modules are attached to this program or dynamic-link module.
NestingNotAllowed	Cannot nest calls to LoadModule.
ExeMachineTypeMismatch	This version of %1 is not compatible with the version of Windows you're running. Check your computer's system information and then contact the software publisher.
IoIncomplete
IoPending
OperationAborted
StatusCancelled
StatusLocalDisconnect
StatusRemoteDisconnect
WsaInterrupted	A blocking operation was interrupted by a call to WSACancelBlockingCall.
WsaBadFileHandle	The file handle supplied is not valid.
WsaAccess	An attempt was made to access a socket in a way forbidden by its access permissions.
WsaInvalidPointer	The system detected an invalid pointer address in attempting to use a pointer argument in a call.
WsaInvalidArgument	An invalid argument was supplied.
WsaToManyOpenSockets	Too many open sockets.
WsaWouldBlock	A non-blocking socket operation could not be completed immediately.
WsaInProgress	A blocking operation is currently executing.
WsaAlready	An operation was attempted on a non-blocking socket that already had an operation in progress.
WsaNotSocket	An operation was attempted on something that is not a socket.
WsaDestinationAddressRequired	A required address was omitted from an operation on a socket.
WsaMessageSize	A message sent on a datagram socket was larger than the internal message buffer or some other network limit, or the buffer used to receive a datagram into was smaller than the datagram itself.
WsaProtocolType	A protocol was specified in the socket function call that does not support the semantics of the socket type requested.
WsaInvalidProtocolOptionId	An unknown, invalid, or unsupported option or level was specified in a getsockopt or setsockopt call.
WsaProtocolNotSupported	The requested protocol has not been configured into the system, or no implementation for it exists.
WsaSocketTypeNotSupportedByAddressFamily	The support for the specified socket type does not exist in this address family.
WsaOperationNotSupported	The attempted operation is not supported for the type of object referenced.
WsaProtocolFamilyNotSupported	The protocol family has not been configured into the system or no implementation for it exists.
WsaAddressIncompatibleWithProtocol	An address incompatible with the requested protocol was used.
WsaAddressInUse	Only one usage of each socket address (protocol/network address/port) is normally permitted.
WsaAddressNotAvailable	The requested address is not valid in its context.
WsaNetworkDown	A socket operation encountered a dead network.
WsaNetworkUnreachable	A socket operation was attempted to an unreachable network.
WsaNetworkReset	The connection has been broken due to keep-alive activity detecting a failure while the operation was in progress.
WsaConnectionAborted	An established connection was aborted by the software in your host machine.
WsaConnectionReset	An existing connection was forcibly closed by the remote host.
WsaNoBuffers	An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full.
WsaIsConnected	A connect request was made on an already connected socket.
WsaNotConnected	A request to send or receive data was disallowed because the socket is not connected and (when sending on a datagram socket using a sendto call) no address was supplied.
WsaShutdown	A request to send or receive data was disallowed because the socket had already been shut down in that direction with a previous shutdown call.
WsaTooManyReferences	Too many references to some kernel object.
WsaTimedout	A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.
WsaConnectionRefused	No connection could be made because the target machine actively refused it.
WsaLoop	Cannot translate name. An odd one ... perhaps it actually has a different meaning
WsaNameTooLong	Name component or name was too long.
WsaHostIsDown	A socket operation failed because the destination host was down.
WsaHostUnreachable	A socket operation was attempted to an unreachable host.
WsaNotEmpty	Cannot remove a directory that is not empty.
WsaProcessLimit	A Windows Sockets implementation may have a limit on the number of applications that may use it simultaneously.
WsaUsers	Ran out of quota.
WsaDiskQuota	Ran out of disk quota.
WsaStale	File handle reference is no longer available.
WsaRemote	Item is not available locally.
WsaSystemNotReady	WSAStartup cannot function at this time because the underlying system it uses to provide network services is currently unavailable.
WsaVersionNotSupported	The Windows Sockets version requested is not supported.
WsaNotInitialised	Either the application has not called WSAStartup, or WSAStartup failed.
WsaDisconnected	Returned by WSARecv or WSARecvFrom to indicate the remote party has initiated a graceful shutdown sequence.
WsaNoMore	No more results can be returned by WSALookupServiceNext.
WsaNoMore2
WsaCancelled	A call to WSALookupServiceEnd was made while this call was still processing. The call has been canceled.
WsaCancelled2	A call to WSALookupServiceEnd was made while this call was still processing. The call has been canceled.
WsaInvalidProcedureCallTable	The procedure call table is invalid.
WsaInvalidServiceProvider	The requested service provider is invalid.
WsaProviderInitializationFailed	The requested service provider could not be loaded or initialized.
WsaSystemCallFailure	A system call has failed.
WsaServiceNotFound	No such service is known. The service cannot be found in the specified name space.
WsaTypeNotFound	The specified class was not found.
WsaRefused	A database query failed because it was actively refused.
WsaHostNotFound	No such host is known.
WsaTryAgain	This is usually a temporary error during hostname resolution and means that the local server did not receive a response from an authoritative server.
WsaNoRecovery	A non-recoverable error occurred during a database lookup.
WsaNoData	The requested name is valid, but no data of the requested type was found.

Function Documentation

__declspec()

Harlinn::Common::Core::__declspec

(

thread

)

= { 0, }

AlignedPaddingFor()

template<size_t N>

size_t Harlinn::Common::Core::AlignedPaddingFor ( const void * address )

inline

Calculates the number of bytes between the argument address and an address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N

Parameters

address

Returns

AlignTo() [1/2]

template<size_t N>

const void * Harlinn::Common::Core::AlignTo ( const void * address )

inline

Calculates the address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N	The requested alignment.

Parameters

address

The address to calculate the alignment for.

Returns

The aligned address.

AlignTo() [2/2]

template<size_t N>

void * Harlinn::Common::Core::AlignTo ( void * address )

inline

Calculates the address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N	The requested alignment.

Parameters

address

The address to calculate the alignment for.

Returns

The aligned address.

Apply()

template<class CallableT , class TupleT >

decltype(auto) Harlinn::Common::Core::Apply ( CallableT && callable, TupleT && tuple )

constexpr

AreNearlyEqual()

template<typename T >
requires std::is_floating_point_v<T>

bool Harlinn::Common::Core::AreNearlyEqual ( T a, T b, T smallNumber = static_cast<T>( 0.0001 ) )

constexprnoexcept

BitsToBool()

template<typename BitsT >
requires std::is_integral_v<BitsT>

bool Harlinn::Common::Core::BitsToBool ( const BitsT bits, const UInt32 startIndex )

inlineconstexpr

Extracts the value of a bit at a bit index from an integer value.

Template Parameters

BitsT

A signed or unsigned integer type.

Parameters

bits	The integer value
startIndex	0 based index of the bit to extract, where 0 is the index of the least significant bit.

Returns

true if the bit was set, otherwise false.

BitsToByte()

template<typename BitsT >
requires std::is_integral_v<BitsT>

Byte Harlinn::Common::Core::BitsToByte ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToEnum()

template<typename ResultT , typename BitsT >
requires ( std::is_integral_v<BitsT> && std::is_enum_v<ResultT> )

ResultT Harlinn::Common::Core::BitsToEnum ( const BitsT bits, const UInt32 startIndex, const UInt32 bitCount )

inlineconstexpr

BitsToInt16()

template<typename BitsT >
requires std::is_integral_v<BitsT>

Int16 Harlinn::Common::Core::BitsToInt16 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToInt32()

template<typename BitsT >
requires std::is_integral_v<BitsT>

Int32 Harlinn::Common::Core::BitsToInt32 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToInt64()

template<typename BitsT >
requires std::is_integral_v<BitsT>

Int64 Harlinn::Common::Core::BitsToInt64 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToSByte()

template<typename BitsT >
requires std::is_integral_v<BitsT>

SByte Harlinn::Common::Core::BitsToSByte ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToSigned()

template<typename ResultT , typename BitsT >
requires ( std::is_integral_v<BitsT>&& std::is_integral_v<ResultT>&& std::is_signed_v<ResultT> )

ResultT Harlinn::Common::Core::BitsToSigned ( const BitsT bits, const UInt32 startIndex, const UInt32 bitCount )

inlineconstexpr

BitsToUInt16()

template<typename BitsT >
requires std::is_integral_v<BitsT>

UInt16 Harlinn::Common::Core::BitsToUInt16 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToUInt32()

template<typename BitsT >
requires std::is_integral_v<BitsT>

UInt32 Harlinn::Common::Core::BitsToUInt32 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToUInt64()

template<typename BitsT >
requires std::is_integral_v<BitsT>

UInt64 Harlinn::Common::Core::BitsToUInt64 ( const BitsT bits, UInt32 startIndex, UInt32 bitCount )

inlineconstexpr

BitsToUnsigned()

template<typename ResultT , typename BitsT >
requires ( std::is_integral_v<BitsT>&& std::is_integral_v<ResultT>&& std::is_unsigned_v<ResultT> )

ResultT Harlinn::Common::Core::BitsToUnsigned ( const BitsT bits, const UInt32 startIndex, const UInt32 bitCount )

inlineconstexpr

ByteArray()

template<typename ... Args>

Harlinn::Common::Core::ByteArray

(

Args...

)

-> ByteArray< Internal::_ByteSizeOf_v< Args... > >

ByteSwap() [1/7]

template<typename T >
requires IsGuid<T>

T Harlinn::Common::Core::ByteSwap ( const T & guid )

inlineconstexprnoexcept

Implements ByteSwap for a Guid.

Template Parameters

T	Must be Guid.

Parameters

guid	The Guid value.

Returns

A Guid with the bytes swapped for the Data1, Data2 and Data3 fields.

ByteSwap() [2/7]

template<typename T >
requires IsGUID<T>

T Harlinn::Common::Core::ByteSwap ( const T & guid )

inlineconstexprnoexcept

Swaps the bytes of the Data1, Data2 and Data3 fields of a Guid or GUID, while leaving Data4 as it is.

Template Parameters

T	Guid or GUID

Parameters

guid	A GUID type.

Returns

The GUID type with the bytes swapped.

ByteSwap() [3/7]

template<typename T >
requires IsCurrency<T>

T Harlinn::Common::Core::ByteSwap ( const T value )

inlineconstexprnoexcept

ByteSwap() [4/7]

template<typename T >
requires IsTimeSpan<T>

T Harlinn::Common::Core::ByteSwap ( const T value )

inlineconstexprnoexcept

ByteSwap() [5/7]

template<typename T >
requires IsDateTime<T>

T Harlinn::Common::Core::ByteSwap ( const T value )

inlineconstexprnoexcept

ByteSwap() [6/7]

template<typename T >
requires (IsFloatingPoint<std::remove_cvref_t<T>> || std::is_enum_v<std::remove_cvref_t<T>> )

T Harlinn::Common::Core::ByteSwap ( const T value )

inlineconstexprnoexcept

Reverses the bytes of a floating point value, or an enum.

Template Parameters

T	A floating point type, or an enum type.

Parameters

value

The value.

Returns

The result.

ByteSwap() [7/7]

template<typename T >
requires IsInteger<std::remove_cvref_t<T>>

T Harlinn::Common::Core::ByteSwap ( T value )

inlineconstexpr

CheckHRESULT() [1/4]

void Harlinn::Common::Core::CheckHRESULT

(

HRESULT

hresult

)

CheckHRESULT() [2/4]

void Harlinn::Common::Core::CheckHRESULT	(	HRESULT	hresult,
		const wchar_t *	function,
		const wchar_t *	filename,
		int	lineNumber )

CheckHRESULT() [3/4]

void Harlinn::Common::Core::CheckHRESULT	(	HRESULT	hresult,
		IUnknown *	itf )

CheckHRESULT() [4/4]

void Harlinn::Common::Core::CheckHRESULT	(	HRESULT	hresult,
		IUnknown *	itf,
		const wchar_t *	function,
		const wchar_t *	filename,
		int	lineNumber )

CheckPointerNotNull()

template<typename T >

void Harlinn::Common::Core::CheckPointerNotNull ( T * ptr )

inline

Compare() [1/15]

int Harlinn::Common::Core::Compare ( const char * s1, const char * s2 )

inlineconstexprnoexcept

Compare() [2/15]

int Harlinn::Common::Core::Compare ( const char * s1, nullptr_t s2 )

inlineconstexprnoexcept

Compare() [3/15]

template<typename FirstT , typename SecondT >
requires requires( FirstT f, SecondT s ) { { Compare( f, s ) } ->std::convertible_to<int>; }

int Harlinn::Common::Core::Compare ( const FirstT * first, size_t firstLength, const SecondT * second, size_t secondLength )

inline

Compare() [4/15]

template<typename FirstT , typename SecondT , typename ConversionFunc >
requires requires( FirstT f, SecondT s, ConversionFunc func ) { { Compare( f, s ) } ->std::convertible_to<int>; { func(s) } ->std::convertible_to<FirstT>; }

int Harlinn::Common::Core::Compare ( const FirstT * first, size_t firstLength, const SecondT * second, size_t secondLength, ConversionFunc converter )

inline

Compare() [5/15]

template<SimpleSpanLike T1, SimpleSpanLike T2>
requires (std::is_same_v< typename T1::value_type, typename T2::value_type > && ( IsBasicString<T1> == false ) )

int Harlinn::Common::Core::Compare ( const T1 & first, const T2 & second )

inline

Compare() [6/15]

template<SimpleSpanLike T1, SimpleSpanLike T2, typename ConversionFunc >

int Harlinn::Common::Core::Compare ( const T1 & first, const T2 & second, ConversionFunc converter )

inline

Compare() [7/15]

template<typename T1 , typename T2 >
requires ((std::is_same_v<Guid, std::remove_cvref_t<T1>> || std::is_same_v<GUID, std::remove_cvref_t<T1>> ) && ( std::is_same_v<Guid, std::remove_cvref_t<T2>> || std::is_same_v<GUID, std::remove_cvref_t<T2>> ) )

int Harlinn::Common::Core::Compare ( const T1 & v1, const T2 & v2 )

inlineconstexprnoexcept

Compare() [8/15]

template<typename T1 , typename T2 >
requires requires( const T1& t1, const T2& t2 ) { { t1.compare( t2 ) } ->std::convertible_to<int>; }

int Harlinn::Common::Core::Compare ( const T1 & v1, const T2 & v2 )

inlinenoexcept

Compare() [9/15]

int Harlinn::Common::Core::Compare ( const wchar_t * s1, const wchar_t * s2 )

inlineconstexprnoexcept

Compare() [10/15]

int Harlinn::Common::Core::Compare ( const wchar_t * s1, nullptr_t s2 )

inlineconstexprnoexcept

Compare() [11/15]

int Harlinn::Common::Core::Compare ( nullptr_t s1, const char * s2 )

inlineconstexprnoexcept

Compare() [12/15]

int Harlinn::Common::Core::Compare ( nullptr_t s1, const wchar_t * s2 )

inlineconstexprnoexcept

Compare() [13/15]

int Harlinn::Common::Core::Compare ( nullptr_t s1, nullptr_t s2 )

inlineconstexprnoexcept

Compare() [14/15]

template<typename T >
requires std::is_integral_v<T> || std::is_floating_point_v<T>

int Harlinn::Common::Core::Compare ( T v1, T v2 )

inlineconstexprnoexcept

Compare() [15/15]

template<typename T >
requires std::is_same_v<DateTime, std::remove_cvref_t<T>> || std::is_same_v<TimeSpan, std::remove_cvref_t<T>> || std::is_same_v<Currency, std::remove_cvref_t<T>>

int Harlinn::Common::Core::Compare ( T v1, T v2 )

inlineconstexprnoexcept

CompareEx()

template<typename FirstT , typename SecondT , typename CompareFunc >
requires requires( FirstT f, SecondT s, CompareFunc func ) { { func( f, s ) } ->std::convertible_to<int>; }

int Harlinn::Common::Core::CompareEx ( const FirstT * first, size_t firstLength, const SecondT * second, size_t secondLength, CompareFunc compare )

inline

ContainsAllOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT> && std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::Core::ContainsAllOf ( EnumT flags, Args &&... args )

constexpr

ContainsAnyOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::Core::ContainsAnyOf ( EnumT flags, Args ... args )

constexpr

ContainsNoneOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::Core::ContainsNoneOf ( EnumT flags, Args ... args )

constexpr

ConvertTo() [1/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inlineconstexpr

A ConvertTo template that performs no conversion since ResultType must be the same as ArgumentType.

Template Parameters

ResultType	The type to convert to.
ArgumentType	The type to convert from, must be of the same type as ResultType

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [2/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, double>&& std::is_same_v<ArgumentType, float> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inlineconstexpr

A ConvertTo template that performs conversion from float to double.

Template Parameters

ResultType	Must be double, the type to convert to.
ArgumentType	Must be float, the type to convert from.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [3/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, float>&& std::is_same_v<ArgumentType, double> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from double to float. Throws an ArgumentOutOfRangeException if the argument cannot safely be converted to a float.

Template Parameters

ResultType	Must be float, the type to convert to.
ArgumentType	Must be double, the type to convert from.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [4/35]

template<typename ResultType , typename ArgumentType >
requires (requires( ArgumentType a ) { { ToWideString( a ) } -> std::same_as<WideString>; } && IsWideString<ResultType> && std::is_same_v<Variant, ArgumentType> == false && std::is_same_v<Currency, ArgumentType> == false )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from any type for which there exists an overload of ToWideString, except for Variant and Currency, to WideString.

Template Parameters

ResultType	Must be WideString.
ArgumentType	Must be a type for which there exists an overload of ToWideString, except for Variant and Currency.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [5/35]

template<typename ResultType , typename ArgumentType >
requires ( requires( ArgumentType a ) { { ToAnsiString( a ) } -> std::same_as<AnsiString>; } && IsAnsiString<ResultType> && std::is_same_v<Variant, ArgumentType> == false && std::is_same_v<Currency, ArgumentType> == false )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from any type for which there exists an overload of ToAnsiString, except for Variant and Currency, to AnsiString.

Template Parameters

ResultType	Must be WideString.
ArgumentType	Must be a type for which there exists an overload of ToAnsiString, except for Variant and Currency.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [6/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, bool> && std::is_arithmetic_v<ArgumentType> && IsNotBoolean<ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inlineconstexpr

A ConvertTo template that performs conversion from an integer or floating point type, but not bool, to a bool.

Template Parameters

ResultType	Must be bool.
ArgumentType	Must be an integer or floating point type, but not bool.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [7/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ArgumentType, bool> && std::is_arithmetic_v<ResultType> && IsNotBoolean<ResultType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inlineconstexpr

A ConvertTo template that performs conversion from a bool to an integer or floating point type, but not a bool type.

Template Parameters

ResultType	Must be an integer or floating point type, but not bool.
ArgumentType	Must be bool.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [8/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, bool> && ( std::is_same_v<DateTime, ArgumentType> || std::is_same_v<TimeSpan, ArgumentType> ) )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inlineconstexpr

A ConvertTo template that performs conversion from a DateTime or TimeSpan to a bool.

Template Parameters

ResultType	Must be bool.
ArgumentType	Must be DateTime or TimeSpan.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [9/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, bool> && std::is_same_v<Guid, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a Guid to a bool.

Template Parameters

ResultType	Must be bool.
ArgumentType	Must be Guid.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [10/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<ResultType, bool> && std::is_same_v<Currency, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a Currency to a bool.

Template Parameters

ResultType	Must be bool.
ArgumentType	Must be Currency.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [11/35]

template<typename ResultType , typename ArgumentType >
requires ( std::is_same_v<Variant, ArgumentType> && std::is_same_v <Variant,ResultType> == false ) && requires ( Variant v ) { { v.As<ResultType>( ) }->std::same_as<ResultType>; }

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a Variant to a type for Which there exist a specialization of Variant::As<ResultType>.

Template Parameters

ResultType	Must not be a Variant, and it must be a type for Which there exist a specialization of Variant::As<ResultType>.
ArgumentType	Must be Variant.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [12/35]

template<typename ResultType , typename ArgumentType >
requires ( ((IsSignedInteger<ResultType> && IsSignedInteger<ArgumentType>) || ( IsUnsignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> ) ) && size_is_less< ResultType, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a narrowing conversion from an integer type to another.

Template Parameters

ResultType	Must be a smaller integer type than ArgumentType.
ArgumentType	Must be a wider integer type than ResultType.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [13/35]

template<typename ResultType , typename ArgumentType >
requires ( ((IsSignedInteger<ResultType> && IsSignedInteger<ArgumentType>) || ( IsUnsignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> ) ) && size_is_greater_or_equal< ResultType, ArgumentType> && std::is_same_v<ResultType, ArgumentType> == false )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a widening conversion from an integer type to another integer type with the same signedness.

Template Parameters

ResultType	Must be an integer type that is wider or equally sized to ArgumentType with the same signedness..
ArgumentType	Must be an integer type that is narrower or equally sized to ArgumentType with the same signedness.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [14/35]

template<typename ResultType , typename ArgumentType >
requires ( IsSignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> && size_is_less_or_equal< ResultType, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a narrowing conversion from an unsigned integer type to a signed integer type.

Template Parameters

ResultType	Must be a signed integer type that is narrower or equally sized to ArgumentType.
ArgumentType	Must be a unsigned integer type that is wider or equally sized to ResultType.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [15/35]

template<typename ResultType , typename ArgumentType >
requires ( IsSignedInteger<ResultType> && IsUnsignedInteger<ArgumentType> && size_is_greater< ResultType, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a widening conversion from an unsigned integer type to a signed integer type.

Template Parameters

ResultType	Must be a signed integer type that is wider than ArgumentType.
ArgumentType	Must be an unsigned integer type that is narrower than ResultType.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [16/35]

template<typename ResultType , typename ArgumentType >
requires ( IsUnsignedInteger<ResultType> && IsSignedInteger<ArgumentType> && size_is_less< ResultType, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a narrowing conversion from a signed integer type to an unsigned integer type.

Template Parameters

ResultType	Must be an unsigned integer type that is narrower than ArgumentType.
ArgumentType	Must be a signed integer type that is wider than ResultType.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [17/35]

template<typename ResultType , typename ArgumentType >
requires ( IsUnsignedInteger<ResultType> && IsSignedInteger<ArgumentType> && size_is_greater_or_equal< ResultType, ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs a widening conversion from a signed integer type to an unsigned integer type.

Template Parameters

ResultType	Must be an unsigned integer type that is wider or equally sized to ArgumentType.
ArgumentType	Must be a signed integer type that is narrower or equally sized to ResultType.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [18/35]

template<typename ResultType , typename ArgumentType >
requires IsInteger<ResultType> && IsFloatingPoint<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a floating point type to an integer type.

Template Parameters

ResultType	Must be an integer.
ArgumentType	Must be a floating point type.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [19/35]

template<typename ResultType , typename ArgumentType >
requires (IsInteger<ResultType> || IsFloatingPoint<ResultType> || IsAnsiString<ResultType> || IsWideString<ResultType> ) && std::is_same_v<ArgumentType,Currency>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a Currency value to an integer, floating point, AnsiString or WideString type.

Template Parameters

ResultType	Must be an integer, floating point, AnsiString or WideString type.
ArgumentType	Must be Currency.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [20/35]

template<typename ResultType , typename ArgumentType >
requires IsInteger<ResultType> && IsAnyOf_v<ArgumentType,DateTime, TimeSpan>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a DateTime or TimeSpan value to an integer type.

Template Parameters

ResultType	Must be an integer type.
ArgumentType	Must DateTime or TimeSpan.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [21/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, TimeSpan> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*>)

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a c style zero terminated string value to a TimeSpan.

Template Parameters

ResultType	Must be TimeSpan.
ArgumentType	Must be convertible to const char* or const wchar_t*.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [22/35]

template<typename ResultType , SimpleStringLike ArgumentType>
requires std::is_same_v<ResultType, TimeSpan>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a type that matches the SimpleStringLike concept to a TimeSpan.

Template Parameters

ResultType	Must be TimeSpan.
ArgumentType	Must be a type that matches the SimpleStringLike concept.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [23/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, TimeSpan> && IsFloatingPoint<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a TimeSpan to a floating point type.

Template Parameters

ResultType	Must be a floating point type.
ArgumentType	Must be TimeSpan.

Parameters

arg	The value to convert.

Returns

The converted value in number of days.

ConvertTo() [24/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, TimeSpan> && std::is_same_v<ArgumentType,Currency>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a Currency value to a TimeSpan value.

Template Parameters

ResultType	Must be TimeSpan.
ArgumentType	Must be Currency.

Parameters

arg	The value to convert in number of days.

Returns

The converted value.

ConvertTo() [25/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, DateTime>&& IsInteger<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from an integer type to a DateTime value.

Template Parameters

ResultType	Must be DateTime.
ArgumentType	Must be an integer type.

Parameters

arg	The value to convert in ticks.

Returns

The converted value.

ConvertTo() [26/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, TimeSpan>&& IsInteger<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from an integer type to a TimeSpan value.

Template Parameters

ResultType	Must be TimeSpan.
ArgumentType	Must be an integer type.

Parameters

arg	The value to convert in ticks.

Returns

The converted value.

ConvertTo() [27/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, DateTime> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*>)

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a c style zero terminated string value to a DateTime.

Template Parameters

ResultType	Must be DateTime.
ArgumentType	Must be convertible to const char* or const wchar_t*.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [28/35]

template<typename ResultType , SimpleStringLike ArgumentType>
requires std::is_same_v<ResultType, DateTime>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a type that matches the SimpleStringLike concept to a DateTime.

Template Parameters

ResultType	Must be DateTime.
ArgumentType	Must be a type that matches the SimpleStringLike concept.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [29/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, DateTime> && IsFloatingPoint<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a floating point type to a DateTime value.

Template Parameters

ResultType	Must be DateTime.
ArgumentType	Must be a floating point type.

Parameters

arg	The value to convert in number of days before or after midnight, 30 December 1899.

Returns

The converted value.

ConvertTo() [30/35]

template<typename ResultType , typename ArgumentType >
requires IsFloatingPoint<ResultType> && std::is_same_v<ArgumentType, DateTime>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a DateTime value to a floating point type.

Template Parameters

ResultType	Must be a floating point type.
ArgumentType	Must be DateTime.

Parameters

arg	The value to convert.

Returns

The converted value in number of days before or after midnight, 30 December 1899.

ConvertTo() [31/35]

template<typename ResultType , typename ArgumentType >
requires IsFloatingPoint<ResultType> && std::is_same_v<ArgumentType, TimeSpan>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a TimeSpan value to a floating point type.

Template Parameters

ResultType	Must be a floating point type.
ArgumentType	Must be TimeSpan.

Parameters

arg	The value to convert.

Returns

The converted value in number of days.

ConvertTo() [32/35]

template<typename ResultType , typename ArgumentType >
requires (std::is_same_v<ResultType, TimeSpan>&& std::is_same_v<ArgumentType, DateTime>) || ( std::is_same_v<ResultType, DateTime> && std::is_same_v<ArgumentType, TimeSpan> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a TimeSpan value to DataTime value, or a conversion from a DataTime value to TimeSpan value.

Template Parameters

ResultType	Must be TimeSpan if ArgumentType is DataTime, or DataTime if ArgumentType is TimeSpan.
ArgumentType	Must be TimeSpan if ResultType is DataTime, or DataTime if ResultType is TimeSpan.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [33/35]

template<typename ResultType , typename ArgumentType >
requires std::is_same_v<ResultType, Guid> && (std::is_nothrow_convertible_v< ArgumentType, const wchar_t*> || std::is_nothrow_convertible_v< ArgumentType, const char*> || SimpleStringLike<ArgumentType> )

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from a c style zero terminated string value, or a type that matches the SimpleStringLike concept, to a Guid.

Template Parameters

ResultType	Must be Guid.
ArgumentType	Must be convertible to const char* or const wchar_t*, or a type that matches the SimpleStringLike concept.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [34/35]

template<typename ResultType , typename ArgumentType >
requires IsFloatingPoint<ResultType> && IsInteger<ArgumentType>

ResultType Harlinn::Common::Core::ConvertTo ( ArgumentType arg )

inline

A ConvertTo template that performs conversion from an integer to a floating point value.

Template Parameters

ResultType	Must be floating point type.
ArgumentType	Must be an integer type.

Parameters

arg	The value to convert.

Returns

The converted value.

ConvertTo() [35/35]

template<typename ResultType , SimpleStringLike ArgumentType>
requires requires( const ArgumentType& a ) { { Parse<ResultType>( a ) }->std::same_as<ResultType>; }

ResultType Harlinn::Common::Core::ConvertTo ( const ArgumentType & arg )

inline

A ConvertTo template that performs conversion from a type that satisfies the SimpleStringLike concept to a type for which there exist a Parse<> specialization that accepts the argument type.

Template Parameters

ResultType	A type for which there exist a Parse<> specialization that accepts the argument type.
ArgumentType	A type that satisfies the SimpleStringLike concept.

Parameters

arg	The value to convert.

Returns

The converted value.

crc24q()

UInt32 Harlinn::Common::Core::crc24q ( const uint8_t * input, size_t length, UInt32 crc = 0 )

inlineconstexpr

crc32()

uint32_t Harlinn::Common::Core::crc32	(	const void *	buffer,
		size_t	bufferSize,
		uint32_t	crc = 0 )

crc32c()

uint32_t Harlinn::Common::Core::crc32c	(	const uint8_t *	input,
		size_t	length,
		uint32_t	crc = 0 )

crc32c_hw()

uint32_t Harlinn::Common::Core::crc32c_hw	(	const uint8_t *	input,
		size_t	length,
		uint32_t	crc = 0 )

crc32c_hw_available()

int Harlinn::Common::Core::crc32c_hw_available

(

)

crc32c_init()

void Harlinn::Common::Core::crc32c_init

(

)

crc32c_sw()

uint32_t Harlinn::Common::Core::crc32c_sw	(	const uint8_t *	input,
		size_t	length,
		uint32_t	crc = 0 )

CreateBitMask32()

UInt32 Harlinn::Common::Core::CreateBitMask32 ( unsigned numberOfBitsToSet )

inlineconstexprnoexcept

Creates a bit-mask with all the bits - up to, and including, the bit at bitIndex.

• set.

Parameters

bitIndex

The number of bits to set. The value of numberOfBitsToSet must be in the range [1,32]

Returns

The generated bit-mask

CreateBitMask64()

UInt64 Harlinn::Common::Core::CreateBitMask64 ( unsigned numberOfBitsToSet )

inlineconstexprnoexcept

Creates a bit-mask.

Parameters

bitIndex

The number of bits to set. The value of numberOfBitsToSet must be in the range [1,64]

Returns

The generated bit-mask

EndsWith()

template<SimpleCharSpanLike SpanT>

bool Harlinn::Common::Core::EndsWith ( const SpanT & span, typename SpanT::value_type value )

inline

Exponent() [1/2]

int Harlinn::Common::Core::Exponent ( double value )

inlineconstexprnoexcept

Exponent() [2/2]

int Harlinn::Common::Core::Exponent ( float v )

inlineconstexprnoexcept

ExtractBits32()

UInt32 Harlinn::Common::Core::ExtractBits32 ( UInt32 value, UInt32 start, UInt32 len )

inlineconstexprnoexcept

Extracts contiguous bits from value.

Parameters

value
start	0 based index of the least significant bit to extract.
len	Number of bits to extract,

Returns

the extracted bits, with the first extracted bit at position 0, the least significant bit in the returned value.

ExtractBits64()

UInt64 Harlinn::Common::Core::ExtractBits64 ( UInt64 value, UInt32 start, UInt32 len )

inlineconstexprnoexcept

Extracts contiguous bits from value.

Parameters

value
start	0 based index of the least significant bit to extract.
len	Number of bits to extract,

Returns

the extracted bits, with the first extracted bit at position 0, the least significant bit in the returned value.

FlipSign() [1/2]

double Harlinn::Common::Core::FlipSign ( double a, double b )

inlineconstexpr

FlipSign() [2/2]

float Harlinn::Common::Core::FlipSign ( float a, float b )

inlineconstexpr

Format() [1/4]

template<class... Types>

AnsiString Harlinn::Common::Core::Format ( const std::format_string< Types... > fmt, Types &&... args )

inlinenodiscard

Format() [2/4]

template<class... Types>

AnsiString Harlinn::Common::Core::Format ( const std::locale & locale, const std::format_string< Types... > fmt, Types &&... args )

inlinenodiscard

Format() [3/4]

template<class... Types>

WideString Harlinn::Common::Core::Format ( const std::locale & locale, const std::wformat_string< Types... > fmt, Types &&... args )

inlinenodiscard

Format() [4/4]

template<class... Types>

WideString Harlinn::Common::Core::Format ( const std::wformat_string< Types... > fmt, Types &&... args )

inlinenodiscard

FormatError()

WideString Harlinn::Common::Core::FormatError

(

DWORD

errorId

)

FormatErrorA()

AnsiString Harlinn::Common::Core::FormatErrorA

(

DWORD

errorId

)

FormatV() [1/4]

AnsiString Harlinn::Common::Core::FormatV ( const std::locale & locale, const std::string_view fmt, const std::format_args args )

inlinenodiscard

FormatV() [2/4]

WideString Harlinn::Common::Core::FormatV ( const std::locale & locale, const std::wstring_view fmt, const std::wformat_args args )

inlinenodiscard

FormatV() [3/4]

AnsiString Harlinn::Common::Core::FormatV ( const std::string_view fmt, const std::format_args args )

inlinenodiscard

FormatV() [4/4]

WideString Harlinn::Common::Core::FormatV ( const std::wstring_view fmt, const std::wformat_args args )

inlinenodiscard

ForwardAsTuple()

template<class... Args>

Tuple< Args &&... > Harlinn::Common::Core::ForwardAsTuple ( Args &&... args )

nodiscardconstexprnoexcept

From32BitsTo64Bits()

template<typename T1 , typename T2 , typename T3 >
requires ( sizeof( T1 ) == 8 ) && ( std::is_same_v<Int32, T2> || std::is_same_v<UInt32, T2> ) && ( std::is_same_v<Int32, T3> || std::is_same_v<UInt32, T3> ) && requires( UInt64 v1 ) { { std::bit_cast<T1>( v1 ) }->std::same_as<T1>; }

T1 Harlinn::Common::Core::From32BitsTo64Bits ( T2 high32Bits, T3 low32Bits )

inlineconstexprnoexcept

get() [1/4]

template<std::size_t index, typename... Args>

const TupleElement_t< index, Args... > && Harlinn::Common::Core::get ( const Tuple< Args... > && tuple )

constexpr

get() [2/4]

template<std::size_t index, typename... Args>

const TupleElement_t< index, Args... > & Harlinn::Common::Core::get ( const Tuple< Args... > & tuple )

constexpr

get() [3/4]

template<std::size_t index, typename... Args>

TupleElement_t< index, Args... > && Harlinn::Common::Core::get ( Tuple< Args... > && tuple )

constexpr

get() [4/4]

template<std::size_t index, typename... Args>

TupleElement_t< index, Args... > & Harlinn::Common::Core::get ( Tuple< Args... > & tuple )

constexpr

GetFileAccess()

HCC_EXPORT IO::FileAccess Harlinn::Common::Core::GetFileAccess

(

MemoryMappedFileAccess

access

)

GetFileMapAccess()

HCC_EXPORT DWORD Harlinn::Common::Core::GetFileMapAccess

(

MemoryMappedFileAccess

access

)

GetFileSystemRights()

HCC_EXPORT IO::FileSystemRights Harlinn::Common::Core::GetFileSystemRights

(

MemoryMappedFileAccess

access

)

GetHigh32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }

T1 Harlinn::Common::Core::GetHigh32Bits ( T2 val )

inlineconstexprnoexcept

GetLow32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }

T1 Harlinn::Common::Core::GetLow32Bits ( T2 val )

inlineconstexprnoexcept

GetPageAccess()

PageFlags Harlinn::Common::Core::GetPageAccess ( MemoryMappedFileAccess access )

inline

GetPageFlags()

HCC_EXPORT PageFlags Harlinn::Common::Core::GetPageFlags

(

MemoryMappedFileAccess

access

)

GrayDecode() [1/2]

template<typename T >
requires ( std::is_integral_v<T>&& std::is_unsigned_v<T> )

T Harlinn::Common::Core::GrayDecode ( T value )

inlineconstexpr

GrayDecode() [2/2]

template<typename T >
requires ( std::is_integral_v<T>&& std::is_signed_v<T> )

T Harlinn::Common::Core::GrayDecode ( T value )

inlineconstexpr

GrayEncode() [1/2]

template<typename T >
requires (std::is_integral_v<T> && std::is_unsigned_v<T>)

T Harlinn::Common::Core::GrayEncode ( T value )

inlineconstexpr

GrayEncode() [2/2]

template<typename T >
requires ( std::is_integral_v<T>&& std::is_signed_v<T> )

T Harlinn::Common::Core::GrayEncode ( T value )

inlineconstexpr

HCC_DEFINE_ENUM_FLAG_OPERATORS() [1/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	DropEffect	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [2/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	EventWaitHandleRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [3/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	FileMap	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [4/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	MarshalFlags	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [5/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	MemoryMappedFileOptions	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [6/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	MemoryMappedFileRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [7/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	MutexRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [8/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	PageFlags	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [9/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	ProcessAccessRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [10/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	SectionFlags	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [11/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	SemaphoreRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [12/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	SynchronizationBarrierFlags	,
		UInt32	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [13/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	ThreadAccessRights	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [14/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	ThreadModel	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [15/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	TimerQueueTimerFlags	,
		DWORD	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [16/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	VariantType	,
		unsigned short	)

HCC_DEFINE_ENUM_FLAG_OPERATORS() [17/17]

Harlinn::Common::Core::HCC_DEFINE_ENUM_FLAG_OPERATORS	(	WaitableTimerRights	,
		DWORD	)

HexToBinary() [1/2]

template<typename CharType >

bool Harlinn::Common::Core::HexToBinary	(	CharType	c,
		Byte &	result )

HexToBinary() [2/2]

template<typename CharType >

bool Harlinn::Common::Core::HexToBinary ( const CharType * text, size_t textLength, std::vector< Byte > & result )

inline

HRESULTFromException()

HRESULT Harlinn::Common::Core::HRESULTFromException

(

const std::exception &

exception

)

IndexOfBitFromMSB()

template<typename T >
requires std::is_integral_v<T>

bool Harlinn::Common::Core::IndexOfBitFromMSB ( unsigned long * index, T bits )

constexpr

IsAlnum() [1/2]

bool Harlinn::Common::Core::IsAlnum ( char c )

inline

IsAlnum() [2/2]

bool Harlinn::Common::Core::IsAlnum ( wchar_t c )

inline

IsAlpha() [1/2]

bool Harlinn::Common::Core::IsAlpha ( char c )

inline

IsAlpha() [2/2]

bool Harlinn::Common::Core::IsAlpha ( wchar_t c )

inline

IsBlank() [1/2]

bool Harlinn::Common::Core::IsBlank ( char c )

inline

IsBlank() [2/2]

bool Harlinn::Common::Core::IsBlank ( wchar_t c )

inline

IsCntrl() [1/2]

bool Harlinn::Common::Core::IsCntrl ( char c )

inline

IsCntrl() [2/2]

bool Harlinn::Common::Core::IsCntrl ( wchar_t c )

inline

IsDigit() [1/2]

bool Harlinn::Common::Core::IsDigit ( char c )

inline

IsDigit() [2/2]

bool Harlinn::Common::Core::IsDigit ( wchar_t c )

inline

IsGraph() [1/2]

bool Harlinn::Common::Core::IsGraph ( char c )

inline

IsGraph() [2/2]

bool Harlinn::Common::Core::IsGraph ( wchar_t c )

inline

IsLower() [1/2]

bool Harlinn::Common::Core::IsLower ( char c )

inline

IsLower() [2/2]

bool Harlinn::Common::Core::IsLower ( wchar_t c )

inline

IsNotSet()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::Core::IsNotSet ( EnumT flags, Args ... args )

constexpr

IsPowerOf2() [1/2]

template<typename T >
requires IsInteger<T>

bool Harlinn::Common::Core::IsPowerOf2 ( T v )

inlineconstexprnoexcept

IsPowerOf2() [2/2]

template<typename T >
requires std::is_enum_v<std::remove_cvref_t<T>>

bool Harlinn::Common::Core::IsPowerOf2 ( T v )

inlineconstexprnoexcept

IsPowerOfTwo() [1/2]

template<typename T >
requires IsInteger<T>

bool Harlinn::Common::Core::IsPowerOfTwo ( T v )

inlineconstexprnoexcept

IsPowerOfTwo() [2/2]

template<typename T >
requires std::is_enum_v<std::remove_cvref_t<T>>

bool Harlinn::Common::Core::IsPowerOfTwo ( T v )

inlineconstexprnoexcept

IsPrint() [1/2]

bool Harlinn::Common::Core::IsPrint ( char c )

inline

IsPrint() [2/2]

bool Harlinn::Common::Core::IsPrint ( wchar_t c )

inline

IsPunct() [1/2]

bool Harlinn::Common::Core::IsPunct ( char c )

inline

IsPunct() [2/2]

bool Harlinn::Common::Core::IsPunct ( wchar_t c )

inline

IsSet()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT> && std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::Core::IsSet ( EnumT flags, Args &&... args )

constexpr

IsSpace() [1/2]

bool Harlinn::Common::Core::IsSpace ( char c )

inline

IsSpace() [2/2]

bool Harlinn::Common::Core::IsSpace ( wchar_t c )

inline

IsUpper() [1/2]

bool Harlinn::Common::Core::IsUpper ( char c )

inline

IsUpper() [2/2]

bool Harlinn::Common::Core::IsUpper ( wchar_t c )

inline

IsXDigit() [1/2]

bool Harlinn::Common::Core::IsXDigit ( char c )

inline

IsXDigit() [2/2]

bool Harlinn::Common::Core::IsXDigit ( wchar_t c )

inline

LengthOf() [1/3]

template<typename T >
requires requires( T container ) { { container.size( ) } -> std::convertible_to<size_t>; }

size_t Harlinn::Common::Core::LengthOf ( const T & container )

inlinenodiscardconstexprnoexcept

LengthOf() [2/3]

template<typename T >
requires std::is_same_v<T,char> || std::is_same_v<T, wchar_t>

size_t Harlinn::Common::Core::LengthOf ( const T * str )

inlinenodiscardconstexprnoexcept

LengthOf() [3/3]

template<typename T , size_t N>
requires ( std::is_same_v<char,std::remove_cv_t<T>> == false && std::is_same_v<wchar_t, std::remove_cv_t<T>> == false )

size_t Harlinn::Common::Core::LengthOf ( T(&) array[N] )

inlinenodiscardconstexprnoexcept

LogStackTrace()

void Harlinn::Common::Core::LogStackTrace

(

)

MakeReferenceCounted()

template<SimpleComLike T, typename... Args>

ReferenceCountedPtr< T > Harlinn::Common::Core::MakeReferenceCounted ( Args &&... args )

inline

MakeTuple()

template<class... Args>

Tuple< Internal::ToReferenceIfReferenceWrapper_t< Args >... > Harlinn::Common::Core::MakeTuple ( Args &&... args )

nodiscardconstexpr

Creates a Tuple from the arguments.

MaskLeadingOnes()

template<typename T , size_t N>
requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::Core::MaskLeadingOnes ( )

constexpr

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

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to set.

Returns

The bitmask.

MaskLeadingZeros()

template<typename T , size_t N>
requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::Core::MaskLeadingZeros ( )

constexpr

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

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to clear.

Returns

The bitmask.

MaskTrailingOnes()

template<typename T , size_t N>
requires IsUnsignedInteger<T> && (N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::Core::MaskTrailingOnes ( )

constexpr

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

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to set.

Returns

The bitmask.

MaskTrailingZeros()

template<typename T , size_t N>
requires IsUnsignedInteger<T> && ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::Core::MaskTrailingZeros ( )

constexpr

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

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to clear.

Returns

The bitmask.

MemChr() [1/4]

char * Harlinn::Common::Core::MemChr ( char * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemChr() [2/4]

const char * Harlinn::Common::Core::MemChr ( const char * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemChr() [3/4]

const wchar_t * Harlinn::Common::Core::MemChr ( const wchar_t * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemChr() [4/4]

wchar_t * Harlinn::Common::Core::MemChr ( wchar_t * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemCmp() [1/2]

int Harlinn::Common::Core::MemCmp ( const char * first, const char * second, size_t length )

inlinenodiscard

MemCmp() [2/2]

int Harlinn::Common::Core::MemCmp ( const wchar_t * first, const wchar_t * second, size_t length )

inlinenodiscard

MemCopy() [1/2]

void Harlinn::Common::Core::MemCopy ( char * dest, const char * source, size_t length )

inlinenoexcept

MemCopy() [2/2]

void Harlinn::Common::Core::MemCopy ( wchar_t * dest, const wchar_t * source, size_t length )

inlinenoexcept

MemIChr() [1/4]

char * Harlinn::Common::Core::MemIChr ( char * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemIChr() [2/4]

const char * Harlinn::Common::Core::MemIChr ( const char * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemIChr() [3/4]

const wchar_t * Harlinn::Common::Core::MemIChr ( const wchar_t * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemIChr() [4/4]

wchar_t * Harlinn::Common::Core::MemIChr ( wchar_t * buffer, int value, size_t bufferSize )

inlinenodiscardnoexcept

MemMove() [1/2]

void Harlinn::Common::Core::MemMove ( char * dest, const char * source, size_t length )

inlinenoexcept

MemMove() [2/2]

void Harlinn::Common::Core::MemMove ( wchar_t * dest, const wchar_t * source, size_t length )

inlinenoexcept

MemSet() [1/2]

void Harlinn::Common::Core::MemSet ( char * dest, char value, size_t length )

inlinenoexcept

MemSet() [2/2]

void Harlinn::Common::Core::MemSet ( wchar_t * dest, wchar_t value, size_t length )

inlinenoexcept

NextPowerOfTwo() [1/8]

Byte Harlinn::Common::Core::NextPowerOfTwo ( Byte v )

inlineconstexprnoexcept

NextPowerOfTwo() [2/8]

Int16 Harlinn::Common::Core::NextPowerOfTwo ( Int16 v )

inlineconstexprnoexcept

NextPowerOfTwo() [3/8]

Int32 Harlinn::Common::Core::NextPowerOfTwo ( Int32 v )

inlineconstexprnoexcept

NextPowerOfTwo() [4/8]

Int64 Harlinn::Common::Core::NextPowerOfTwo ( Int64 v )

inlineconstexprnoexcept

NextPowerOfTwo() [5/8]

SByte Harlinn::Common::Core::NextPowerOfTwo ( SByte v )

inlineconstexprnoexcept

NextPowerOfTwo() [6/8]

UInt16 Harlinn::Common::Core::NextPowerOfTwo ( UInt16 v )

inlineconstexprnoexcept

NextPowerOfTwo() [7/8]

UInt32 Harlinn::Common::Core::NextPowerOfTwo ( UInt32 v )

inlineconstexprnoexcept

NextPowerOfTwo() [8/8]

UInt64 Harlinn::Common::Core::NextPowerOfTwo ( UInt64 v )

inlineconstexprnoexcept

operator""_gb()

unsigned long long Harlinn::Common::Core::operator""_gb ( unsigned long long value )

constexpr

operator""_kb()

unsigned long long Harlinn::Common::Core::operator""_kb ( unsigned long long value )

constexpr

operator""_mb()

unsigned long long Harlinn::Common::Core::operator""_mb ( unsigned long long value )

constexpr

operator&() [1/2]

template<size_t N>

Bits< N > Harlinn::Common::Core::operator& ( const Bits< N > & lhs, const Bits< N > & rhs )

constexprnoexcept

operator&() [2/2]

template<typename VectorT , typename VectorU >

Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type Harlinn::Common::Core::operator& ( const BitVector< VectorT > & lhs, const BitVector< VectorU > & rhs )

inline

operator+()

template<typename T , size_t N1, size_t N2>

std::array< T, N1+N2 > Harlinn::Common::Core::operator+ ( const std::array< T, N1 > & lhs, const std::array< T, N2 > & rhs )

inlineconstexprnoexcept

Concatenation of arrays.

Template Parameters

T	The element type
N1	The size of the lhs array
N2	The size of the rhs array

Parameters

lhs	The first array.
rhs	The second array.

Returns

An array containing the data from the first array and second array. The data from the second array is appended to the data from the first array.

operator<<() [1/5]

template<typename T , size_t N>
requires std::is_integral_v<T>

Bits< N > Harlinn::Common::Core::operator<< ( const Bits< N > & lhs, const T & rhs )

constexprnoexcept

operator<<() [2/5]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & Harlinn::Common::Core::operator<< ( std::basic_ostream< CharT, Traits > & os, const BasicString< CharT > & str )

inline

operator<<() [3/5]

std::ostream & Harlinn::Common::Core::operator<<	(	std::ostream &	stream,
		const DateTime &	dateTime )

operator<<() [4/5]

HCC_EXPORT std::ostream & Harlinn::Common::Core::operator<<	(	std::ostream &	stream,
		const Guid &	guid )

operator<<() [5/5]

HCC_EXPORT std::ostream & Harlinn::Common::Core::operator<<	(	std::ostream &	stream,
		const TimeSpan &	timeSpan )

operator>>() [1/2]

template<typename T , size_t N>
requires std::is_integral_v<T>

Bits< N > Harlinn::Common::Core::operator>> ( const Bits< N > & lhs, const T & rhs )

constexprnoexcept

operator>>() [2/2]

template<class CharT , class CharTraitsT >

std::basic_istream< CharT, CharTraitsT > & Harlinn::Common::Core::operator>>	(	std::basic_istream< CharT, CharTraitsT > &	inputStream,
		BasicString< CharT > &	str )

operator^() [1/2]

template<size_t N>

Bits< N > Harlinn::Common::Core::operator^ ( const Bits< N > & lhs, const Bits< N > & rhs )

constexprnoexcept

operator^() [2/2]

template<typename VectorT , typename VectorU >

Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type Harlinn::Common::Core::operator^ ( const BitVector< VectorT > & lhs, const BitVector< VectorU > & rhs )

inline

operator|() [1/2]

template<size_t N>

Bits< N > Harlinn::Common::Core::operator| ( const Bits< N > & lhs, const Bits< N > & rhs )

constexprnoexcept

operator|() [2/2]

template<typename VectorT , typename VectorU >

Core::Internal::BitVectorLogicalResult< BitVector< VectorT >, BitVector< VectorU > >::type Harlinn::Common::Core::operator| ( const BitVector< VectorT > & lhs, const BitVector< VectorU > & rhs )

inline

Parse() [1/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::MemberKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [2/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxGraphRelation, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [3/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxRefKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [4/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxMemberKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [5/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxProtectionKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [6/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxRefQualifierKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [7/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxLanguage, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [8/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxVirtualKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [9/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxCompoundKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [10/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxSectionKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [11/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxHighlightClass, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [12/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxSimpleSectKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [13/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxCheck, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [14/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxImageKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [15/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxPlantumlEngine, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [16/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxParamListKind, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [17/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxParamDir, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [18/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxAccessor, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [19/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxAlign, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [20/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxVerticalAlign, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [21/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxOlType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [22/136]

template<typename T , typename CharT >
requires std::is_same_v<Doxygen::DoxCmdGroupType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [23/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::ColumnType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [24/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::ColumnFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [25/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::IndexFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [26/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::RetrieveFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [27/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::SetFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [28/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::ColumnInfoLevel, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [29/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::PrepareUpdateOptions, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [30/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::KeyFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [31/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::SeekFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [32/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::IndexRangeFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [33/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::SetCurrentIndexFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [34/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::TableOptions, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [35/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::ObjectFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [36/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::SequentialFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [37/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::ExceptionAction, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [38/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::OpenTableFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [39/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::TransactionFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [40/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::AttachDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [41/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::DetachDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [42/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::CreateDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [43/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::OpenDatabaseFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [44/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::InitFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [45/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::OnlineDefragFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [46/136]

template<typename T , typename CharT >
requires std::is_same_v<Ese::BackupFlags, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [47/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceAccessRights, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [48/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceControlManagerAccessRights, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [49/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [50/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceStartType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [51/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceEnumerationState, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [52/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceState, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [53/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceControl, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [54/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::ServiceControlAccepted, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [55/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::DeviceEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [56/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::HardwareProfileChangeEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [57/136]

template<typename T , typename CharT >
requires std::is_same_v<Services::PowerEventType, T> && ( std::is_same_v<CharT, wchar_t> || std::is_same_v<CharT, char> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [58/136]

template<typename T , typename CharT >
requires std::is_same_v<bool,T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [59/136]

template<typename T , typename CharT >
requires std::is_same_v<float, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [60/136]

template<typename T , typename CharT >
requires std::is_same_v<double, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str )

inline

Parse() [61/136]

template<typename T , typename CharT >
requires std::is_same_v<Byte, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [62/136]

template<typename T , typename CharT >
requires std::is_same_v<SByte, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [63/136]

template<typename T , typename CharT >
requires std::is_same_v<Int16, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [64/136]

template<typename T , typename CharT >
requires std::is_same_v<UInt16, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [65/136]

template<typename T , typename CharT >
requires std::is_same_v<Int32, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [66/136]

template<typename T , typename CharT >
requires std::is_same_v<UInt32, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [67/136]

template<typename T , typename CharT >
requires std::is_same_v<Int64, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [68/136]

template<typename T , typename CharT >
requires std::is_same_v<UInt64, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::Parse ( const CharT * str, int radix = 10 )

inline

Parse() [69/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::MemberKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [70/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxGraphRelation, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [71/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxRefKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [72/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxMemberKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [73/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxProtectionKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [74/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxRefQualifierKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [75/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxLanguage, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [76/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxVirtualKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [77/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxCompoundKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [78/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxSectionKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [79/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxHighlightClass, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [80/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxSimpleSectKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [81/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxCheck, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [82/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxImageKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [83/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxPlantumlEngine, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [84/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxParamListKind, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [85/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxParamDir, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [86/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxAccessor, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [87/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxAlign, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [88/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxVerticalAlign, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [89/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxOlType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [90/136]

template<typename T , typename StringT >
requires std::is_same_v<Doxygen::DoxCmdGroupType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [91/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<bool, T>

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [92/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<float, T>

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [93/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<double, T>

T Harlinn::Common::Core::Parse ( const StringT & str )

inline

Parse() [94/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<Byte, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [95/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<SByte, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [96/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<Int16, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [97/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<UInt16, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [98/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<Int32, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [99/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<UInt32, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [100/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<Int64, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [101/136]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<UInt64, T>

T Harlinn::Common::Core::Parse ( const StringT & str, int radix = 10 )

inline

Parse() [102/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::ColumnType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [103/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::ColumnFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [104/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::IndexFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [105/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::RetrieveFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [106/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::SetFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [107/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::ColumnInfoLevel, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [108/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::PrepareUpdateOptions, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [109/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::KeyFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [110/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::SeekFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [111/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::IndexRangeFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [112/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::SetCurrentIndexFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [113/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::TableOptions, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [114/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::ObjectFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [115/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::SequentialFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [116/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::ExceptionAction, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [117/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::OpenTableFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [118/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::TransactionFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [119/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::AttachDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [120/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::DetachDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [121/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::CreateDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [122/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::OpenDatabaseFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [123/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::InitFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [124/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::OnlineDefragFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [125/136]

template<typename T , typename StringT >
requires std::is_same_v<Ese::BackupFlags, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [126/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceAccessRights, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [127/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceControlManagerAccessRights, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [128/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [129/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceStartType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [130/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceEnumerationState, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [131/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceState, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [132/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceControl, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [133/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::ServiceControlAccepted, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [134/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::DeviceEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [135/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::HardwareProfileChangeEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

Parse() [136/136]

template<typename T , typename StringT >
requires std::is_same_v<Services::PowerEventType, T> && ( std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString> )

T Harlinn::Common::Core::Parse ( const WideString & str )

inline

ParseBoolean() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::ParseBoolean ( const char * str )

noexcept

ParseBoolean() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::ParseBoolean ( const StringT & str )

inlinenoexcept

ParseBoolean() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::ParseBoolean ( const wchar_t * str )

noexcept

ParseByte() [1/3]

HCC_EXPORT Byte Harlinn::Common::Core::ParseByte	(	const char *	str,
		int	radix )

ParseByte() [2/3]

template<SimpleStringLike StringT>

Byte Harlinn::Common::Core::ParseByte ( const StringT & str, int radix = 10 )

inline

ParseByte() [3/3]

HCC_EXPORT Byte Harlinn::Common::Core::ParseByte	(	const wchar_t *	str,
		int	radix )

ParseDouble() [1/3]

HCC_EXPORT Double Harlinn::Common::Core::ParseDouble

(

const char *

str

)

ParseDouble() [2/3]

template<SimpleStringLike StringT>

Double Harlinn::Common::Core::ParseDouble ( const StringT & str )

inline

ParseDouble() [3/3]

HCC_EXPORT Double Harlinn::Common::Core::ParseDouble

(

const wchar_t *

str

)

ParseDoubleInvariant() [1/3]

HCC_EXPORT Double Harlinn::Common::Core::ParseDoubleInvariant

(

const char *

str

)

ParseDoubleInvariant() [2/3]

template<SimpleStringLike StringT>

Double Harlinn::Common::Core::ParseDoubleInvariant ( const StringT & str )

inline

ParseDoubleInvariant() [3/3]

HCC_EXPORT Double Harlinn::Common::Core::ParseDoubleInvariant

(

const wchar_t *

str

)

ParseInt16() [1/3]

HCC_EXPORT Int16 Harlinn::Common::Core::ParseInt16	(	const char *	str,
		int	radix )

ParseInt16() [2/3]

template<SimpleStringLike StringT>

Int16 Harlinn::Common::Core::ParseInt16 ( const StringT & str, int radix = 10 )

inline

ParseInt16() [3/3]

HCC_EXPORT Int16 Harlinn::Common::Core::ParseInt16	(	const wchar_t *	str,
		int	radix )

ParseInt32() [1/3]

HCC_EXPORT Int32 Harlinn::Common::Core::ParseInt32	(	const char *	str,
		int	radix )

ParseInt32() [2/3]

template<SimpleStringLike StringT>

Int32 Harlinn::Common::Core::ParseInt32 ( const StringT & str, int radix = 10 )

inline

ParseInt32() [3/3]

HCC_EXPORT Int32 Harlinn::Common::Core::ParseInt32	(	const wchar_t *	str,
		int	radix )

ParseInt64() [1/3]

HCC_EXPORT Int64 Harlinn::Common::Core::ParseInt64	(	const char *	str,
		int	radix )

ParseInt64() [2/3]

template<SimpleStringLike StringT>

Int64 Harlinn::Common::Core::ParseInt64 ( const StringT & str, int radix = 10 )

inline

ParseInt64() [3/3]

HCC_EXPORT Int64 Harlinn::Common::Core::ParseInt64	(	const wchar_t *	str,
		int	radix )

ParseInvariant() [1/4]

template<typename T , typename CharT >
requires std::is_same_v<float, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::ParseInvariant ( const CharT * str )

inline

ParseInvariant() [2/4]

template<typename T , typename CharT >
requires std::is_same_v<double, T> && ( std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT> )

T Harlinn::Common::Core::ParseInvariant ( const CharT * str )

inline

ParseInvariant() [3/4]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<float, T>

T Harlinn::Common::Core::ParseInvariant ( const StringT & str )

inline

ParseInvariant() [4/4]

template<typename T , SimpleStringLike StringT>
requires std::is_same_v<double, T>

T Harlinn::Common::Core::ParseInvariant ( const StringT & str )

inline

ParseSByte() [1/3]

HCC_EXPORT SByte Harlinn::Common::Core::ParseSByte	(	const char *	str,
		int	radix )

ParseSByte() [2/3]

template<SimpleStringLike StringT>

SByte Harlinn::Common::Core::ParseSByte ( const StringT & str, int radix = 10 )

inline

ParseSByte() [3/3]

HCC_EXPORT SByte Harlinn::Common::Core::ParseSByte	(	const wchar_t *	str,
		int	radix )

ParseSingle() [1/3]

HCC_EXPORT Single Harlinn::Common::Core::ParseSingle

(

const char *

str

)

ParseSingle() [2/3]

template<SimpleStringLike StringT>

Single Harlinn::Common::Core::ParseSingle ( const StringT & str )

inline

ParseSingle() [3/3]

HCC_EXPORT Single Harlinn::Common::Core::ParseSingle

(

const wchar_t *

str

)

ParseSingleInvariant() [1/3]

HCC_EXPORT Single Harlinn::Common::Core::ParseSingleInvariant

(

const char *

str

)

ParseSingleInvariant() [2/3]

HCC_EXPORT Single Harlinn::Common::Core::ParseSingleInvariant

(

const wchar_t *

str

)

ParseSingleInvariant() [3/3]

template<SimpleStringLike StringT>

Single Harlinn::Common::Core::ParseSingleInvariant ( std::locale locale, const StringT & str )

inline

ParseUInt16() [1/3]

HCC_EXPORT UInt16 Harlinn::Common::Core::ParseUInt16	(	const char *	str,
		int	radix )

ParseUInt16() [2/3]

template<SimpleStringLike StringT>

UInt16 Harlinn::Common::Core::ParseUInt16 ( const StringT & str, int radix = 10 )

inline

ParseUInt16() [3/3]

HCC_EXPORT UInt16 Harlinn::Common::Core::ParseUInt16	(	const wchar_t *	str,
		int	radix )

ParseUInt32() [1/3]

HCC_EXPORT UInt32 Harlinn::Common::Core::ParseUInt32	(	const char *	str,
		int	radix )

ParseUInt32() [2/3]

template<SimpleStringLike StringT>

UInt32 Harlinn::Common::Core::ParseUInt32 ( const StringT & str, int radix = 10 )

inline

ParseUInt32() [3/3]

HCC_EXPORT UInt32 Harlinn::Common::Core::ParseUInt32	(	const wchar_t *	str,
		int	radix )

ParseUInt64() [1/3]

HCC_EXPORT UInt64 Harlinn::Common::Core::ParseUInt64	(	const char *	str,
		int	radix )

ParseUInt64() [2/3]

template<SimpleStringLike StringT>

UInt64 Harlinn::Common::Core::ParseUInt64 ( const StringT & str, int radix = 10 )

inline

ParseUInt64() [3/3]

HCC_EXPORT UInt64 Harlinn::Common::Core::ParseUInt64	(	const wchar_t *	str,
		int	radix )

PrintLn() [1/4]

template<class... Types>

void Harlinn::Common::Core::PrintLn ( const std::format_string< Types... > fmt, Types &&... args )

inline

PrintLn() [2/4]

template<class... Types>

void Harlinn::Common::Core::PrintLn ( const std::locale & locale, const std::format_string< Types... > fmt, Types &&... args )

inline

PrintLn() [3/4]

template<class... Types>

void Harlinn::Common::Core::PrintLn ( const std::locale & locale, const std::wformat_string< Types... > fmt, Types &&... args )

inline

PrintLn() [4/4]

template<class... Types>

void Harlinn::Common::Core::PrintLn ( const std::wformat_string< Types... > fmt, Types &&... args )

inline

Read7BitEncodedByte()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

Byte Harlinn::Common::Core::Read7BitEncodedByte ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 8-bit unsigned integer.

Read7BitEncodedChar()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

char Harlinn::Common::Core::Read7BitEncodedChar ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 8-bit char.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

Read7BitEncodedInt16()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

Int16 Harlinn::Common::Core::Read7BitEncodedInt16 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 16-bit signed integer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedInt32()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

Int32 Harlinn::Common::Core::Read7BitEncodedInt32 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 32-bit signed integer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedInt64()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

Int64 Harlinn::Common::Core::Read7BitEncodedInt64 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 64-bit signed integer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedSByte()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

SByte Harlinn::Common::Core::Read7BitEncodedSByte ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 8-bit signed integer.

Read7BitEncodedUInt16()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

UInt16 Harlinn::Common::Core::Read7BitEncodedUInt16 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 16-bit unsigned integer.

Read7BitEncodedUInt32()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

UInt32 Harlinn::Common::Core::Read7BitEncodedUInt32 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 32-bit unsigned integer.

Read7BitEncodedUInt64()

template<typename Reader >
requires requires( Reader r, Byte& b) { { r.Read( b ) }; }

UInt64 Harlinn::Common::Core::Read7BitEncodedUInt64 ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 64-bit unsigned integer.

Read7BitEncodedValue() [1/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, Byte & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit unsigned integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 8-bit unsigned integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

Read7BitEncodedValue() [2/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, char & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit char referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 8-bit char that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

Read7BitEncodedValue() [3/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, Int16 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit signed integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 16-bit signed integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedValue() [4/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, Int32 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 32-bit signed integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 32-bit signed integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedValue() [5/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, Int64 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 64-bit signed integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 64-bit signed integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Read7BitEncodedValue() [6/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, SByte & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 8-bit signed integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 8-bit signed integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

Read7BitEncodedValue() [7/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, UInt16 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit unsigned integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 16-bit unsigned integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

Read7BitEncodedValue() [8/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, UInt32 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 32-bit unsigned integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 32-bit unsigned integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

Read7BitEncodedValue() [9/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, UInt64 & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 64-bit unsigned integer referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 64-bit unsigned integer that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

Read7BitEncodedValue() [10/11]

size_t Harlinn::Common::Core::Read7BitEncodedValue ( const Byte * buffer, size_t offset, wchar_t & resultValue )

inlineconstexprnoexcept

Reads a 7-bit encoded numer, located at offset in the buffer, decodes in and places the result into the 16-bit wchar_t referenced by resultValue.

Parameters

buffer	A pointer to the buffer containing the 7-bit encoded number.
offset	The offset into buffer of the start of the 7-bit encoded number.
resultValue	A reference to the 16-bit wchar_t that receives the value of the 7-bit encoded number.

Returns

Number of bytes read to decode the 7-bit encoded number.

Read7BitEncodedValue() [11/11]

template<size_t N>

UInt64 Harlinn::Common::Core::Read7BitEncodedValue ( const ByteArray< N > & byteArray )

inlineconstexprnoexcept

Read7BitEncodedWChar()

template<typename Reader >
requires requires( Reader r, Byte& b ) { { r.Read( b ) }; }

wchar_t Harlinn::Common::Core::Read7BitEncodedWChar ( Reader & reader )

inlineconstexprnoexcept

Decodes a 7-bit encoded numer by reading one byte at the time from the Reader object referenced by reader.

Template Parameters

Reader

A type that reads one byte at the time from the underlying source and places the result in the referenced argument.

Parameters

reader

The reader object.

Returns

The decoded 16-bit wchar_t.

ReportException() [1/2]

void Harlinn::Common::Core::ReportException	(	const Exception &	exception,
		const wchar_t *	function,
		const wchar_t *	filename,
		int	lineNumber )

ReportException() [2/2]

void Harlinn::Common::Core::ReportException	(	const std::exception &	exception,
		const wchar_t *	function,
		const wchar_t *	filename,
		int	lineNumber )

ReportUnknownException()

void Harlinn::Common::Core::ReportUnknownException	(	const wchar_t *	function,
		const wchar_t *	filename,
		int	lineNumber )

ReverseBits() [1/14]

Byte Harlinn::Common::Core::ReverseBits ( Byte b )

inlineconstexprnoexcept

Reverses the order of the bits of a byte.

ReverseBits() [2/14]

char Harlinn::Common::Core::ReverseBits ( char b )

inlineconstexprnoexcept

Reverses the order of the bits of a char.

ReverseBits() [3/14]

Double Harlinn::Common::Core::ReverseBits ( double val )

inlineconstexprnoexcept

Reverses the order of the bits of a double.

ReverseBits() [4/14]

Single Harlinn::Common::Core::ReverseBits ( float val )

inlineconstexprnoexcept

Reverses the order of the bits of a float.

ReverseBits() [5/14]

Int16 Harlinn::Common::Core::ReverseBits ( Int16 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int16.

ReverseBits() [6/14]

Int32 Harlinn::Common::Core::ReverseBits ( Int32 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int32.

ReverseBits() [7/14]

Int64 Harlinn::Common::Core::ReverseBits ( Int64 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int64.

ReverseBits() [8/14]

long Harlinn::Common::Core::ReverseBits ( long val )

inlineconstexprnoexcept

Reverses the order of the bits of a long.

ReverseBits() [9/14]

SByte Harlinn::Common::Core::ReverseBits ( SByte b )

inlineconstexprnoexcept

Reverses the order of the bits of a SByte.

ReverseBits() [10/14]

UInt16 Harlinn::Common::Core::ReverseBits ( UInt16 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt16.

ReverseBits() [11/14]

UInt32 Harlinn::Common::Core::ReverseBits ( UInt32 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt32.

ReverseBits() [12/14]

UInt64 Harlinn::Common::Core::ReverseBits ( UInt64 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt64.

ReverseBits() [13/14]

unsigned long Harlinn::Common::Core::ReverseBits ( unsigned long val )

inlineconstexprnoexcept

Reverses the order of the bits of an unsigned long.

ReverseBits() [14/14]

wchar_t Harlinn::Common::Core::ReverseBits ( wchar_t val )

inlineconstexprnoexcept

SetHigh32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }

T2 Harlinn::Common::Core::SetHigh32Bits ( T2 x, T1 value )

inlineconstexprnoexcept

SetLow32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast<UInt64>( t2 ) }->std::convertible_to<UInt64>; }

T2 Harlinn::Common::Core::SetLow32Bits ( T2 x, T1 value )

inlineconstexprnoexcept

shift_crc()

static uint32_t Harlinn::Common::Core::shift_crc ( uint32_t shift_table[][256], uint32_t crc )

inlinestatic

SignBit() [1/2]

UInt64 Harlinn::Common::Core::SignBit ( double value )

inlineconstexpr

SignBit() [2/2]

uint32_t Harlinn::Common::Core::SignBit ( float v )

constexpr

Significand() [1/2]

UInt64 Harlinn::Common::Core::Significand ( double value )

inlineconstexprnoexcept

Significand() [2/2]

int Harlinn::Common::Core::Significand ( float v )

inlineconstexprnoexcept

SizeOf7BitEncodedValue() [1/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( Byte value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 8-bit unsigned integer.

Parameters

value

The 8-bit unsigned integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

SizeOf7BitEncodedValue() [2/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( char value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 8-bit char.

Parameters

value

The 8-bit char.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

SizeOf7BitEncodedValue() [3/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( Int16 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 16-bit signed integer.

Parameters

value

The 16-bit signed integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

SizeOf7BitEncodedValue() [4/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( Int32 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 32-bit signed integer.

Parameters

value

The 32-bit signed integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

SizeOf7BitEncodedValue() [5/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( Int64 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 64-bit signed integer.

Parameters

value

The 64-bit signed integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

SizeOf7BitEncodedValue() [6/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( SByte value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 8-bit signed integer.

Parameters

value

The 8-bit signed integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

SizeOf7BitEncodedValue() [7/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( UInt16 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 16-bit unsigned integer.

Parameters

value

The 16-bit unsigned integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

SizeOf7BitEncodedValue() [8/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( UInt32 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 32-bit unsigned integer.

Parameters

value

The 32-bit unsigned integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

SizeOf7BitEncodedValue() [9/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( UInt64 value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 64-bit unsigned integer.

Parameters

value

The 64-bit unsigned integer.

Returns

Number of bytes required to store value as a 7-bit encoded number.

SizeOf7BitEncodedValue() [10/10]

size_t Harlinn::Common::Core::SizeOf7BitEncodedValue ( wchar_t value )

inlineconstexprnoexcept

Calculates the size, in bytes, required to store a 7-bit encoded 16-bit wchar_t.

Parameters

value

The 16-bit wchar_t.

Returns

Number of bytes required to store value as a 7-bit encoded number.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

StartsWith()

template<SimpleCharSpanLike SpanT>

bool Harlinn::Common::Core::StartsWith ( const SpanT & span, typename SpanT::value_type value )

inline

Strip()

template<typename T >
requires ( IsStdBasicString<T> || IsBasicString<T> )

T Harlinn::Common::Core::Strip ( const T & str, bool(testFunction)(typename T::value_type c)  )

inline

swap() [1/4]

template<typename T , typename Traits >

void Harlinn::Common::Core::swap ( ConcurrentQueue< T, Traits > & a, ConcurrentQueue< T, Traits > & b )

inlinenoexcept

swap() [2/4]

void Harlinn::Common::Core::swap ( ConsumerToken & a, ConsumerToken & b )

inlinenoexcept

swap() [3/4]

void Harlinn::Common::Core::swap ( ProducerToken & a, ProducerToken & b )

inlinenoexcept

swap() [4/4]

template<typename T , typename Traits >

void Harlinn::Common::Core::swap ( typename ConcurrentQueue< T, Traits >::ImplicitProducerKVP & a, typename ConcurrentQueue< T, Traits >::ImplicitProducerKVP & b )

inlinenoexcept

ThrowHRESULT()

void Harlinn::Common::Core::ThrowHRESULT

(

HRESULT

hresult

)

ThrowInvalidHandle()

void Harlinn::Common::Core::ThrowInvalidHandle

(

)

ThrowLastOSError()

void Harlinn::Common::Core::ThrowLastOSError

(

)

ThrowNoInterface()

void Harlinn::Common::Core::ThrowNoInterface

(

)

ThrowNullReferenceException() [1/3]

void Harlinn::Common::Core::ThrowNullReferenceException

(

)

ThrowNullReferenceException() [2/3]

void Harlinn::Common::Core::ThrowNullReferenceException

(

const char *

message

)

ThrowNullReferenceException() [3/3]

void Harlinn::Common::Core::ThrowNullReferenceException

(

const wchar_t *

message

)

ThrowOSError()

void Harlinn::Common::Core::ThrowOSError

(

DWORD

errorId

)

ThrowPointerIsNULL()

void Harlinn::Common::Core::ThrowPointerIsNULL

(

)

Tie()

template<class... Args>

Tuple< Args &... > Harlinn::Common::Core::Tie ( Args &... args )

nodiscardconstexprnoexcept

Creates a Tuple of references from arguments.

ToAnsiString() [1/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

bool

value

)

ToAnsiString() [2/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Byte	value,
		int	base )

ToAnsiString() [3/152]

template<AnsiStringLike StringT = AnsiString>

StringT Harlinn::Common::Core::ToAnsiString ( const char * source )

inline

ToAnsiString() [4/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

const Currency &

value

)

ToAnsiString() [5/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

const DateTime &

value

)

ToAnsiString() [6/152]

AnsiString Harlinn::Common::Core::ToAnsiString

(

const DL_EUI48 *

ethernetAddress

)

ToAnsiString() [7/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString ( const FixedSizeMemoryManagerStatistics & statistics )

nodiscard

ToAnsiString() [8/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

const Guid &

value

)

ToAnsiString() [9/152]

AnsiString Harlinn::Common::Core::ToAnsiString	(	const in6_addr *	addr,
		UInt32	scopeId,
		UInt16	port )

ToAnsiString() [10/152]

AnsiString Harlinn::Common::Core::ToAnsiString

(

const in_addr *

addr

)

ToAnsiString() [11/152]

AnsiString Harlinn::Common::Core::ToAnsiString	(	const in_addr *	addr,
		UInt16	port )

ToAnsiString() [12/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( const IO::MemoryStream & stream, bool convertFromUnicode = false )

inlinenodiscard

ToAnsiString() [13/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( const std::string & source )

inline

ToAnsiString() [14/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( const std::wstring_view & source )

inline

ToAnsiString() [15/152]

void Harlinn::Common::Core::ToAnsiString ( const std::wstring_view & source, AnsiString & dest )

inline

ToAnsiString() [16/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

const TimeSpan &

value

)

ToAnsiString() [17/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

const Variant &

value

)

ToAnsiString() [18/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( const wchar_t * source )

inline

ToAnsiString() [19/152]

template<AnsiStringLike StringT = AnsiString>

StringT Harlinn::Common::Core::ToAnsiString ( const wchar_t * source )

inline

ToAnsiString() [20/152]

template<AnsiStringLike StringT>

void Harlinn::Common::Core::ToAnsiString ( const wchar_t * source, size_t length, StringT & dest )

inline

ToAnsiString() [21/152]

template<AnsiStringLike StringT>

void Harlinn::Common::Core::ToAnsiString ( const wchar_t * source, size_t length, unsigned codePage, unsigned flags, StringT & dest )

inline

ToAnsiString() [22/152]

template<AnsiStringLike AnsiStringT = AnsiString, WideStringLike WideStringT>

AnsiStringT Harlinn::Common::Core::ToAnsiString ( const WideStringT & source )

inline

ToAnsiString() [23/152]

template<WideStringLike WideStringT, AnsiStringLike AnsiStringT>

void Harlinn::Common::Core::ToAnsiString ( const WideStringT & source, AnsiStringT & dest )

inline

ToAnsiString() [24/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

Double

value

)

ToAnsiString() [25/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Double	value,
		const std::locale &	locale )

ToAnsiString() [26/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Double	value,
		int	width,
		int	precision )

ToAnsiString() [27/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Double	value,
		int	width,
		int	precision,
		const std::locale &	locale )

ToAnsiString() [28/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxAccessor value )

inline

ToAnsiString() [29/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxAccessor value, const AnsiString & defaultResult )

inline

ToAnsiString() [30/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxAlign value )

inline

ToAnsiString() [31/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxAlign value, const AnsiString & defaultResult )

inline

ToAnsiString() [32/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCheck value )

inline

ToAnsiString() [33/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCheck value, const AnsiString & defaultResult )

inline

ToAnsiString() [34/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCmdGroupType value )

inline

ToAnsiString() [35/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCmdGroupType value, const AnsiString & defaultResult )

inline

ToAnsiString() [36/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCompoundKind value )

inline

ToAnsiString() [37/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxCompoundKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [38/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxGraphRelation value )

inline

ToAnsiString() [39/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxGraphRelation value, const AnsiString & defaultResult )

inline

ToAnsiString() [40/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxHighlightClass value )

inline

ToAnsiString() [41/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxHighlightClass value, const AnsiString & defaultResult )

inline

ToAnsiString() [42/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxImageKind value )

inline

ToAnsiString() [43/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxImageKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [44/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxLanguage value )

inline

ToAnsiString() [45/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxLanguage value, const AnsiString & defaultResult )

inline

ToAnsiString() [46/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxMemberKind value )

inline

ToAnsiString() [47/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxMemberKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [48/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxOlType value )

inline

ToAnsiString() [49/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxOlType value, const AnsiString & defaultResult )

inline

ToAnsiString() [50/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxParamDir value )

inline

ToAnsiString() [51/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxParamDir value, const AnsiString & defaultResult )

inline

ToAnsiString() [52/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxParamListKind value )

inline

ToAnsiString() [53/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxParamListKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [54/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxPlantumlEngine value )

inline

ToAnsiString() [55/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxPlantumlEngine value, const AnsiString & defaultResult )

inline

ToAnsiString() [56/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxProtectionKind value )

inline

ToAnsiString() [57/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxProtectionKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [58/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxRefKind value )

inline

ToAnsiString() [59/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxRefKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [60/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxRefQualifierKind value )

inline

ToAnsiString() [61/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxRefQualifierKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [62/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxSectionKind value )

inline

ToAnsiString() [63/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxSectionKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [64/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxSimpleSectKind value )

inline

ToAnsiString() [65/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxSimpleSectKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [66/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxVerticalAlign value )

inline

ToAnsiString() [67/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxVerticalAlign value, const AnsiString & defaultResult )

inline

ToAnsiString() [68/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxVirtualKind value )

inline

ToAnsiString() [69/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::DoxVirtualKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [70/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::MemberKind value )

inline

ToAnsiString() [71/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Doxygen::MemberKind value, const AnsiString & defaultResult )

inline

ToAnsiString() [72/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::AttachDatabaseFlags value )

inline

ToAnsiString() [73/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::AttachDatabaseFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [74/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::BackupFlags value )

inline

ToAnsiString() [75/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::BackupFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [76/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnFlags value )

inline

ToAnsiString() [77/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [78/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnInfoLevel value )

inline

ToAnsiString() [79/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnInfoLevel value, const AnsiString & defaultResult )

inline

ToAnsiString() [80/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnType value )

inline

ToAnsiString() [81/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ColumnType value, const AnsiString & defaultResult )

inline

ToAnsiString() [82/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::CreateDatabaseFlags value )

inline

ToAnsiString() [83/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::CreateDatabaseFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [84/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::DetachDatabaseFlags value )

inline

ToAnsiString() [85/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::DetachDatabaseFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [86/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ExceptionAction value )

inline

ToAnsiString() [87/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ExceptionAction value, const AnsiString & defaultResult )

inline

ToAnsiString() [88/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::IndexFlags value )

inline

ToAnsiString() [89/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::IndexFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [90/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::IndexRangeFlags value )

inline

ToAnsiString() [91/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::IndexRangeFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [92/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::InitFlags value )

inline

ToAnsiString() [93/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::InitFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [94/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::KeyFlags value )

inline

ToAnsiString() [95/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::KeyFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [96/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ObjectFlags value )

inline

ToAnsiString() [97/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::ObjectFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [98/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OnlineDefragFlags value )

inline

ToAnsiString() [99/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OnlineDefragFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [100/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OpenDatabaseFlags value )

inline

ToAnsiString() [101/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OpenDatabaseFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [102/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OpenTableFlags value )

inline

ToAnsiString() [103/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::OpenTableFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [104/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::PrepareUpdateOptions value )

inline

ToAnsiString() [105/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::PrepareUpdateOptions value, const AnsiString & defaultResult )

inline

ToAnsiString() [106/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::RetrieveFlags value )

inline

ToAnsiString() [107/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::RetrieveFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [108/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SeekFlags value )

inline

ToAnsiString() [109/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SeekFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [110/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SequentialFlags value )

inline

ToAnsiString() [111/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SequentialFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [112/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SetCurrentIndexFlags value )

inline

ToAnsiString() [113/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SetCurrentIndexFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [114/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SetFlags value )

inline

ToAnsiString() [115/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::SetFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [116/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::TableOptions value )

inline

ToAnsiString() [117/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::TableOptions value, const AnsiString & defaultResult )

inline

ToAnsiString() [118/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::TransactionFlags value )

inline

ToAnsiString() [119/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Ese::TransactionFlags value, const AnsiString & defaultResult )

inline

ToAnsiString() [120/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Int16	value,
		int	base )

ToAnsiString() [121/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Int32	value,
		int	base )

ToAnsiString() [122/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Int64	value,
		int	base )

ToAnsiString() [123/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	SByte	value,
		int	base )

ToAnsiString() [124/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::DeviceEventType value )

inline

ToAnsiString() [125/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::DeviceEventType value, const AnsiString & defaultResult )

inline

ToAnsiString() [126/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::HardwareProfileChangeEventType value )

inline

ToAnsiString() [127/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::HardwareProfileChangeEventType value, const AnsiString & defaultResult )

inline

ToAnsiString() [128/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::PowerEventType value )

inline

ToAnsiString() [129/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::PowerEventType value, const AnsiString & defaultResult )

inline

ToAnsiString() [130/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceAccessRights value )

inline

ToAnsiString() [131/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceAccessRights value, const AnsiString & defaultResult )

inline

ToAnsiString() [132/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControl value )

inline

ToAnsiString() [133/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControl value, const AnsiString & defaultResult )

inline

ToAnsiString() [134/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControlAccepted value )

inline

ToAnsiString() [135/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControlAccepted value, const AnsiString & defaultResult )

inline

ToAnsiString() [136/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControlManagerAccessRights value )

inline

ToAnsiString() [137/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceControlManagerAccessRights value, const AnsiString & defaultResult )

inline

ToAnsiString() [138/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceEnumerationState value )

inline

ToAnsiString() [139/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceEnumerationState value, const AnsiString & defaultResult )

inline

ToAnsiString() [140/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceStartType value )

inline

ToAnsiString() [141/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceStartType value, const AnsiString & defaultResult )

inline

ToAnsiString() [142/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceState value )

inline

ToAnsiString() [143/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceState value, const AnsiString & defaultResult )

inline

ToAnsiString() [144/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceType value )

inline

ToAnsiString() [145/152]

AnsiString Harlinn::Common::Core::ToAnsiString ( Services::ServiceType value, const AnsiString & defaultResult )

inline

ToAnsiString() [146/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString

(

Single

value

)

ToAnsiString() [147/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Single	value,
		const std::locale &	locale )

ToAnsiString() [148/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Single	value,
		int	width,
		int	precision )

ToAnsiString() [149/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	Single	value,
		int	width,
		int	precision,
		const std::locale &	locale )

ToAnsiString() [150/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	UInt16	value,
		int	base )

ToAnsiString() [151/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	UInt32	value,
		int	base )

ToAnsiString() [152/152]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiString	(	UInt64	value,
		int	base )

ToAnsiStringInvariant() [1/4]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiStringInvariant

(

Double

value

)

ToAnsiStringInvariant() [2/4]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiStringInvariant	(	Double	value,
		int	width,
		int	precision )

ToAnsiStringInvariant() [3/4]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiStringInvariant

(

Single

value

)

ToAnsiStringInvariant() [4/4]

HCC_EXPORT AnsiString Harlinn::Common::Core::ToAnsiStringInvariant	(	Single	value,
		int	width,
		int	precision )

ToLower() [1/8]

void Harlinn::Common::Core::ToLower ( char * s )

inline

ToLower() [2/8]

void Harlinn::Common::Core::ToLower ( char * s, size_t size )

inline

ToLower() [3/8]

char Harlinn::Common::Core::ToLower ( char c )

inlinenodiscardnoexcept

ToLower() [4/8]

template<typename T >
requires ( IsStdBasicString<T> )

T Harlinn::Common::Core::ToLower ( const T & str )

inline

ToLower() [5/8]

template<typename T >
requires ( IsBasicString<T> )

T Harlinn::Common::Core::ToLower ( const T & str )

inline

ToLower() [6/8]

void Harlinn::Common::Core::ToLower ( wchar_t * s )

inline

ToLower() [7/8]

void Harlinn::Common::Core::ToLower ( wchar_t * s, size_t size )

inline

ToLower() [8/8]

wchar_t Harlinn::Common::Core::ToLower ( wchar_t c )

inlinenodiscardnoexcept

ToUpper() [1/8]

void Harlinn::Common::Core::ToUpper ( char * s )

inline

ToUpper() [2/8]

void Harlinn::Common::Core::ToUpper ( char * s, size_t size )

inline

ToUpper() [3/8]

char Harlinn::Common::Core::ToUpper ( char c )

inlinenodiscardnoexcept

ToUpper() [4/8]

template<typename T >
requires ( IsStdBasicString<T> )

T Harlinn::Common::Core::ToUpper ( const T & str )

inline

ToUpper() [5/8]

template<typename T >
requires ( IsBasicString<T> )

T Harlinn::Common::Core::ToUpper ( const T & str )

inline

ToUpper() [6/8]

void Harlinn::Common::Core::ToUpper ( wchar_t * s )

inline

ToUpper() [7/8]

void Harlinn::Common::Core::ToUpper ( wchar_t * s, size_t size )

inline

ToUpper() [8/8]

wchar_t Harlinn::Common::Core::ToUpper ( wchar_t c )

inlinenodiscardnoexcept

ToWideString() [1/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

bool

value

)

ToWideString() [2/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Byte	value,
		int	base )

ToWideString() [3/201]

WideString Harlinn::Common::Core::ToWideString

(

ColumnFlags

value

)

ToWideString() [4/201]

WideString Harlinn::Common::Core::ToWideString	(	ColumnFlags	value,
		const WideString &	defaultResult )

ToWideString() [5/201]

WideString Harlinn::Common::Core::ToWideString

(

ColumnType

value

)

ToWideString() [6/201]

WideString Harlinn::Common::Core::ToWideString	(	ColumnType	value,
		const WideString &	defaultResult )

ToWideString() [7/201]

WideString Harlinn::Common::Core::ToWideString ( const AnsiString & source )

inline

ToWideString() [8/201]

template<AnsiStringLike AnsiStringT, WideStringLike WideStringT>

void Harlinn::Common::Core::ToWideString ( const AnsiStringT & source, WideStringT & dest )

inline

ToWideString() [9/201]

WideString Harlinn::Common::Core::ToWideString ( const char * source )

inline

ToWideString() [10/201]

template<WideStringLike StringT>

void Harlinn::Common::Core::ToWideString ( const char * source, size_t length, StringT & dest )

inline

ToWideString() [11/201]

template<WideStringLike StringT>

void Harlinn::Common::Core::ToWideString ( const char * source, size_t length, unsigned codePage, unsigned flags, StringT & dest )

inline

ToWideString() [12/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

const Currency &

value

)

ToWideString() [13/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

const DateTime &

value

)

ToWideString() [14/201]

WideString Harlinn::Common::Core::ToWideString

(

const DL_EUI48 *

ethernetAddress

)

ToWideString() [15/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString ( const FixedSizeMemoryManagerStatistics & statistics )

nodiscard

ToWideString() [16/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

const Guid &

value

)

ToWideString() [17/201]

WideString Harlinn::Common::Core::ToWideString	(	const in6_addr *	addr,
		UInt32	scopeId,
		UInt16	port )

ToWideString() [18/201]

WideString Harlinn::Common::Core::ToWideString

(

const in_addr *

addr

)

ToWideString() [19/201]

WideString Harlinn::Common::Core::ToWideString	(	const in_addr *	addr,
		UInt16	port )

ToWideString() [20/201]

WideString Harlinn::Common::Core::ToWideString ( const IO::MemoryStream & stream, bool convertToUnicode = false )

inlinenodiscard

ToWideString() [21/201]

WideString Harlinn::Common::Core::ToWideString ( const std::string & source )

inline

ToWideString() [22/201]

WideString Harlinn::Common::Core::ToWideString ( const std::string_view & source )

inline

ToWideString() [23/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

const TimeSpan &

value

)

ToWideString() [24/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

const Variant &

value

)

ToWideString() [25/201]

WideString Harlinn::Common::Core::ToWideString ( const wchar_t * source )

inline

ToWideString() [26/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Double

value

)

ToWideString() [27/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxAccessor

value

)

ToWideString() [28/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxAccessor	value,
		const WideString &	defaultResult )

ToWideString() [29/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxAlign

value

)

ToWideString() [30/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxAlign	value,
		const WideString &	defaultResult )

ToWideString() [31/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxCheck

value

)

ToWideString() [32/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxCheck	value,
		const WideString &	defaultResult )

ToWideString() [33/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxCmdGroupType

value

)

ToWideString() [34/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxCmdGroupType	value,
		const WideString &	defaultResult )

ToWideString() [35/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxCompoundKind

value

)

ToWideString() [36/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxCompoundKind	value,
		const WideString &	defaultResult )

ToWideString() [37/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxGraphRelation

value

)

ToWideString() [38/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxGraphRelation	value,
		const WideString &	defaultResult )

ToWideString() [39/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxHighlightClass

value

)

ToWideString() [40/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxHighlightClass	value,
		const WideString &	defaultResult )

ToWideString() [41/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxImageKind

value

)

ToWideString() [42/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxImageKind	value,
		const WideString &	defaultResult )

ToWideString() [43/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxLanguage

value

)

ToWideString() [44/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxLanguage	value,
		const WideString &	defaultResult )

ToWideString() [45/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxMemberKind

value

)

ToWideString() [46/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxMemberKind	value,
		const WideString &	defaultResult )

ToWideString() [47/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxOlType

value

)

ToWideString() [48/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxOlType	value,
		const WideString &	defaultResult )

ToWideString() [49/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxParamDir

value

)

ToWideString() [50/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxParamDir	value,
		const WideString &	defaultResult )

ToWideString() [51/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxParamListKind

value

)

ToWideString() [52/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxParamListKind	value,
		const WideString &	defaultResult )

ToWideString() [53/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxPlantumlEngine

value

)

ToWideString() [54/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxPlantumlEngine	value,
		const WideString &	defaultResult )

ToWideString() [55/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxProtectionKind

value

)

ToWideString() [56/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxProtectionKind	value,
		const WideString &	defaultResult )

ToWideString() [57/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxRefKind

value

)

ToWideString() [58/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxRefKind	value,
		const WideString &	defaultResult )

ToWideString() [59/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxRefQualifierKind

value

)

ToWideString() [60/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxRefQualifierKind	value,
		const WideString &	defaultResult )

ToWideString() [61/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxSectionKind

value

)

ToWideString() [62/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxSectionKind	value,
		const WideString &	defaultResult )

ToWideString() [63/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxSimpleSectKind

value

)

ToWideString() [64/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxSimpleSectKind	value,
		const WideString &	defaultResult )

ToWideString() [65/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxVerticalAlign

value

)

ToWideString() [66/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxVerticalAlign	value,
		const WideString &	defaultResult )

ToWideString() [67/201]

WideString Harlinn::Common::Core::ToWideString

(

DoxVirtualKind

value

)

ToWideString() [68/201]

WideString Harlinn::Common::Core::ToWideString	(	DoxVirtualKind	value,
		const WideString &	defaultResult )

ToWideString() [69/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxAccessor

value

)

ToWideString() [70/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxAccessor	value,
		const WideString &	defaultResult )

ToWideString() [71/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxAlign

value

)

ToWideString() [72/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxAlign	value,
		const WideString &	defaultResult )

ToWideString() [73/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxCheck

value

)

ToWideString() [74/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxCheck	value,
		const WideString &	defaultResult )

ToWideString() [75/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxCmdGroupType

value

)

ToWideString() [76/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxCmdGroupType	value,
		const WideString &	defaultResult )

ToWideString() [77/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxCompoundKind

value

)

ToWideString() [78/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxCompoundKind	value,
		const WideString &	defaultResult )

ToWideString() [79/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxGraphRelation

value

)

ToWideString() [80/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxGraphRelation	value,
		const WideString &	defaultResult )

ToWideString() [81/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxHighlightClass

value

)

ToWideString() [82/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxHighlightClass	value,
		const WideString &	defaultResult )

ToWideString() [83/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxImageKind

value

)

ToWideString() [84/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxImageKind	value,
		const WideString &	defaultResult )

ToWideString() [85/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxLanguage

value

)

ToWideString() [86/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxLanguage	value,
		const WideString &	defaultResult )

ToWideString() [87/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxMemberKind

value

)

ToWideString() [88/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxMemberKind	value,
		const WideString &	defaultResult )

ToWideString() [89/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxOlType

value

)

ToWideString() [90/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxOlType	value,
		const WideString &	defaultResult )

ToWideString() [91/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxParamDir

value

)

ToWideString() [92/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxParamDir	value,
		const WideString &	defaultResult )

ToWideString() [93/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxParamListKind

value

)

ToWideString() [94/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxParamListKind	value,
		const WideString &	defaultResult )

ToWideString() [95/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxPlantumlEngine

value

)

ToWideString() [96/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxPlantumlEngine	value,
		const WideString &	defaultResult )

ToWideString() [97/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxProtectionKind

value

)

ToWideString() [98/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxProtectionKind	value,
		const WideString &	defaultResult )

ToWideString() [99/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxRefKind

value

)

ToWideString() [100/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxRefKind	value,
		const WideString &	defaultResult )

ToWideString() [101/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxRefQualifierKind

value

)

ToWideString() [102/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxRefQualifierKind	value,
		const WideString &	defaultResult )

ToWideString() [103/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxSectionKind

value

)

ToWideString() [104/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxSectionKind	value,
		const WideString &	defaultResult )

ToWideString() [105/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxSimpleSectKind

value

)

ToWideString() [106/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxSimpleSectKind	value,
		const WideString &	defaultResult )

ToWideString() [107/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxVerticalAlign

value

)

ToWideString() [108/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxVerticalAlign	value,
		const WideString &	defaultResult )

ToWideString() [109/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::DoxVirtualKind

value

)

ToWideString() [110/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::DoxVirtualKind	value,
		const WideString &	defaultResult )

ToWideString() [111/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Doxygen::MemberKind

value

)

ToWideString() [112/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Doxygen::MemberKind	value,
		const WideString &	defaultResult )

ToWideString() [113/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::AttachDatabaseFlags

value

)

ToWideString() [114/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::AttachDatabaseFlags	value,
		const WideString &	defaultResult )

ToWideString() [115/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::BackupFlags

value

)

ToWideString() [116/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::BackupFlags	value,
		const WideString &	defaultResult )

ToWideString() [117/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::ColumnFlags

value

)

ToWideString() [118/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::ColumnFlags	value,
		const WideString &	defaultResult )

ToWideString() [119/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::ColumnInfoLevel

value

)

ToWideString() [120/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::ColumnInfoLevel	value,
		const WideString &	defaultResult )

ToWideString() [121/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::ColumnType

value

)

ToWideString() [122/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::ColumnType	value,
		const WideString &	defaultResult )

ToWideString() [123/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::CreateDatabaseFlags

value

)

ToWideString() [124/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::CreateDatabaseFlags	value,
		const WideString &	defaultResult )

ToWideString() [125/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::DetachDatabaseFlags

value

)

ToWideString() [126/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::DetachDatabaseFlags	value,
		const WideString &	defaultResult )

ToWideString() [127/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::ExceptionAction

value

)

ToWideString() [128/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::ExceptionAction	value,
		const WideString &	defaultResult )

ToWideString() [129/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::IndexFlags

value

)

ToWideString() [130/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::IndexFlags	value,
		const WideString &	defaultResult )

ToWideString() [131/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::IndexRangeFlags

value

)

ToWideString() [132/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::IndexRangeFlags	value,
		const WideString &	defaultResult )

ToWideString() [133/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::InitFlags

value

)

ToWideString() [134/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::InitFlags	value,
		const WideString &	defaultResult )

ToWideString() [135/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::KeyFlags

value

)

ToWideString() [136/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::KeyFlags	value,
		const WideString &	defaultResult )

ToWideString() [137/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::ObjectFlags

value

)

ToWideString() [138/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::ObjectFlags	value,
		const WideString &	defaultResult )

ToWideString() [139/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::OnlineDefragFlags

value

)

ToWideString() [140/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::OnlineDefragFlags	value,
		const WideString &	defaultResult )

ToWideString() [141/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::OpenDatabaseFlags

value

)

ToWideString() [142/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::OpenDatabaseFlags	value,
		const WideString &	defaultResult )

ToWideString() [143/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::OpenTableFlags

value

)

ToWideString() [144/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::OpenTableFlags	value,
		const WideString &	defaultResult )

ToWideString() [145/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::PrepareUpdateOptions

value

)

ToWideString() [146/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::PrepareUpdateOptions	value,
		const WideString &	defaultResult )

ToWideString() [147/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::RetrieveFlags

value

)

ToWideString() [148/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::RetrieveFlags	value,
		const WideString &	defaultResult )

ToWideString() [149/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::SeekFlags

value

)

ToWideString() [150/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::SeekFlags	value,
		const WideString &	defaultResult )

ToWideString() [151/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::SequentialFlags

value

)

ToWideString() [152/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::SequentialFlags	value,
		const WideString &	defaultResult )

ToWideString() [153/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::SetCurrentIndexFlags

value

)

ToWideString() [154/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::SetCurrentIndexFlags	value,
		const WideString &	defaultResult )

ToWideString() [155/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::SetFlags

value

)

ToWideString() [156/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::SetFlags	value,
		const WideString &	defaultResult )

ToWideString() [157/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::TableOptions

value

)

ToWideString() [158/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::TableOptions	value,
		const WideString &	defaultResult )

ToWideString() [159/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Ese::TransactionFlags

value

)

ToWideString() [160/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Ese::TransactionFlags	value,
		const WideString &	defaultResult )

ToWideString() [161/201]

WideString Harlinn::Common::Core::ToWideString

(

IndexFlags

value

)

ToWideString() [162/201]

WideString Harlinn::Common::Core::ToWideString	(	IndexFlags	value,
		const WideString &	defaultResult )

ToWideString() [163/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Int16	value,
		int	base )

ToWideString() [164/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Int32	value,
		int	base )

ToWideString() [165/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Int64	value,
		int	base )

ToWideString() [166/201]

WideString Harlinn::Common::Core::ToWideString

(

MemberKind

value

)

ToWideString() [167/201]

WideString Harlinn::Common::Core::ToWideString	(	MemberKind	value,
		const WideString &	defaultResult )

ToWideString() [168/201]

WideString Harlinn::Common::Core::ToWideString

(

RetrieveFlags

value

)

ToWideString() [169/201]

WideString Harlinn::Common::Core::ToWideString	(	RetrieveFlags	value,
		const WideString &	defaultResult )

ToWideString() [170/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	SByte	value,
		int	base )

ToWideString() [171/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::DeviceEventType

value

)

ToWideString() [172/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::DeviceEventType	value,
		const WideString &	defaultResult )

ToWideString() [173/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::HardwareProfileChangeEventType

value

)

ToWideString() [174/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::HardwareProfileChangeEventType	value,
		const WideString &	defaultResult )

ToWideString() [175/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::PowerEventType

value

)

ToWideString() [176/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::PowerEventType	value,
		const WideString &	defaultResult )

ToWideString() [177/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceAccessRights

value

)

ToWideString() [178/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceAccessRights	value,
		const WideString &	defaultResult )

ToWideString() [179/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceControl

value

)

ToWideString() [180/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceControl	value,
		const WideString &	defaultResult )

ToWideString() [181/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceControlAccepted

value

)

ToWideString() [182/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceControlAccepted	value,
		const WideString &	defaultResult )

ToWideString() [183/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceControlManagerAccessRights

value

)

ToWideString() [184/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceControlManagerAccessRights	value,
		const WideString &	defaultResult )

ToWideString() [185/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceEnumerationState

value

)

ToWideString() [186/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceEnumerationState	value,
		const WideString &	defaultResult )

ToWideString() [187/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceStartType

value

)

ToWideString() [188/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceStartType	value,
		const WideString &	defaultResult )

ToWideString() [189/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceState

value

)

ToWideString() [190/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceState	value,
		const WideString &	defaultResult )

ToWideString() [191/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Services::ServiceType

value

)

ToWideString() [192/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Services::ServiceType	value,
		const WideString &	defaultResult )

ToWideString() [193/201]

WideString Harlinn::Common::Core::ToWideString

(

SetFlags

value

)

ToWideString() [194/201]

WideString Harlinn::Common::Core::ToWideString	(	SetFlags	value,
		const WideString &	defaultResult )

ToWideString() [195/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString

(

Single

value

)

ToWideString() [196/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Single	value,
		const std::locale &	locale )

ToWideString() [197/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Single	value,
		int	width,
		int	precision )

ToWideString() [198/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	Single	value,
		int	width,
		int	precision,
		const std::locale &	locale )

ToWideString() [199/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	UInt16	value,
		int	base )

ToWideString() [200/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	UInt32	value,
		int	base )

ToWideString() [201/201]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideString	(	UInt64	value,
		int	base )

ToWideStringInvariant() [1/2]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideStringInvariant

(

Single

value

)

ToWideStringInvariant() [2/2]

HCC_EXPORT WideString Harlinn::Common::Core::ToWideStringInvariant	(	Single	value,
		int	width,
		int	precision )

Trim() [1/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::Trim ( const T & str )

inline

Trim() [2/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::Trim ( const T & str, bool(testFunction)(typename T::value_type c)  )

inline

TrimLeading() [1/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::TrimLeading ( const T & str )

inline

TrimLeading() [2/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::TrimLeading ( const T & str, bool(testFunction)(typename T::value_type c)  )

inline

TrimTrailing() [1/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::TrimTrailing ( const T & str )

inline

TrimTrailing() [2/2]

template<typename T >
requires ( IsStdBasicString<T> || IsStdBasicStringView<T> || IsBasicString<T> || IsBasicStringView<T> )

T Harlinn::Common::Core::TrimTrailing ( const T & str, bool(testFunction)(typename T::value_type c)  )

inline

TryParse() [1/92]

bool Harlinn::Common::Core::TryParse	(	const char *	str,
		bool	strict,
		const char **	end,
		in_addr *	addr )

TryParse() [2/92]

bool Harlinn::Common::Core::TryParse	(	const char *	str,
		const char **	end,
		DL_EUI48 *	ethernetAddress )

TryParse() [3/92]

bool Harlinn::Common::Core::TryParse	(	const char *	str,
		const char **	end,
		in_addr *	addr )

TryParse() [4/92]

bool Harlinn::Common::Core::TryParse	(	const char *	str,
		DL_EUI48 *	ethernetAddress )

TryParse() [5/92]

bool Harlinn::Common::Core::TryParse	(	const char *	str,
		in_addr *	addr )

TryParse() [6/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, Byte & value, int radix = 10 )

inline

TryParse() [7/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, double & value )

inline

TryParse() [8/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, float & value )

inline

TryParse() [9/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, Int16 & value, int radix = 10 )

inline

TryParse() [10/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, Int32 & value, int radix = 10 )

inline

TryParse() [11/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, Int64 & value, int radix = 10 )

inline

TryParse() [12/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, SByte & value, int radix = 10 )

inline

TryParse() [13/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, UInt16 & value, int radix = 10 )

inline

TryParse() [14/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, UInt32 & value, int radix = 10 )

inline

TryParse() [15/92]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParse ( const CharT * str, UInt64 & value, int radix = 10 )

inline

TryParse() [16/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, bool & value )

inlinenoexcept

TryParse() [17/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Byte & value, int radix = 10 )

inlinenoexcept

TryParse() [18/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse	(	const StringT &	str,
		DL_EUI48 *	ethernetAddress )

TryParse() [19/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, double & value )

inlinenoexcept

TryParse() [20/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxAccessor & value )

inline

TryParse() [21/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxAlign & value )

inline

TryParse() [22/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxCheck & value )

inline

TryParse() [23/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxCmdGroupType & value )

inline

TryParse() [24/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxCompoundKind & value )

inline

TryParse() [25/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxGraphRelation & value )

inline

TryParse() [26/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxHighlightClass & value )

inline

TryParse() [27/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxImageKind & value )

inline

TryParse() [28/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxLanguage & value )

inline

TryParse() [29/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxMemberKind & value )

inline

TryParse() [30/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxOlType & value )

inline

TryParse() [31/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxParamDir & value )

inline

TryParse() [32/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxParamListKind & value )

inline

TryParse() [33/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxPlantumlEngine & value )

inline

TryParse() [34/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxProtectionKind & value )

inline

TryParse() [35/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxRefKind & value )

inline

TryParse() [36/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxRefQualifierKind & value )

inline

TryParse() [37/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxSectionKind & value )

inline

TryParse() [38/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxSimpleSectKind & value )

inline

TryParse() [39/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxVerticalAlign & value )

inline

TryParse() [40/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::DoxVirtualKind & value )

inline

TryParse() [41/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Doxygen::MemberKind & value )

inline

TryParse() [42/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::AttachDatabaseFlags & value )

inline

TryParse() [43/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::BackupFlags & value )

inline

TryParse() [44/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::ColumnFlags & value )

inline

TryParse() [45/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::ColumnInfoLevel & value )

inline

TryParse() [46/92]

template<typename StringT >
requires std::is_same_v<StringT,WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::ColumnType & value )

inline

TryParse() [47/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::CreateDatabaseFlags & value )

inline

TryParse() [48/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::DetachDatabaseFlags & value )

inline

TryParse() [49/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::ExceptionAction & value )

inline

TryParse() [50/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::IndexFlags & value )

inline

TryParse() [51/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::IndexRangeFlags & value )

inline

TryParse() [52/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::InitFlags & value )

inline

TryParse() [53/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::KeyFlags & value )

inline

TryParse() [54/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::ObjectFlags & value )

inline

TryParse() [55/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::OnlineDefragFlags & value )

inline

TryParse() [56/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::OpenDatabaseFlags & value )

inline

TryParse() [57/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::OpenTableFlags & value )

inline

TryParse() [58/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::PrepareUpdateOptions & value )

inline

TryParse() [59/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::RetrieveFlags & value )

inline

TryParse() [60/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::SeekFlags & value )

inline

TryParse() [61/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::SequentialFlags & value )

inline

TryParse() [62/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::SetCurrentIndexFlags & value )

inline

TryParse() [63/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::SetFlags & value )

inline

TryParse() [64/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::TableOptions & value )

inline

TryParse() [65/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Ese::TransactionFlags & value )

inline

TryParse() [66/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, float & value )

inlinenoexcept

TryParse() [67/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse	(	const StringT &	str,
		in_addr *	addr )

TryParse() [68/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Int16 & value, int radix = 10 )

inlinenoexcept

TryParse() [69/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Int32 & value, int radix = 10 )

inlinenoexcept

TryParse() [70/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Int64 & value, int radix = 10 )

inlinenoexcept

TryParse() [71/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, SByte & value, int radix = 10 )

inlinenoexcept

TryParse() [72/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::DeviceEventType & value )

inline

TryParse() [73/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::HardwareProfileChangeEventType & value )

inline

TryParse() [74/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::PowerEventType & value )

inline

TryParse() [75/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceAccessRights & value )

inline

TryParse() [76/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceControl & value )

inline

TryParse() [77/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceControlAccepted & value )

inline

TryParse() [78/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceControlManagerAccessRights & value )

inline

TryParse() [79/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceEnumerationState & value )

inline

TryParse() [80/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceStartType & value )

inline

TryParse() [81/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceState & value )

inline

TryParse() [82/92]

template<typename StringT >
requires std::is_same_v<StringT, WideString> || std::is_same_v<StringT, AnsiString>

bool Harlinn::Common::Core::TryParse ( const StringT & str, Services::ServiceType & value )

inline

TryParse() [83/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse	(	const StringT &	str,
		typename StringT::size_type &	end,
		in_addr *	addr )

TryParse() [84/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, UInt16 & value, int radix = 10 )

inlinenoexcept

TryParse() [85/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, UInt32 & value, int radix = 10 )

inlinenoexcept

TryParse() [86/92]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParse ( const StringT & str, UInt64 & value, int radix = 10 )

inlinenoexcept

TryParse() [87/92]

template<typename T >
requires std::is_same_v<char,T> || std::is_same_v<wchar_t, T>

bool Harlinn::Common::Core::TryParse ( const T * str, bool & value )

inline

TryParse() [88/92]

bool Harlinn::Common::Core::TryParse	(	const wchar_t *	str,
		bool	strict,
		const wchar_t **	end,
		in_addr *	addr )

TryParse() [89/92]

bool Harlinn::Common::Core::TryParse	(	const wchar_t *	str,
		const wchar_t **	end,
		DL_EUI48 *	ethernetAddress )

TryParse() [90/92]

bool Harlinn::Common::Core::TryParse	(	const wchar_t *	str,
		const wchar_t **	end,
		in_addr *	addr )

TryParse() [91/92]

bool Harlinn::Common::Core::TryParse	(	const wchar_t *	str,
		DL_EUI48 *	ethernetAddress )

TryParse() [92/92]

bool Harlinn::Common::Core::TryParse	(	const wchar_t *	str,
		in_addr *	addr )

TryParseBoolean() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseBoolean ( const char * str, bool & value )

noexcept

TryParseBoolean() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseBoolean ( const StringT & str, bool & value )

inlinenoexcept

TryParseBoolean() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseBoolean ( const wchar_t * str, bool & value )

noexcept

TryParseByte() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseByte ( const char * str, Byte & value, int radix )

noexcept

TryParseByte() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseByte ( const StringT & str, Byte & value, int radix = 10 )

inlinenoexcept

TryParseByte() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseByte ( const wchar_t * str, Byte & value, int radix )

noexcept

TryParseDouble() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseDouble ( const char * str, double & value )

noexcept

TryParseDouble() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseDouble ( const StringT & str, double & value )

inlinenoexcept

TryParseDouble() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseDouble ( const wchar_t * str, double & value )

noexcept

TryParseDoubleInvariant() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseDoubleInvariant ( const char * str, double & value )

noexcept

TryParseDoubleInvariant() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseDoubleInvariant ( const StringT & str, double & value )

inlinenoexcept

TryParseDoubleInvariant() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseDoubleInvariant ( const wchar_t * str, double & value )

noexcept

TryParseInt16() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt16 ( const char * str, Int16 & value, int radix )

noexcept

TryParseInt16() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseInt16 ( const StringT & str, Int16 & value, int radix = 10 )

inlinenoexcept

TryParseInt16() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt16 ( const wchar_t * str, Int16 & value, int radix )

noexcept

TryParseInt32() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt32 ( const char * str, Int32 & value, int radix )

noexcept

TryParseInt32() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseInt32 ( const StringT & str, Int32 & value, int radix = 10 )

inlinenoexcept

TryParseInt32() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt32 ( const wchar_t * str, Int32 & value, int radix )

noexcept

TryParseInt64() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt64 ( const char * str, Int64 & value, int radix )

noexcept

TryParseInt64() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseInt64 ( const StringT & str, Int64 & value, int radix = 10 )

inlinenoexcept

TryParseInt64() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseInt64 ( const wchar_t * str, Int64 & value, int radix )

noexcept

TryParseInvariant() [1/4]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParseInvariant ( const CharT * str, double & value )

inline

TryParseInvariant() [2/4]

template<typename CharT >
requires std::is_same_v<char, CharT> || std::is_same_v<wchar_t, CharT>

bool Harlinn::Common::Core::TryParseInvariant ( const CharT * str, float & value )

inline

TryParseInvariant() [3/4]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseInvariant ( const StringT & str, double & value )

inlinenoexcept

TryParseInvariant() [4/4]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseInvariant ( const StringT & str, float & value )

inlinenoexcept

TryParseSByte() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSByte ( const char * str, SByte & value, int radix )

noexcept

TryParseSByte() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseSByte ( const StringT & str, SByte & value, int radix = 10 )

inlinenoexcept

TryParseSByte() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSByte ( const wchar_t * str, SByte & value, int radix )

noexcept

TryParseSingle() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSingle ( const char * str, float & value )

noexcept

TryParseSingle() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseSingle ( const StringT & str, float & value )

inlinenoexcept

TryParseSingle() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSingle ( const wchar_t * str, float & value )

noexcept

TryParseSingleInvariant() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSingleInvariant ( const char * str, float & value )

noexcept

TryParseSingleInvariant() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseSingleInvariant ( const StringT & str, float & value )

inlinenoexcept

TryParseSingleInvariant() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseSingleInvariant ( const wchar_t * str, float & value )

noexcept

TryParseUInt16() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt16 ( const char * str, UInt16 & value, int radix )

noexcept

TryParseUInt16() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseUInt16 ( const StringT & str, UInt16 & value, int radix = 10 )

inlinenoexcept

TryParseUInt16() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt16 ( const wchar_t * str, UInt16 & value, int radix )

noexcept

TryParseUInt32() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt32 ( const char * str, UInt32 & value, int radix )

noexcept

TryParseUInt32() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseUInt32 ( const StringT & str, UInt32 & value, int radix = 10 )

inlinenoexcept

TryParseUInt32() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt32 ( const wchar_t * str, UInt32 & value, int radix )

noexcept

TryParseUInt64() [1/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt64 ( const char * str, UInt64 & value, int radix )

noexcept

TryParseUInt64() [2/3]

template<SimpleStringLike StringT>

bool Harlinn::Common::Core::TryParseUInt64 ( const StringT & str, UInt64 & value, int radix = 10 )

inlinenoexcept

TryParseUInt64() [3/3]

HCC_EXPORT bool Harlinn::Common::Core::TryParseUInt64 ( const wchar_t * str, UInt64 & value, int radix )

noexcept

Tuple() [1/2]

template<typename... Args>

Harlinn::Common::Core::Tuple

(

Args...

args

)

-> Tuple< Args... >

Tuple() [2/2]

template<typename... Args>

Harlinn::Common::Core::Tuple

(

const Tuple< Args... > &

args

)

-> Tuple< Args... >

TupleCat()

template<typename... Tuples>

Core::Internal::TupleCatTraits< Tuples... >::type Harlinn::Common::Core::TupleCat ( Tuples &&... tuples )

nodiscardconstexpr

UnwrapPointer() [1/3]

template<typename PointerT >

auto Harlinn::Common::Core::UnwrapPointer ( const PointerT & pointer )

inlinenodiscardconstexprnoexcept

Extracts a plain pointer from a smart pointer.

UnwrapPointer() [2/3]

template<typename PointerT >

auto Harlinn::Common::Core::UnwrapPointer ( PointerT & pointer )

inlinenodiscardconstexprnoexcept

Extracts a plain pointer from a smart pointer.

UnwrapPointer() [3/3]

template<typename T >

T * Harlinn::Common::Core::UnwrapPointer ( T * pointer )

inlinenodiscardconstexprnoexcept

ensure no conversion for regular pointers

Vector()

template<typename It >
requires IsIterator_v<It>

Harlinn::Common::Core::Vector	(	It	,
		It	) -> Vector< IteratorValue_t< It > >

WrapPointer() [1/2]

template<typename PointerT , std::enable_if_t< std::is_pointer_v< PointerT >, int > = 0>

PointerT Harlinn::Common::Core::WrapPointer ( PointerT pointer )

inlinenodiscardconstexprnoexcept

ensure no conversion for regular pointers

WrapPointer() [2/2]

template<typename PointerT , std::enable_if_t<!std::is_pointer_v< PointerT >, int > = 0>

PointerT Harlinn::Common::Core::WrapPointer ( typename std::pointer_traits< PointerT >::element_type * pointer )

inlinenodiscardconstexprnoexcept

WrapReferenceCounted()

template<SimpleComLike T>

ReferenceCountedPtr< T > Harlinn::Common::Core::WrapReferenceCounted ( T * ptr, bool addRef = false )

inline

Write7BitEncodedValue() [1/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( Byte value, Byte * dest )

inlineconstexprnoexcept

Encodes a 8-bit unsigned integer as a 7-bit encoded value.

Parameters

value	The 8-bit unsigned integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

Write7BitEncodedValue() [2/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( char value, Byte * dest )

inlineconstexprnoexcept

Encodes a 8-bit char as a 7-bit encoded value.

Parameters

value	The 8-bit char value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

Write7BitEncodedValue() [3/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( Int16 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 16-bit signed integer as a 7-bit encoded value.

Parameters

value	The 16-bit signed integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Write7BitEncodedValue() [4/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( Int32 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 32-bit signed integer as a 7-bit encoded value.

Parameters

value	The 32-bit signed integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Write7BitEncodedValue() [5/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( Int64 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 64-bit signed integer as a 7-bit encoded value.

Parameters

value	The 64-bit signed integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to minimize the size of the 7-bit encoding.

Write7BitEncodedValue() [6/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( SByte value, Byte * dest )

inlineconstexprnoexcept

Encodes a 8-bit signed integer as a 7-bit encoded value.

Parameters

value	The 8-bit signed integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

The sign bit is rotated to the least significant bit, and the remaining bits are shifted one bit to the right to ensure compatibility with the encodings for the wider signed integer types.

Write7BitEncodedValue() [7/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( UInt16 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 16-bit unsigned integer as a 7-bit encoded value.

Parameters

value	The 16-bit unsigned integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

Write7BitEncodedValue() [8/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( UInt32 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 32-bit unsigned integer as a 7-bit encoded value.

Parameters

value	The 32-bit unsigned integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

Write7BitEncodedValue() [9/11]

template<size_t N>

ByteArray< N > Harlinn::Common::Core::Write7BitEncodedValue ( UInt64 value )

inlineconstexprnoexcept

Write7BitEncodedValue() [10/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( UInt64 value, Byte * dest )

inlineconstexprnoexcept

Encodes a 64-bit unsigned integer as a 7-bit encoded value.

Parameters

value	The 64-bit unsigned integer value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

Write7BitEncodedValue() [11/11]

size_t Harlinn::Common::Core::Write7BitEncodedValue ( wchar_t value, Byte * dest )

inlineconstexprnoexcept

Encodes a 16-bit wchar_t as a 7-bit encoded value.

Parameters

value	The 16-bit wchar_t value.
dest	The a pointer to the buffer receiving the 7-bit encoded number. The size of the buffer must be greater or equal to the value returned by SizeOf7BitEncodedValue for the value.

Returns

Number of bytes written to the destination buffer.

Variable Documentation

applicationThreadId

UInt64 Harlinn::Common::Core::applicationThreadId = 0xFFFFFFFFFFFFFFFF

static

BitMask_v

template<size_t N>

auto Harlinn::Common::Core::BitMask_v = BitMask<N>::value

inlineconstexpr

crc32cImpl

uint32_t(* Harlinn::Common::Core::crc32cImpl) (const uint8_t *, size_t, uint32_t)	(	const uint8_t *	,
		size_t	,
		uint32_t	) = crc32c_sw

dword_table

uint32_t Harlinn::Common::Core::dword_table[4][256]

ExponentMask

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>

U Harlinn::Common::Core::ExponentMask = 0

inlineconstexpr

ExponentMask< double, UInt64 >

template<>

UInt64 Harlinn::Common::Core::ExponentMask< double, UInt64 > = std::bit_cast<UInt64>( 0b0111111111110000000000000000000000000000000000000000000000000000 )

inlineconstexpr

ExponentMask< float, UInt32 >

template<>

UInt32 Harlinn::Common::Core::ExponentMask< float, UInt32 > = std::bit_cast<UInt32>( 0b01111111100000000000000000000000 )

inlineconstexpr

False_v

template<typename T >

bool Harlinn::Common::Core::False_v = false

inlineconstexpr

FractionMask

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>

U Harlinn::Common::Core::FractionMask = std::numeric_limits<std::remove_cvref_t<T>>::max( )

inlineconstexpr

FractionMask< double, UInt64 >

template<>

UInt64 Harlinn::Common::Core::FractionMask< double, UInt64 > = std::bit_cast<UInt64>( 0b0000000000001111111111111111111111111111111111111111111111111111 )

inlineconstexpr

FractionMask< float, UInt32 >

template<>

UInt32 Harlinn::Common::Core::FractionMask< float, UInt32 > = std::bit_cast<UInt32>( 0b00000000011111111111111111111111 )

inlineconstexpr

IsAnsiString

template<typename T >

bool Harlinn::Common::Core::IsAnsiString = std::is_base_of_v<AnsiString,T>

inlineconstexpr

IsAnsiStringView

template<typename T >

bool Harlinn::Common::Core::IsAnsiStringView = std::is_base_of_v<AnsiStringView, T>

inlineconstexpr

IsAnyOf_v

template<typename Type , typename... TypeList>

bool Harlinn::Common::Core::IsAnyOf_v = IsAnyOf<Type, TypeList...>::value

inlineconstexpr

IsArray

template<typename T >

bool Harlinn::Common::Core::IsArray = std::is_array_v<std::remove_cvref_t<T>>

constexpr

IsArrayContainer

template<typename T >

bool Harlinn::Common::Core::IsArrayContainer = IsStdArray<T> || IsCoreByteArray<T>

constexpr

IsBasicString

template<typename T >

bool Harlinn::Common::Core::IsBasicString = Core::Internal::IsBasicStringImpl<std::remove_cvref_t<T>>

constexpr

IsBasicStringView

template<typename T >

bool Harlinn::Common::Core::IsBasicStringView = Core::Internal::IsBasicStringViewImpl<std::remove_cvref_t<T>>

constexpr

IsBasicType

template<typename T >

bool Harlinn::Common::Core::IsBasicType = Core::Internal::IsBasicTypeImpl<std::remove_cvref_t<T>>

constexpr

IsBidirectionalIterator_v

template<class It >

bool Harlinn::Common::Core::IsBidirectionalIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::bidirectional_iterator_tag>

inlineconstexpr

IsBoolean

template<typename T >

bool Harlinn::Common::Core::IsBoolean = std::is_same_v<std::remove_cvref_t<T>, bool>

inlineconstexpr

IsCharString

template<typename T >

bool Harlinn::Common::Core::IsCharString = std::is_pointer_v<T> && std::is_same_v<char, std::remove_cvref_t< std::remove_pointer_t<T>>>

constexpr

IsConst

template<typename T >

bool Harlinn::Common::Core::IsConst = std::is_same_v<std::remove_reference_t<std::remove_volatile_t<T>>, std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>> == false

constexpr

IsContainer

template<typename T >

bool Harlinn::Common::Core::IsContainer

constexpr

Initial value:

= IsStdArray<T> ||
                                IsStdVector<T> ||
                                IsStdDeque<T> ||
                                IsStdForwardList<T> ||
                                IsStdList<T> ||
                                IsStdSet<T> ||
                                IsStdMap<T> ||
                                IsStdMultiset<T> ||
                                IsStdMultimap<T> ||
                                IsStdUnorderedSet<T> ||
                                IsStdUnorderedMap<T> ||
                                IsStdUnorderedMultiset<T> ||
                                IsStdUnorderedMultimap<T> ||
                                IsStdStack<T> ||
                                IsStdQueue<T> ||
                                IsStdPriorityQueue<T> ||
                                IsStdSpan<T> ||
                                IsStdBasicString<T> ||
                                IsStdBasicStringView<T> ||
 
                                IsBasicString<T> ||
                                IsBasicStringView<T> ||
 
                                IsCoreByteArray<T> ||
                                IsCoreVector<T>

IsContiguousIterator_v

template<class It >

bool Harlinn::Common::Core::IsContiguousIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::contiguous_iterator_tag>

inlineconstexpr

IsCoreByteArray

template<typename T >

bool Harlinn::Common::Core::IsCoreByteArray = Core::Internal::IsCoreByteArrayImpl<std::remove_cvref_t<T>>

constexpr

IsCoreTuple

template<typename T >

bool Harlinn::Common::Core::IsCoreTuple = Core::Internal::IsCoreTupleImpl<std::remove_cvref_t<T>>

constexpr

IsCoreVector

template<typename T >

bool Harlinn::Common::Core::IsCoreVector = Core::Internal::IsCoreVectorImpl<std::remove_cvref_t<T>>

constexpr

IsCurrency

template<typename T >

bool Harlinn::Common::Core::IsCurrency = std::is_same_v<std::remove_cv_t<T>, Currency>

inlineconstexpr

IsDateTime

template<typename T >

bool Harlinn::Common::Core::IsDateTime = std::is_same_v<std::remove_cv_t<T>, DateTime>

inlineconstexpr

IsFloatingPoint

template<typename T >

bool Harlinn::Common::Core::IsFloatingPoint = std::is_floating_point_v<std::remove_cvref_t<T>>

inlineconstexpr

IsForwardIterator_v

template<class It >

bool Harlinn::Common::Core::IsForwardIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::forward_iterator_tag>

inlineconstexpr

IsGUID

template<typename T >

bool Harlinn::Common::Core::IsGUID = std::is_same_v<std::remove_cv_t<T>, GUID>

inlineconstexpr

IsGuid

template<typename T >

bool Harlinn::Common::Core::IsGuid = std::is_same_v<std::remove_cv_t<T>, Guid>

inlineconstexpr

IsInputIterator_v

template<class It >

bool Harlinn::Common::Core::IsInputIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::input_iterator_tag>

inlineconstexpr

IsInteger

template<typename T >

bool Harlinn::Common::Core::IsInteger = std::is_integral_v<std::remove_cvref_t<T>> && IsBoolean<T> == false

inlineconstexpr

IsIterator_v

template<class It , class = void>

bool Harlinn::Common::Core::IsIterator_v = false

inlineconstexpr

IsNotBoolean

template<typename T >

bool Harlinn::Common::Core::IsNotBoolean = std::is_same_v<std::remove_cvref_t<T>, bool> == false

inlineconstexpr

IsNotString

template<typename T >

bool Harlinn::Common::Core::IsNotString = IsAnsiString<T> == false && IsWideString<T> == false

inlineconstexpr

IsPointer

template<typename T >

bool Harlinn::Common::Core::IsPointer = std::is_same_v< std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>, std::remove_pointer_t<std::remove_const_t<std::remove_reference_t<std::remove_volatile_t<T>>>>> == false

constexpr

IsRandomAccessIterator_v

template<class It >

bool Harlinn::Common::Core::IsRandomAccessIterator_v = std::is_convertible_v<IteratorCategory_t<It>, std::random_access_iterator_tag>

inlineconstexpr

IsReference

template<typename T >

bool Harlinn::Common::Core::IsReference = std::is_same_v< std::remove_volatile_t<std::remove_const_t<T>> , std::remove_reference_t<std::remove_volatile_t<std::remove_const_t<T>>>> == false

inlineconstexpr

IsSignedInteger

template<typename T >

bool Harlinn::Common::Core::IsSignedInteger = IsInteger<std::remove_cvref_t<T>> && std::is_signed_v<std::remove_cvref_t<T>>

inlineconstexpr

IsSpecializationOf

template<class , template< class... > class>

bool Harlinn::Common::Core::IsSpecializationOf = false

inlineconstexpr

IsSpecializationOf< T< Args... >, T >

template<template< class... > class T, class... Args>

bool Harlinn::Common::Core::IsSpecializationOf< T< Args... >, T > = true

inlineconstexpr

IsStdAny

template<typename T >

bool Harlinn::Common::Core::IsStdAny = Core::Internal::IsStdAnyImpl<std::remove_cvref_t<T>>

constexpr

IsStdArray

template<typename T >

bool Harlinn::Common::Core::IsStdArray = Core::Internal::IsStdArrayImpl<std::remove_cvref_t<T>>

constexpr

IsStdBasicString

template<typename T >

bool Harlinn::Common::Core::IsStdBasicString = Core::Internal::IsStdBasicStringImpl<std::remove_cvref_t<T>>

constexpr

IsStdBasicStringView

template<typename T >

bool Harlinn::Common::Core::IsStdBasicStringView = Core::Internal::IsStdBasicStringViewImpl<std::remove_cvref_t<T>>

constexpr

IsStdComplex

template<typename T >

bool Harlinn::Common::Core::IsStdComplex = Core::Internal::IsStdComplexImpl<std::remove_cvref_t<T>>

constexpr

IsStdDeque

template<typename T >

bool Harlinn::Common::Core::IsStdDeque = Core::Internal::IsStdDequeImpl<std::remove_cvref_t<T>>

constexpr

IsStdForwardList

template<typename T >

bool Harlinn::Common::Core::IsStdForwardList = Core::Internal::IsStdForwardListImpl<std::remove_cvref_t<T>>

constexpr

IsStdList

template<typename T >

bool Harlinn::Common::Core::IsStdList = Core::Internal::IsStdListImpl<std::remove_cvref_t<T>>

constexpr

IsStdMap

template<typename T >

bool Harlinn::Common::Core::IsStdMap = Core::Internal::IsStdMapImpl<std::remove_cvref_t<T>>

constexpr

IsStdMultimap

template<typename T >

bool Harlinn::Common::Core::IsStdMultimap = Core::Internal::IsStdMultimapImpl<std::remove_cvref_t<T>>

constexpr

IsStdMultiset

template<typename T >

bool Harlinn::Common::Core::IsStdMultiset = Core::Internal::IsStdMultisetImpl<std::remove_cvref_t<T>>

constexpr

IsStdOptional

template<typename T >

bool Harlinn::Common::Core::IsStdOptional = Core::Internal::IsStdOptionalImpl<std::remove_cvref_t<T>>

constexpr

IsStdPair

template<typename T >

bool Harlinn::Common::Core::IsStdPair = Core::Internal::IsStdPairImpl<std::remove_cvref_t<T>>

constexpr

IsStdPriorityQueue

template<typename T >

bool Harlinn::Common::Core::IsStdPriorityQueue = Core::Internal::IsStdPriorityQueueImpl<std::remove_cvref_t<T>>

constexpr

IsStdQueue

template<typename T >

bool Harlinn::Common::Core::IsStdQueue = Core::Internal::IsStdQueueImpl<std::remove_cvref_t<T>>

constexpr

IsStdSet

template<typename T >

bool Harlinn::Common::Core::IsStdSet = Core::Internal::IsStdSetImpl<std::remove_cvref_t<T>>

constexpr

IsStdSharedPtr

template<typename T >

bool Harlinn::Common::Core::IsStdSharedPtr = Core::Internal::IsStdSharedPtrImpl<std::remove_cvref_t<T>>

constexpr

IsStdSpan

template<typename T >

bool Harlinn::Common::Core::IsStdSpan = Core::Internal::IsStdSpanImpl<std::remove_cvref_t<T>>

constexpr

IsStdStack

template<typename T >

bool Harlinn::Common::Core::IsStdStack = Core::Internal::IsStdStackImpl<std::remove_cvref_t<T>>

constexpr

IsStdTuple

template<typename T >

bool Harlinn::Common::Core::IsStdTuple = Core::Internal::IsStdTupleImpl<std::remove_cvref_t<T>>

constexpr

IsStdUniquePtr

template<typename T >

bool Harlinn::Common::Core::IsStdUniquePtr = Core::Internal::IsStdUniquePtrImpl<std::remove_cvref_t<T>>

constexpr

IsStdUnorderedMap

template<typename T >

bool Harlinn::Common::Core::IsStdUnorderedMap = Core::Internal::IsStdUnorderedMapImpl<std::remove_cvref_t<T>>

constexpr

IsStdUnorderedMultimap

template<typename T >

bool Harlinn::Common::Core::IsStdUnorderedMultimap = Core::Internal::IsStdUnorderedMultimapImpl<std::remove_cvref_t<T>>

constexpr

IsStdUnorderedMultiset

template<typename T >

bool Harlinn::Common::Core::IsStdUnorderedMultiset = Core::Internal::IsStdUnorderedMultisetImpl<std::remove_cvref_t<T>>

constexpr

IsStdUnorderedSet

template<typename T >

bool Harlinn::Common::Core::IsStdUnorderedSet = Core::Internal::IsStdUnorderedSetImpl<std::remove_cvref_t<T>>

constexpr

IsStdVariant

template<typename T >

bool Harlinn::Common::Core::IsStdVariant = Core::Internal::IsStdVariantImpl<std::remove_cvref_t<T>>

constexpr

IsStdVector

template<typename T >

bool Harlinn::Common::Core::IsStdVector = Core::Internal::IsStdVectorImpl<std::remove_cvref_t<T>>

constexpr

IsStdVectorBool

template<typename T >

bool Harlinn::Common::Core::IsStdVectorBool = Core::Internal::IsStdVectorBoolImpl<std::remove_cvref_t<T>>

constexpr

IsString

template<typename T >

bool Harlinn::Common::Core::IsString = std::is_pointer_v<T> && ( std::is_same_v<char, std::remove_cvref_t< std::remove_pointer_t<T>>> || std::is_same_v<wchar_t, std::remove_cvref_t< std::remove_pointer_t<T>>> )

constexpr

IsTimeSpan

template<typename T >

bool Harlinn::Common::Core::IsTimeSpan = std::is_same_v<std::remove_cv_t<T>, TimeSpan>

inlineconstexpr

IsTupleType

template<typename T >

bool Harlinn::Common::Core::IsTupleType = IsStdPair<T> || IsStdTuple<T> || IsCoreTuple<T>

constexpr

IsTypeList

template<typename T >

bool Harlinn::Common::Core::IsTypeList = Core::Internal::IsTypeListImpl<std::remove_cvref_t<T>>

constexpr

IsUnsignedInteger

template<typename T >

bool Harlinn::Common::Core::IsUnsignedInteger = IsInteger<T> && std::is_unsigned_v<std::remove_cvref_t<T>>

inlineconstexpr

IsVectorContainer

template<typename T >

bool Harlinn::Common::Core::IsVectorContainer = IsStdVector<T> || IsCoreVector<T>

constexpr

IsVolatile

template<typename T >

bool Harlinn::Common::Core::IsVolatile = std::is_same_v<std::remove_reference_t<std::remove_const_t<T>>, std::remove_volatile_t<std::remove_reference_t<std::remove_const_t<T>>>> == false

constexpr

IsWideCharString

template<typename T >

bool Harlinn::Common::Core::IsWideCharString = std::is_pointer_v<T> && std::is_same_v<wchar_t, std::remove_cvref_t< std::remove_pointer_t<T>>>

constexpr

IsWideString

template<typename T >

bool Harlinn::Common::Core::IsWideString = std::is_base_of_v<WideString, T>

inlineconstexpr

IsWideStringView

template<typename T >

bool Harlinn::Common::Core::IsWideStringView = std::is_base_of_v<WideStringView, T>

inlineconstexpr

[union]

union { ... } Harlinn::Common::Core::long_shifts

mainThreadId

UInt64 Harlinn::Common::Core::mainThreadId = 0xFFFFFFFFFFFFFFFF

static

MaxDWord32

DWord32 Harlinn::Common::Core::MaxDWord32 = ( (DWord32)~( (DWord32)0 ) )

constexpr

MaxDWord64

DWord64 Harlinn::Common::Core::MaxDWord64 = ( (DWord64)~( (DWord64)0 ) )

constexpr

MaxEightByteValue

UInt64 Harlinn::Common::Core::MaxEightByteValue = 0xFFFFFFFFFFFFFFULL

constexpr

MaxFiveByteValue

UInt64 Harlinn::Common::Core::MaxFiveByteValue = 0x7FFFFFFFFULL

constexpr

MaxFourByteValue

UInt64 Harlinn::Common::Core::MaxFourByteValue = 0xFFFFFFFULL

constexpr

MaxInt

Int Harlinn::Common::Core::MaxInt = ( (Int)( MaxUInt >> 1 ) )

constexpr

MaxInt16

Int16 Harlinn::Common::Core::MaxInt16 = ( (Int16)( MaxUInt16 >> 1 ) )

constexpr

MaxInt32

Int32 Harlinn::Common::Core::MaxInt32 = ( (Int32)( MaxUInt32 >> 1 ) )

constexpr

MaxInt64

Int64 Harlinn::Common::Core::MaxInt64 = ( (Int64)( MaxUInt64 >> 1 ) )

constexpr

MaxInt8

Int8 Harlinn::Common::Core::MaxInt8 = ( (Int8)( MaxUInt8 >> 1 ) )

constexpr

MaxLong32

Long32 Harlinn::Common::Core::MaxLong32 = ( (Long32)( MaxULong32 >> 1 ) )

constexpr

MaxLong64

Long64 Harlinn::Common::Core::MaxLong64 = ( (Long64)( MaxULong64 >> 1 ) )

constexpr

MaxLongLong

LongLong Harlinn::Common::Core::MaxLongLong = ( (LongLong)( MaxULongLong >> 1 ) )

constexpr

MaxNineByteValue

UInt64 Harlinn::Common::Core::MaxNineByteValue = 0xFFFFFFFFFFFFFFFFULL

constexpr

MaxOneByteValue

UInt64 Harlinn::Common::Core::MaxOneByteValue = 0x7FULL

constexpr

MaxSevenByteValue

UInt64 Harlinn::Common::Core::MaxSevenByteValue = 0x1FFFFFFFFFFFFULL

constexpr

MaxSixByteValue

UInt64 Harlinn::Common::Core::MaxSixByteValue = 0x3FFFFFFFFFFULL

constexpr

MaxSizeT

SizeT Harlinn::Common::Core::MaxSizeT = ( (SizeT)~( (SizeT)0 ) )

constexpr

MaxSSizeT

SSizeT Harlinn::Common::Core::MaxSSizeT = ( (SSizeT)( MaxSizeT >> 1 ) )

constexpr

MaxThreeByteValue

UInt64 Harlinn::Common::Core::MaxThreeByteValue = 0x1FFFFFULL

constexpr

MaxTwoByteValue

UInt64 Harlinn::Common::Core::MaxTwoByteValue = 0x3FFFULL

constexpr

MaxUInt

UInt Harlinn::Common::Core::MaxUInt = ( (UInt)~( (UInt)0 ) )

constexpr

MaxUInt16

UInt16 Harlinn::Common::Core::MaxUInt16 = ( (UInt16)~( (UInt16)0 ) )

constexpr

MaxUInt32

UInt32 Harlinn::Common::Core::MaxUInt32 = ( (UInt32)~( (UInt32)0 ) )

constexpr

MaxUInt64

UInt64 Harlinn::Common::Core::MaxUInt64 = ( (UInt64)~( (UInt64)0 ) )

constexpr

MaxUInt8

UInt8 Harlinn::Common::Core::MaxUInt8 = ( (UInt8)~( (UInt8)0 ) )

constexpr

MaxULong32

ULong32 Harlinn::Common::Core::MaxULong32 = ( (ULong32)~( (ULong32)0 ) )

constexpr

MaxULong64

ULong64 Harlinn::Common::Core::MaxULong64 = ( (ULong64)~( (ULong64)0 ) )

constexpr

MaxULongLong

ULongLong Harlinn::Common::Core::MaxULongLong = ( (ULongLong)~( (ULongLong)0 ) )

constexpr

MinInt

Int Harlinn::Common::Core::MinInt = ( (Int)~MaxInt )

constexpr

MinInt16

Int16 Harlinn::Common::Core::MinInt16 = ( (Int16)~MaxInt16 )

constexpr

MinInt32

Int32 Harlinn::Common::Core::MinInt32 = ( (Int32)~MaxInt32 )

constexpr

MinInt64

Int64 Harlinn::Common::Core::MinInt64 = ( (Int64)~MaxInt64 )

constexpr

MinInt8

Int8 Harlinn::Common::Core::MinInt8 = ( (Int8)~MaxInt8 )

constexpr

MinLong32

Long32 Harlinn::Common::Core::MinLong32 = ( (Long32)~MaxLong32 )

constexpr

MinLong64

Long64 Harlinn::Common::Core::MinLong64 = ( (Long64)~MaxLong64 )

constexpr

MinLongLong

LongLong Harlinn::Common::Core::MinLongLong = ( (LongLong)~MaxLongLong )

constexpr

MinSSizeT

SSizeT Harlinn::Common::Core::MinSSizeT = ( (SSizeT)~MaxSSizeT )

constexpr

qword_array

uint64_t Harlinn::Common::Core::qword_array[512]

[union]

union { ... } Harlinn::Common::Core::short_shifts

SignMask

template<typename T >

std::remove_cvref_t<T> Harlinn::Common::Core::SignMask

inlineconstexpr

Initial value:

= 
        std::numeric_limits< std::make_unsigned_t<std::remove_cvref_t<T>> >::max( ) 
        - std::bit_cast<std::make_unsigned_t<std::remove_cvref_t<T>>>( 
            std::numeric_limits< std::make_signed_t< std::remove_cvref_t<T> > >::max( ) )

SignMask< double >

template<>

UInt64 Harlinn::Common::Core::SignMask< double > = 0x8000000000000000ULL

inlineconstexpr

SignMask< float >

template<>

UInt32 Harlinn::Common::Core::SignMask< float > = 0x80000000UL

inlineconstexpr

size_is_greater

template<typename ty1 , typename ty2 >

bool Harlinn::Common::Core::size_is_greater = sizeof( ty1 ) > sizeof( ty2 ) ? true : false

inlineconstexpr

size_is_greater_or_equal

template<typename ty1 , typename ty2 >

bool Harlinn::Common::Core::size_is_greater_or_equal = sizeof( ty1 ) >= sizeof( ty2 ) ? true : false

inlineconstexpr

size_is_less

template<typename ty1 , typename ty2 >

bool Harlinn::Common::Core::size_is_less = sizeof( ty1 ) < sizeof( ty2 ) ? true : false

inlineconstexpr

size_is_less_or_equal

template<typename ty1 , typename ty2 >

bool Harlinn::Common::Core::size_is_less_or_equal = sizeof( ty1 ) <= sizeof( ty2 ) ? true : false

inlineconstexpr

SizeOf7BitEncoded_v

template<UInt64 N>

size_t Harlinn::Common::Core::SizeOf7BitEncoded_v = SizeOf7BitEncodedValue( N )

inlineconstexpr

Calculates the size, in bytes, required to store a 7-bit encoded 64-bit unsigned integer.

Template Parameters

N	The 64-bit unsigned integer.

[union]

union { ... } Harlinn::Common::Core::table

True_v

template<typename T >

bool Harlinn::Common::Core::True_v = true

inlineconstexpr

ValueMask

template<typename T >

T Harlinn::Common::Core::ValueMask = ~SignMask<T>

inlineconstexpr

ValueMask< double >

template<>

UInt64 Harlinn::Common::Core::ValueMask< double > = 0x7FFFFFFFFFFFFFFFULL

inlineconstexpr

ValueMask< float >

template<>

UInt32 Harlinn::Common::Core::ValueMask< float > = 0x7FFFFFFFUL

inlineconstexpr