 |
Sane C++ Libraries
C++ Platform Abstraction Libraries
|
|
Sane C++ Libraries
C++ Platform Abstraction Libraries
|
| CSC::TypeTraits::AddPointer< T > | AddPointer adds a pointer qualification to a type T if it is not already a pointer |
| CSC::AlignedStorage< N, Alignment > | A buffer of bytes with given alignment |
| CSC::Process::StdStream::AlreadySetup | |
| CSC::ArenaMap< T > | A sparse vector keeping objects at a stable memory location |
| CSC::ArenaMap< T >::ArenaMapIterator< MapType > | |
| CSC::ArenaMapKey< T > | A sparse vector keeping objects at a stable memory location |
| CSC::Assert | Functions and macros to assert, exit() or abort() and capture backtraces |
| CSC::AsyncBuffersPool | Holds a Span of AsyncBufferView (allocated by user) holding available memory for the streams |
| CSC::AsyncBufferView | A Span of bytes memory to be read or written by async streams |
| ►CSC::AsyncCompletionData | Empty base struct for all AsyncRequest-derived CompletionData (internal) structs |
| CSC::AsyncEventLoop | Asynchronous I/O (files, sockets, timers, processes, fs events, threads wake-up) (see Async) AsyncEventLoop pushes all AsyncRequest derived classes to I/O queues in the OS |
| CSC::AsyncEventLoopListeners | Allow library user to provide callbacks signaling different phases of async event loop cycle |
| CSC::AsyncEventLoopMonitor | Monitors Async I/O events from a background thread using a blocking kernel function (no CPU usage on idle) |
| CSC::AsyncKernelEvents | Allows user to supply a block of memory that will store kernel I/O events retrieved from AsyncEventLoop::runOnce |
| CSC::AsyncLoopWakeUpOptions | Options for AsyncLoopWakeUp configuration |
| CSC::AsyncPipeline | Pipes read data from SC::AsyncReadableStream, forwarding them to SC::AsyncWritableStream |
| ►CSC::AsyncReadableStream | Async source abstraction emitting data events in caller provided byte buffers |
| ►CSC::AsyncRequest | Base class for all async requests, holding state and type |
| ►CSC::AsyncResult | Base class for all async results (argument of completion callbacks) |
| ►CSC::AsyncSequence | Execute AsyncRequests serially, by submitting the next one after the previous one is completed |
| CSC::AsyncSignalOptions | Options for AsyncSignal request configuration |
| CSC::AsyncStreams | Traits exposing AsyncStreams public types through a single template parameter |
| ►CSC::AsyncWritableStream | Async destination abstraction where bytes can be written to |
| CSC::Atomic< T > | Atomic variables (only for int and bool for now) |
| CSC::AwaitAllocator | Explicit allocator used by AwaitTask coroutine frame allocation |
| CSC::AwaitAllocatorInterface | |
| CSC::AwaitAllocatorStatistics | |
| CSC::AwaitAllocatorVirtualOptions | |
| CSC::AwaitCancellationHandler | Cancellation hook installed by the awaiter currently suspending an AwaitTask |
| CSC::AwaitEventLoop | Coroutine-friendly wrapper around an existing AsyncEventLoop |
| CSC::AwaitFilePollAwaiter | Awaiter for a single AsyncFilePoll operation |
| CSC::AwaitFileReadAwaiter | Awaiter for a single AsyncFileRead operation |
| CSC::AwaitFileReadOptions | |
| CSC::AwaitFileReadResult | Result object populated by AwaitEventLoop::fileRead |
| CSC::AwaitFileReadUntilFullOrEOFAwaiter | Awaiter that reads until the caller buffer is full or EOF is reached |
| CSC::AwaitFileSendAwaiter | Awaiter for a single AsyncFileSend operation |
| CSC::AwaitFileSendOptions | |
| CSC::AwaitFileSendResult | |
| CSC::AwaitFileSystemOperationAwaiter | Awaiter for selected AsyncFileSystemOperation path operations |
| CSC::AwaitFileWriteAwaiter | Awaiter for a single AsyncFileWrite operation |
| CSC::AwaitFileWriteOptions | |
| CSC::AwaitFileWriteResult | |
| CSC::AwaitLoopWakeUp | Stable wake-up object that can resume an AwaitLoopWakeUpAwaiter from another thread |
| CSC::AwaitLoopWakeUpAwaiter | Awaiter for a single AsyncLoopWakeUp delivery |
| CSC::AwaitLoopWakeUpResult | |
| CSC::AwaitLoopWorkAwaiter | Awaiter for a single AsyncLoopWork operation |
| CSC::AwaitProcessExitAwaiter | Awaiter for a single AsyncProcessExit operation |
| CSC::AwaitProcessExitResult | |
| CSC::AwaitSignalAwaiter | Awaiter for a single one-shot AsyncSignal operation |
| CSC::AwaitSignalResult | |
| CSC::AwaitSleepAwaiter | Awaiter for a single AsyncLoopTimeout operation |
| CSC::AwaitSocketAcceptAwaiter | Awaiter for a single AsyncSocketAccept operation |
| CSC::AwaitSocketConnectAwaiter | Awaiter for a single AsyncSocketConnect operation |
| CSC::AwaitSocketReceiveAwaiter | Awaiter for a single AsyncSocketReceive operation |
| CSC::AwaitSocketReceiveExactAwaiter | Awaiter that reactivates AsyncSocketReceive until the whole caller buffer is filled |
| CSC::AwaitSocketReceiveFromAwaiter | Awaiter for a single AsyncSocketReceiveFrom operation |
| CSC::AwaitSocketReceiveFromResult | Result object populated by AwaitEventLoop::receiveFrom |
| CSC::AwaitSocketReceiveLineAwaiter | Awaiter that reads a ' '-terminated line into caller-provided storage |
| CSC::AwaitSocketReceiveLineResult | Result object populated by AwaitEventLoop::receiveLine |
| CSC::AwaitSocketReceiveResult | Result object populated by AwaitEventLoop::receive |
| CSC::AwaitSocketSendAllAwaiter | Awaiter that reactivates AsyncSocketSend until the whole buffer is sent |
| CSC::AwaitSocketSendAllBuffersAwaiter | Awaiter that sends every buffer in a scatter/gather list |
| CSC::AwaitSocketSendAwaiter | Awaiter for a single AsyncSocketSend operation |
| CSC::AwaitSocketSendResult | |
| CSC::AwaitSocketSendToAwaiter | Awaiter for a single AsyncSocketSendTo operation |
| CSC::AwaitTask | Caller-owned coroutine task returning a plain SC::Result |
| CSC::AwaitTaskGroup | Caller-storage structured group of child tasks owned by the current scope |
| CSC::AwaitTaskGroupResultSummary | |
| CSC::AwaitTaskGroupWaitAllAwaiter | Awaiter that waits for every active task in an AwaitTaskGroup |
| CSC::AwaitTaskGroupWaitAnyAwaiter | Awaiter that waits for the first active task in an AwaitTaskGroup to complete |
| CSC::AwaitTaskGroupWaitAnyResult | |
| CSC::AwaitTaskRegistry | Caller-owned fixed-slot registry for detached/background tasks |
| CSC::AwaitTaskRegistrySpawnResult | |
| CSC::AwaitTaskRegistryWaitAllAwaiter | Awaiter that waits for every valid task in an AwaitTaskRegistry |
| CSC::AwaitTaskRegistryWaitAnyAwaiter | Awaiter that waits for the first valid task in an AwaitTaskRegistry to complete |
| CSC::AwaitTaskRegistryWaitAnyResult | |
| CSC::AwaitTaskSpawnAwaiter | Awaiter that starts a child task if needed, then waits for it to complete |
| CSC::AwaitTaskTimeoutAwaiter | Awaiter that waits for a child task, cancelling it if a timeout expires first |
| CSC::AwaitTimeoutResult | |
| CSC::Barrier | A synchronization point that blocks threads until the required number of threads have reached it |
| ►CBaseClass | |
| CSC::CommandLineArguments | |
| CSC::CommandLineOption | |
| CSC::CommandLineParseResult | |
| CSC::CommandLinePositional | |
| CSC::CommandLineSpec | |
| CSC::CommandLineValue | |
| CSC::TypeTraits::Conditional< B, T, F > | Conditional defines a type to be T if a boolean value is true, F otherwise |
| CSC::ConditionVariable | A native OS condition variable |
| CSC::HttpConnectionsPool::Configuration | |
| CSC::Console | Writes to console using SC::StringFormat |
| CSC::FileSystem::CopyOperation | Specify source, destination and flags for a copy operation |
| CSC::Deferred< F > | Executes a function at end of current scope (in the spirit of Zig defer keyword) |
| CSC::TypeTraits::EnableIf< B, T > | EnableIf conditionally defines a type if a boolean template parameter is true |
| CSC::FileSystemIterator::Entry | Contains information on a file or directory |
| ►CSC::FileSystemWatcher::EventLoopRunner | Abstract class to use event loop notifications (see SC::FileSystemWatcherAsync) |
| CSC::EventObject | An automatically reset event object to synchronize two threads |
| CSC::FileDescriptorStat | A structure to describe file stats queried through a file descriptor |
| CSC::FileOpen | Options used to open a file descriptor |
| CSC::FileSystem | Execute fs operations { exists, copy, delete } for { files and directories } |
| CSC::FileSystemCopyFlags | A structure to describe copy flags |
| CSC::FileSystemIterator | Iterates files and directories inside a given path without allocating any memory |
| CSC::FileSystemStat | A structure to describe file stats |
| CSC::FileSystemWatcher | Notifies about events (add, remove, rename, modified) on files and directories |
| CSC::AwaitTask::Promise::FinalSuspend | |
| CSC::FixedVector< T, N > | |
| CSC::FixedVector< PluginBuildOption, 8 > | |
| CSC::FixedVector< PluginIdentifier, 8 > | |
| CSC::FixedVector< SC::PluginFile, 10 > | |
| CSC::FixedVector< SC::StringPath, 8 > | |
| CSC::FileSystemIterator::FolderState | Holds state of a folder when recursing into it to list its files |
| CSC::FileSystemWatcher::FolderWatcher | Represents a single folder being watched |
| CSC::Globals | Customizable thread-local and global variables for memory handling |
| CSC::GlobalSettings | Settings to initialize Globals |
| CSC::String::GrowableImplementation | |
| CSC::Hashing | Compute MD5, SHA1 or SHA256 hash for stream of data |
| CSC::HttpAsyncClient::Header | |
| CSC::Time::HighResolutionCounter | An high resolution time counter |
| CSC::HttpAsyncClient | Asynchronous HTTP/1.1 client using caller-provided fixed storage |
| CSC::HttpAsyncFileServer | Http file server statically serves files from a directory |
| CSC::HttpAsyncFileServerOptions | Options controlling optional HttpAsyncFileServer semantics |
| CSC::HttpAsyncServer | Async Http Server |
| CSC::HttpAuthorizationView | Zero-copy view of an Authorization header split into scheme and credentials |
| CSC::HttpCacheControlBuilder | Writes a Cache-Control header value into caller-provided storage |
| CSC::HttpClient | Reusable HTTP backend/session owner |
| CSC::HttpClientAsyncOperationMemoryT< T_AsyncStreams > | Caller-owned memory for one HttpClientAsyncT operation |
| CSC::HttpClientCapabilities | Compile-time backend capability report for the active HttpClient backend |
| CSC::HttpClientContentCoding | Parsed response content-coding token view |
| CSC::HttpClientContentCodingIterator | Caller-owned cursor for iterating comma-separated Content-Encoding values |
| CSC::HttpClientHeader | HTTP header name/value view |
| CSC::HttpClientOperation | One in-flight HTTP request/response operation |
| CSC::HttpClientOperationEvent | Event slot storage used by HttpClientOperation to hand off backend notifications |
| ►CSC::HttpClientOperationListener | Listener receiving response notifications during HttpClientOperation::poll |
| CSC::HttpClientOperationMemory | Caller-owned memory for one HttpClientOperation |
| ►CSC::HttpClientOperationNotifier | Optional notifier used by external adapters to wake up their own event loop |
| CSC::HttpClientOperationSchedulerMemory | Caller-owned memory for HttpClientOperationScheduler |
| CSC::HttpClientRequest | Configuration for an outgoing HTTP request |
| CSC::HttpClientRequestBody | Outgoing request body description |
| ►CSC::HttpClientRequestBodyProvider | Pull-based provider for streamed request bodies |
| CSC::HttpClientRequestOptions | Extended request options grouped by transport concern |
| CSC::HttpClientRequestProtocolOptions | HTTP protocol preference for one request |
| CSC::HttpClientRequestProxyOptions | Proxy policy for one request |
| CSC::HttpClientRequestRedirectOptions | Redirect handling policy for one request |
| CSC::HttpClientRequestTimeoutOptions | Timeout policy for one request |
| CSC::HttpClientRequestTlsOptions | TLS policy for one request |
| CSC::HttpClientResponse | Parsed response metadata filled when headers arrive |
| CSC::HttpClientResponseBuffer | Caller-owned response buffer descriptor for one HttpClientOperation |
| CSC::HttpClientResponseHeaderIterator | Caller-owned cursor for iterating response headers |
| CSC::HttpClientSession | Optional caller-owned state layer above the stateless HttpClient core |
| CSC::HttpClientSessionAuthCacheEntry | Caller-managed authorization cache entry for one exact request origin |
| CSC::HttpClientSessionAuthChallenge | Authentication challenge parsed from response headers without owning memory |
| CSC::HttpClientSessionCookie | Cookie state owned by HttpClientSession caller-provided memory |
| CSC::HttpClientSessionMemory | Caller-owned memory for the optional HttpClientSession layer |
| CSC::HttpClientSessionRetryPolicy | Retry policy used by HttpClientSessionRetryState |
| CSC::HttpClientSessionRetryState | Caller-owned retry bookkeeping for one logical request |
| CSC::HttpClientTransferCoding | Parsed response transfer-coding token view |
| CSC::HttpClientTransferCodingIterator | Caller-owned cursor for iterating comma-separated Transfer-Encoding values |
| ►CSC::HttpConnectionBase | Shared async transport storage for HTTP client and server endpoints |
| CSC::HttpConnectionsPool | A pool of HttpConnection that can be active or inactive |
| CSC::HttpCookieIterator | Iterates a request Cookie header as semicolon-delimited name/value pairs |
| CSC::HttpFormUrlEncodedIterator | Iterates raw application/x-www-form-urlencoded name/value pairs without decoding |
| CSC::HttpHeaderKeyValue | A zero-copy key/value view used by lightweight HTTP header helpers |
| ►CSC::HttpIncomingMessage | Incoming message from the perspective of the participants of an HTTP transaction |
| CSC::HttpMultipartContentDispositionView | Zero-copy view of a Content-Disposition multipart header value |
| CSC::HttpMultipartParser | Incremental HTTP multipart/form-data parser |
| CSC::HttpMultipartPartHeadersView | Zero-copy view over common multipart part headers |
| CSC::HttpMultipartWriter | |
| ►CSC::HttpOutgoingMessage | Outgoing message from the perspective of the participants of an HTTP transaction |
| CSC::HttpParser | Incremental HTTP request or response parser |
| CSC::HttpRequestTargetView | Zero-copy view over an HTTP origin-form request target |
| CSC::HttpRoute | |
| CSC::HttpRouteMatch | |
| CSC::HttpRouteParam | |
| CSC::HttpRouter | Tiny allocation-free method/path router over caller-owned routes |
| CSC::HttpSetCookieAttributeIterator | Iterates semicolon-delimited Set-Cookie attributes after the first name/value pair |
| CSC::HttpSetCookieBuilder | Writes a Set-Cookie header value into caller-provided storage |
| CSC::HttpSetCookieView | Zero-copy view of one Set-Cookie header value |
| CSC::HttpURLParser | Parse an URL splitting it into its base components |
| CSC::HttpURLQueryItem | One raw query string item parsed from a URL search component |
| CSC::HttpURLQueryIterator | Iterates raw query string items without allocation or percent-decoding |
| CSC::HttpWebSocketClientHandshake | Small client-side helper that upgrades an HttpAsyncClient connection to a WebSocket transport |
| CSC::HttpWebSocketClientHandshakeResponseView | Normalized client-side WebSocket opening handshake response data |
| CSC::HttpWebSocketConnectionPump | Optional stream pump that binds a WebSocket transport to an endpoint lifecycle |
| CSC::HttpWebSocketEndpoint | Small frame-lifecycle helper for ping / pong, close, and explicit fixed-buffer send backpressure |
| CSC::HttpWebSocketFrameHeaderView | Parsed or to-be-written WebSocket frame header |
| CSC::HttpWebSocketFrameReader | Incremental WebSocket frame reader operating on caller-owned mutable byte slices |
| CSC::HttpWebSocketFrameWriter | Incremental WebSocket frame writer operating on caller-owned header storage and payload buffers |
| CSC::HttpWebSocketHandshake | Dependency-free RFC 6455 opening handshake helpers |
| CSC::HttpWebSocketHandshakeResult | Outcome of validating a WebSocket opening handshake |
| CSC::HttpWebSocketHubClient | Fixed-slot WebSocket hub client entry |
| CSC::HttpWebSocketMessageAssembler | Optional caller-buffered message assembly helper for applications that want complete messages |
| CSC::HttpWebSocketServerHandshakeRequestView | Normalized server-side WebSocket opening handshake data |
| CSC::HttpWebSocketSmallHub | Small fixed-capacity broadcast helper for server-side WebSocket fan-out |
| CSC::HttpWebSocketTransportView | Minimal transport handoff shape for later HTTP upgrade integration |
| CSC::AsyncBufferView::ID | |
| CSC::HttpConnection::ID | |
| CSC::Process::StdOut::Ignore | |
| ►CIGrowableBuffer | |
| CSC::Process::StdIn::Inherit | |
| CSC::Process::StdOut::Inherit | |
| CSC::AsyncEventLoop::InternalDefinition | |
| ►CSC::TestReport::IOutput | |
| CSC::TypeTraits::IsBaseOf< Base, Derived > | IsBaseOf evaluates to true if the type Base is a base class of Derived, false otherwise |
| CSC::TypeTraits::IsConst< T > | IsConst evaluates to true if the provided type T is const, false otherwise |
| CSC::TypeTraits::IsLValueReference< T > | Determines if a type is an lvalue reference |
| CSC::TypeTraits::IsRValueReference< T > | Determines if a type is an rvalue reference |
| CSC::TypeTraits::IsSame< T, U > | IsSame evaluates to true if the provided types T and U are the same, false otherwise |
| CSC::TypeTraits::IsTriviallyCopyable< T > | IsTriviallyCopyable evaluates to true if the type T can be trivially copied, false otherwise |
| CSC::MaxValue | An object that can be converted to any primitive type providing its max value |
| CSC::HttpConnectionsPool::Memory | |
| CSC::Memory | Centralized functions to allocate, reallocate and deallocate memory |
| ►CSC::MemoryAllocator | Customizable functions to allocate, reallocate and deallocate memory |
| CSC::Time::Milliseconds | Type-safe wrapper of uint64 used to represent milliseconds |
| CSC::HttpAsyncFileServer::Stream::MultipartListener | |
| CSC::Mutex | A native OS mutex to synchronize access to shared resources |
| CSC::NamedPipeClient | Named pipe client endpoint creator |
| CSC::NamedPipeClientOptions | |
| CSC::NamedPipeName | Utility for building platform-native named pipe endpoint names from logical names |
| CSC::NamedPipeNameOptions | |
| CSC::NamedPipeServer | Named pipe server endpoint |
| CSC::NamedPipeServerOptions | |
| CSC::Time::Nanoseconds | Type-safe wrapper of uint64 used to represent nanoseconds |
| CSC::StringSpan::NativeWritable | |
| CSC::FileSystemWatcher::Notification | Notification holding type and path |
| ►CSC::detail::ObjectVTable< T > | |
| CSC::OpaqueObject< Definition > | Hides implementation details from public headers (static PIMPL) |
| CSC::OpaqueObject< FolderWatcherSizes > | |
| CSC::OpaqueObject< InternalDefinition > | |
| CSC::OperatingSystem | Holds information about operating system |
| CSC::FileSystem::Operations | Low level filesystem API, requiring paths in native encoding (UTF-16 on Windows, UTF-8 elsewhere) |
| CSC::AsyncEventLoop::Options | Options given to AsyncEventLoop::create |
| CSC::FileSystemIterator::Options | Options when iterating (recursive and other options) |
| CSC::Process::Options | |
| CSC::SerializationJson::Options | Formatting options |
| CSC::Path::ParsedView | Holds the various parsed components of a path |
| CSC::Time::Absolute::ParseResult | Holds information on a parsed absolute time from Absolute::parseLocal |
| CSC::HttpMultipartWriter::Part | |
| CSC::Path | Parse and compose filesystem paths for windows and posix |
| CSC::AsyncPipeline::PendingWrite | |
| CSC::PipeDescriptor | Read / Write pipe (Process stdin/stdout and IPC communication) |
| CSC::PipeOptions | |
| CSC::PluginCompiler | Compiles a plugin to a dynamic library |
| CSC::PluginCompilerEnvironment | Reads and holds CFLAGS and LDFLAGS environment variables, mainly to pass down sysroot location |
| CSC::PluginDefinition | Plugin description, category, dependencies, files and directory location |
| CSC::PluginDynamicLibrary | A plugin dynamic library loaded from a SC::PluginRegistry |
| CSC::PluginFile | Holds path to a given plugin source file |
| CSC::PluginIdentity | Represents the unique signature / identity of a Plugin |
| CSC::PluginRegistry | Holds a registry of plugins, loading and compiling them on the fly |
| CSC::PluginScanner | Scans a directory for PluginDefinition |
| CSC::PluginSysroot | Holds include and library paths for a system toolchain, used to let plugins link to libc and libc++ |
| CSC::NamedPipeServerOptions::Posix | |
| CSC::Path::Posix | |
| CSC::Process | Execute a child process with standard file descriptors redirection |
| CSC::ProcessChain | Execute multiple child processes chaining input / output between them |
| CSC::ProcessDescriptor | |
| CSC::ProcessEnvironment | Reads current process environment variables |
| CSC::ProcessExitStatus | Wraps the code returned by a process that has exited |
| CSC::ProcessFork | Forks current process exiting child at end of process A fork duplicates a parent process execution state, os handles and private memory |
| CSC::ProcessID | Native os handle to a process identifier |
| CSC::AwaitTask::Promise | Coroutine promise implementation used by AwaitTask |
| CSC::HttpAsyncFileServer::Stream::PutFileListener | |
| CSC::Time::Relative | Interval of time represented with 64 bit double precision float |
| CSC::TypeTraits::RemoveConst< T > | RemoveConst removes the const qualification from a type T |
| CSC::TypeTraits::RemoveReference< T > | Removes reference from a type T |
| CSC::AsyncReadableStream::Request | |
| CSC::AsyncWritableStream::Request | |
| CSC::HttpAsyncClient::RequestOptions | |
| CSC::Hashing::Result | |
| CSC::Result | An ascii string used as boolean result. SC_TRY macro forwards errors to caller |
| CSC::RWLock | A Read-Write lock that allows multiple concurrent readers but only one writer |
| CSC::TypeTraits::SameConstnessAs< U, T > | SameConstnessAs modifies type T to have the const-qualification of U |
| Csc_hashing_result_t | Hash result |
| Csc_hashing_span_t | Just a generic data span |
| Csc_hashing_t | Opaque object holding state of hashing |
| CSC::Time::Seconds | Type-safe wrapper of uint64 used to represent seconds |
| ►CSC::detail::SegmentHeaderOffset | |
| ►CSC::detail::SegmentTrivial< char > | |
| CSC::Semaphore | A semaphore synchronization primitive that maintains a count for resource management |
| CSC::SerializationBinary | Loads or writes binary data with its associated reflection schema from or into a C++ object |
| CSC::SerializationBinaryOptions | Conversion options for the binary versioned deserializer |
| CSC::SerializationJson | SC::SerializationJson reads or writes C++ structures to / from json using Reflection information |
| CSC::SerialOpenOptions | Open options for a serial descriptor |
| CSC::SerialSettings | Serial port settings |
| CSC::SocketClient | Use a SocketDescriptor as a client (example a TCP or UDP socket client) |
| CSC::SocketDNS | Synchronous DNS Resolution |
| CSC::SocketFlags | Flags for SocketDescriptor (Blocking / Inheritable, IPVx, SocketType) |
| CSC::SocketIPAddress | Native representation of an IP Address |
| CSC::SocketNetworking | Networking globals initialization (Winsock2 WSAStartup) |
| CSC::SocketServer | Use a SocketDescriptor as a Server (example TCP or UDP Socket Server) |
| CSC::Span< Type > | View over a contiguous sequence of items (pointer + size in elements) |
| CSC::Span< char > | |
| CSC::Span< const char > | |
| CSC::Span< const SC::CommandLineOption > | |
| CSC::Span< const SC::CommandLinePositional > | |
| CSC::Span< const SC::HttpAsyncClient::Header > | |
| CSC::Span< const SC::HttpClientHeader > | |
| CSC::Span< const SC::HttpRoute > | |
| CSC::Span< native_char_t > | |
| CSC::Span< SC::AsyncBufferView > | |
| CSC::Span< SC::AsyncReadableStream::Request > | |
| CSC::Span< SC::AsyncWritableStream::Request > | |
| CSC::Span< SC::AwaitTask * > | |
| CSC::Span< SC::AwaitTask > | |
| CSC::Span< SC::FileSystemIterator::FolderState > | |
| CSC::Span< SC::HttpClientHeader > | |
| CSC::Span< SC::HttpClientOperation * > | |
| CSC::Span< SC::HttpClientOperationEvent > | |
| CSC::Span< SC::HttpClientResponseBuffer > | |
| CSC::Span< SC::HttpClientSessionAuthCacheEntry > | |
| CSC::Span< SC::HttpClientSessionCookie > | |
| CSC::Span< SC::HttpWebSocketHubClient > | |
| CSC::Span< SC::PluginDynamicLibrary > | |
| CSC::Span< SC::Span< const char > > | |
| CSC::Span< SC::StringSpan > | |
| CSC::Span< T_AsyncBufferView > | |
| CSC::Span< T_AsyncReadableRequest > | |
| CSC::Span< T_AsyncWritableRequest > | |
| CSC::Span< uint8_t > | |
| CSC::SpanWithStride< Type > | View over a contiguous sequence of items with a custom stride between elements |
| CSC::SpanWithStride< SC::HttpConnection > | |
| CSC::MemoryAllocator::Statistics | Holds Statistics about how many allocations/release have been issued |
| ►CSC::Process::StdStream | |
| ►CSC::HttpAsyncFileServer::Stream | Support class for HttpAsyncFileServer holding file stream and pipeline |
| ►CSC::String | A non-modifiable owning string with associated encoding |
| CSC::StringAlgorithms | Algorithms operating on strings (glob / wildcard) |
| ►CSC::StringBuilder | Builds String out of a sequence of StringView or formatting through StringFormat |
| CSC::StringConverter | Converts String to a different encoding (UTF8, UTF16) |
| CSC::StringFormat< RangeIterator > | Formats String with a simple DSL embedded in the format string |
| CSC::StringFormatOutput | |
| CSC::StringIterator< CharIterator > | A position inside a fixed range [start, end) of UTF code points |
| ►CSC::StringIterator< StringIteratorASCII > | |
| ►CSC::StringIterator< StringIteratorUTF16 > | |
| ►CSC::StringIterator< StringIteratorUTF8 > | |
| CSC::StringIteratorSkipTable | Builds a constexpr bool skip table of 256 entries used in some parsers |
| CSC::StringPath | Pre-sized char array holding enough space to represent a file system path |
| ►CSC::StringSpan | An read-only view over a string (to avoid including Strings library when parsing is not needed) |
| CSC::StringViewTokenizer | Splits a StringView in tokens according to separators |
| CSC::StrongID< TagType, IDType, InvalidValue > | Strongly typed ID (cannot be assigned incorrectly to another ID) |
| ►CT_AsyncReadableStream | |
| ►CT_AsyncWritableStream | |
| CSC::TestCase | A test case that can be split into multiple sections |
| CSC::TestReport | Collects multiple TestCase and reports their results |
| CSC::Thread | A native OS thread |
| CSC::ThreadPool | Simple thread pool that executes tasks in a fixed number of worker threads |
| CSC::ThreadPoolTask | A small task containing a function to execute that can be queued in the thread pool |
| ►CSC::TimeMs | A vocabulary type representing a time interval in milliseconds since epoch |
| CSC::UniqueHandle< Definition > | Move only handle that has a special tag value flagging its invalid state |
| ►CSC::UniqueHandle< detail::FileDescriptorDefinition > | |
| ►CSC::UniqueHandle< detail::SocketDescriptorDefinition > | |
| CSC::VectorMap< Key, Value, Container > | A map holding VectorMapItem key-value pairs in an unsorted Vector |
| CSC::VectorMapItem< Key, Value > | The single item of VectorMap, holding a Key and Value |
| CSC::VectorSet< Value, Container > | A set built on an unsorted Vector, ensuring no item duplication |
| CSC::VirtualArray< T > | An array using a large virtual memory reservation to keep stable addresses |
| CSC::VirtualMemory | Reserves a contiguous slice of virtual memory committing just a portion of it |
| ►CVTable | |
| CSC::NamedPipeClientOptions::Windows | |
| CSC::Path::Windows |
1.12.0