| Base | |
| C128Bits | |
| C128Bits::v128_t | |
| CAccumulationBuffer | |
| CAccumulationBuffer | |
| CAccumulationBuffer | |
| CActivatableObject | |
| CActivatableObject::Callback | |
| CActivatableObject::CommandData | |
| CActivatableObject::CommandProcessorCallback | |
| CActivatableObject::CommandWrapper | |
| CActivatableObject::CommandWrapperEx | |
| CActivatableObject::IProcessQueuedCommand | |
| CActivatableObject::QueuedCommands | |
| CAddress | Essentially a smart pointer to a CAddressImpl instance |
| CAddressImpl | A reference counted wrapper around a SOCKADDR_STORAGE structure that knows how big the address that's stored is |
| CAddressInfo::Iterator | An iterator to addresses that are supported by the host |
| CAddressIPv4 | An IPv4 address |
| CAddressIPv6 | An IPv6 address |
| CAddressRenderer | An implementation of IRenderAddresses |
| CAddressType | A generic implementation of the IAddressType interface. Should be suitable for all types of addresses, just supply the appropriate values to the constructor |
| CAddressTypeIPv4 | A implementation of the IAddressType interface for IPv4 |
| CAddressTypeIPv6 | A implementation of the IAddressType interface for IPv6 |
| CAddressWrapper | A facade that allows a SOCADDR * to be accessed via the IAddress interface |
| CAES128ICM | |
| CAllFrameworkDebugLogs | |
| CAllFrameworkDebugLogsConfigurationCallback | |
| CApplicationProtocolSelection | |
| CAsyncConnector | |
| CAsyncConnector | |
| CAsyncConnector | |
| CAsyncConnector::ICallback | |
| CAsyncConnector::ICallback | |
| CAsyncConnector::IDataAvailable | |
| CAsyncFileLog | |
| CAsyncFileLog | A class that implements JetByteTools::Core::ILogMessages to provide an asynchronous file log that uses overlapped I/O to perform writes to the log file. This class allows you to change the name of the log file after creation but this functionality should be externally synchronised with any use of the various LogMessage() calls and any calls on the IWaitable interface to ensure that SetLogName() is never called concurrently to one of the other calls. The reason that we require YOU to do this synchronisation work is that when used carefully (i.e. SetLogName() is never called when the class is being used by multiple threads) then there is no need to synchronise the calls to LogMessage() |
| CAsyncFileReader | A class that implements IHandler to provide an asynchronous file reader that uses overlapped I/O to perform reads from the file. Data read from the file is provided in a 'push fashion' via the CAsyncFileReader::Callback interface |
| CAsyncFileReader::Callback | An interface for users of the CAsyncFileReader to be notified of the results of the asynchronous read operations on the file |
| CAsyncFileWriter | A class that implements IHandler to provide an asynchronous file writer that uses overlapped I/O to perform writes to the file. Any errors that occur during the asynchronous file writes are reported via the CAsyncFileWriter::Callback interface |
| CAsyncFileWriter::Callback | An interface for users of the CAsyncFileWriter to be notified of any errors that occur during the asynchronous write operations on the file |
| CAsyncFileWriterEx | A class that implements IHandler to provide an asynchronous file writer that uses overlapped I/O to perform writes to the file. Any errors that occur during the asynchronous file writes are reported via the CAsyncFileWriter::Callback interface |
| CAsynchronousFileBackedH264InterleavedTCPRTPStream | |
| CAsynchronousFileBackedH264RTPStream | |
| CAsynchronousFileBackedH264UDPRTPStream | |
| CAsynchronousH264FileReader | |
| CAsyncSocketConnector | |
| CAsyncSocketConnector::ICallback | |
| CAtomicBool | |
| CAtomicCounter | |
| CAtomicCounter::Decrementer | |
| CAtomicCounter::Incrementer | |
| CAutoDetectProtocolHandler | |
| CAutoDetectProtocolHandlerAllocator | |
| CAutoResetEvent | |
| CAutoResetEvent | A class that wraps the operating system Event API and exposes just the interface for an auto reset event |
| CBitParser | |
| CBuffer | An implementation of the IBuffer interface which includes its own custom new and delete functionality so that the memory for the buffer and the memory for the rest of the class are allocated as a single block of memory. Note that the 'user data' is also allocated as part of the main buffer memory and the class knows how to access the various memory areas correctly. Note that the buffers may be allocated using VirtualAlloc() to align the memory on page boundaries; in this case, it's best to create buffers with a size that is a multiple of the system's page size less the size of the buffer object, see CBufferAllocator for more details |
| CBufferAllocator | |
| CBufferAllocator | An implementation of IAllocateBuffers which pools buffer instances for later reuse |
| CBufferBasedBufferAllocator | |
| CBufferChain | |
| CBufferChainStoresNulls | |
| CBufferFacadeOnRawMemory | |
| CBufferHandle | An implementation of IBuffer that provides a separate WSABUF for another implementation of IBuffer. This is used to broadcast the contents of an IBuffer to multiple receivers without needing to copy the data in the buffer. Each receiver has a CBufferHandle allocated which is attached to the IBuffer that contains the data that needs to be broadcast. When the final send completes the references held by the CBufferHandle objects on the IBuffer will fall to 0 and the buffer will be released |
| CBufferHandleAllocator | |
| CBufferHandleAllocator | An implementation of IAllocateBufferHandles which pools buffer handle instances for later reuse |
| CBufferHistory | |
| CBufferProcessor | |
| CBufferRingBuffer | |
| CCachedValueTickCountProvider | |
| CCallbackTimerQueueEx | A class that manages a group of timers that implement IQueueTimers::Timer and which have their IQueueTimers::Timer::OnTimer() method called when the timer expires. You must manually manage the handling and processing of timeouts by calling IManageTimerQueue::BeginTimeoutHandling() every IManageTimerQueue::GetNextTimeout() milliseconds. See here for more details. Note: the maximum timeout that you can set is 4294967294ms as 0xFFFFFFF is reserved as 'INFINITE' i.e. a timer that never expires. Internally the code uses an unsigned 64 bit counter which will wrap in around 584942417.4 years from the creation of the timer queue. You cannot set a timer that crosses this wrap point and an exception will be thrown. GetMaximumTimeout() does not report the reducing maximum timeout as the wrap point approaches, it will always return 4294967294ms |
| CCallbackTimerWheel | |
| CCallStack | |
| CCallStackCreator | |
| CCertificate | |
| CClientContext | |
| CClientContext | |
| CClientImpersonator | |
| CCLREventSink | A class that manages subscriptions to CLR events via the IActionOnCLREvent interface |
| CCLRGCManager | |
| CCLRHost | A class that hosts the CLR in unmanaged code |
| CCLRHostFactory | |
| CCLRMetaHost | |
| CCLRPolicyManager | |
| CCodePage | |
| CCommandLine | |
| CCommandLine | A class that parses the command line and can report on whether specified switches or arguments have been passed to a program |
| CCompareStrings | |
| CConnectionLimiter | An implementation of ILimitConnections |
| CConnectionMaintainingStreamSocketConnectionFilter | A connection filter that will attempt to reconnect connections that are terminated after a configurable timeout. You can indicate that you want a connection to be maintained by calling MaintainConnections() and you can allow the connection to close and stay closed by calling CancelConnectionRetries() |
| CContext | |
| CContext | |
| CContext | |
| CCountedCertificateContext | |
| CCountedCertificateStoreHandle | |
| CCountedCredentialsHandle | |
| CCountedRegKey | |
| CCountedSecurityContext | |
| CCounterStorageAllocator | |
| CCrashDumpGenerator | |
| CCreateSimpleContext | |
| CCreateSimpleContext::CertificateDetail | |
| CCredentials | |
| CCredentials | |
| CCredentials::Data | |
| CCredentials::Data | |
| CCrtReportHook | |
| CCustomPoolBufferAllocator | |
| CCustomPoolSmartBuffer | |
| CDatabaseConnection | |
| CDatabaseConnection::Exception | |
| CDatabaseConnection::Transaction | |
| CDatabaseConnectionDetails | |
| CDataCompressor | |
| CDataDeflator | |
| CDataDeflatorFactory | |
| CDatagramServerSocket | A datagram socket that allows you to SendTo() any host but restricts who you can RecvFrom(), basically you can only recv data from the port that the associated server is listening on |
| CDatagramServerSocketAllocator | |
| CDatagramServerSocketAllocator | A socket allocator that allocates datagram server sockets. Note that most of the work is down in CSocketAllocator |
| CDatagramSocket | A datagram socket that allows you to RecvFrom() and SendTo() any host |
| CDatagramSocketAllocator | |
| CDatagramSocketAllocator | A socket allocator that allocates datagram sockets. Note that most of the work is down in CSocketAllocator |
| CDatagramSocketConnectionManagerBase | A connection manager for datagram sockets |
| CDatagramSocketConnectionManagerCallback | |
| CDatagramSocketConnectionManagerCallback | An object that implements the CDatagramSocketConnectionManager callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CDatagramSocketServerBase | A socket server for datagram sockets |
| CDatagramSocketServerCallback | |
| CDatagramSocketServerCallback | An object that implements the CIDatagramSocketServer callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CDataInflator | |
| CDebugLog | |
| CDebugLog | |
| CDebugLog | |
| CDebugLog | |
| CDebugLog | |
| CDebugLogBase | |
| CDebugLogBase::SubSystemDetails | |
| CDebugLogFileConfigManager | |
| CDebugLogFileConfigManager | |
| CDebugLogFileConfigManager | |
| CDebugLogFileConfigManager | |
| CDebugServiceDispatcher | |
| CDebugServiceDispatchThread | |
| CDebugTrace | |
| CDebugTrace::LogInstaller | A class that takes an instance of ILogMessages and installs it as the message log used by the CDebugTrace class and then removes it and reinstalls the previous log in its destructor. It can, therefore, be used to support scope based log installation and removal |
| CDirectoryChangeMonitor | |
| CDirectoryChangeMonitor::Callback | |
| CDirectorySearch | A simple class that wraps the FindFirstFile() /FindNextFile() API |
| CDiskSpaceProvider | |
| CDispatchRestrictor | |
| CDispatchRestrictor::AllowDispatch | |
| CDispatchRestrictor::AllowDispatchForThisSocket | |
| CDynamicObjectTrackerCollection | |
| CEmptyBase | |
| CEnvironmentBlock | A class for building and manipulating operating system Environment Blocks |
| CEnvironmentVariables | A class that wraps the operating system Environment Variable API |
| CErrorCodeException | A simple exception class |
| Certificate | |
| CEvent | A class that wraps the operating system Event API. See here for more details |
| CEvent | |
| CEventLog | |
| CEventOwner | A class that manages an instance of CEvent in a scope based style |
| CException | |
| CException | A simple exception class |
| CException | |
| CException | |
| CException | |
| CFiberLocalStorage | |
| CFileBasedCertificateStore | |
| CFileDeleter | |
| CFileInputStream | An object that implements IInputStream on a file |
| CFileOutputStream | An object that implements ICloseableOutputStream on a file |
| CFilterDataBase | |
| CFilterDataBase::ICallback | |
| CFilterDataBase::ICallback | |
| CFilterHolder | |
| CFilterHolder | |
| CFilteringDatagramSocketConnectionManagerBase | |
| CFilteringStreamSocketConnectionManagerBase | A connection manager for stream sockets |
| CFixedFileHeaderRotatingAsyncFileLog | A class that implements JetByteTools::ILogMessages to provide an asynchronous file log that uses overlapped I/O to perform writes to the log file. The log can be set to automatically rotate (i.e. create a new log file) after a set period of time or when the file grows to a particular size |
| CFixedValueTickCountProvider | |
| CFlowControlDatagramSocketConnectionFilter | |
| CFlowControlDatagramSocketConnectionFilterData | |
| CFlowControlListProcessor | A connection filter that will manage the flow of data on a connection so as to prevent uncontrolled resource usage if there is more data to send than the connection can manage. The filter monitors the rate at which writes that are issues on the connection are completing. If the rate is slower than the rate at which new writes are being issued on the connection then the filter begins to buffer the data in a list and will send it when the connection has capacity. If the list exceeds a predefined maximum amount of buffered data then the filter will either begin to discard data either in a FIFO or LIFO order or it will call a callback method that you supply and give you the list to deal with |
| CFlowControlStreamSocketConnectionData | |
| CFlowControlStreamSocketConnectionFilter | A connection filter that will manage the flow of data on a connection so as to prevent uncontrolled resource usage if there is more data to send than the connection can manage. The filter monitors the rate at which writes that are issues on the connection are completing. If the rate is slower than the rate at which new writes are being issued on the connection then the filter begins to buffer the data in a list and will send it when the connection has capacity. If the list exceeds a predefined maximum amount of buffered data then the filter will either begin to discard data either in a FIFO or LIFO order or it will call a callback method that you supply and give you the list to deal with |
| CFlowControlStreamSocketConnectionFilter::IProcessBufferList | |
| CFrameworkDebugLogs | |
| CFrameworkDebugLogsConfigurationCallback | |
| CFullAddress | A class that uses hard coded assumptions to fabricate "full addresses" from a SOCADDR structure and and is somewhat fragile in the face of new address family support. Essentially we guess the protocol, which isn't that hard |
| CFullAddressWrapper | A facade that allows a SOCADDR * to be accessed via the IFullAddress interface. Note that this has to use some hard coded assumptions to fill in the missing bits that aren't contained in a SOCADDR structure and so will be somewhat fragile in the face of new address family support |
| CGlobalErrorHandler | |
| CGlobalName | A kernel object name that is globally visible in the kernel object namespace |
| CH264FrameProcessor | |
| CH264FrameSource | |
| CH264NALUnit | |
| CH264ParameterSetReader | |
| CH264RTPSource | |
| CH264SequenceParameterSetParser | |
| CH264SliceHeaderParser | |
| CH264StreamParser | |
| CH264StreamReader | |
| CHandshakeParser | |
| CharReader | Interface for reading JSON from a char array |
| CharReader | Interface for reading JSON from a char array |
| CharReader::Factory | |
| CharReader::Factory | |
| CharReaderBuilder | |
| CharReaderBuilder | |
| CHeaders | |
| CHeapMemoryPerformanceDataBlock | |
| CHeapMemoryPerformanceDataBlockFactory | |
| CHeapMemoryPerformanceMonitorCounters | An object which represents an installed set of performance counters in memory in an application that wishes to export those counters. This object is created from a CPerformanceDataSchema and provides methods for an application which exports counters to create and manipulate a set of counters. These counters can then be consumed by an instance of CPerformanceDataCollector which has been created with the same schema. The object supports the JetByteTools::Win32::ICriticalSection interface so that you can lock the entire set of counters if you need to during updates to ensure that updates are atomic, however, this is very rarely required. Each individual counter update can be guaranteed to be atomic without the need for external locking |
| CHighResolutionTickCountProvider | |
| CHLSFileResource | |
| CHLSH264LiveResource | |
| CHLSLiveResource | |
| CHLSMemoryCacheResourceData | |
| CHLSResource | |
| CHostAssemblyManager | A class that provides a default implementation of the CLR assembly mangement interfaces; IHostAssemblyManager and IHostAssemblyStore |
| CHostControl | |
| CHostPolicyManager | A class that provides a default implementation of the CLR assembly mangement interfaces; IHostPolicyManager |
| CHTTP_1_0_Parser | |
| CHTTP_1_0_RequestParser | |
| CHTTP_1_0_ResponseParser | |
| CHTTPConnection | |
| CHTTPException | |
| CHTTPFileResource | |
| CHTTPFileResourceData | |
| CHTTPHeaders | |
| CHTTPMemoryResource | |
| CHTTPMemoryResourceData | |
| CHTTPRequest | |
| CHTTPRequestProcessor | |
| CHTTPResource | |
| CHTTPResourceManager | |
| CHTTPResponse | |
| CHTTPSocketServer | |
| CHTTPWriteException | |
| CICEControlledDTLSConnection | |
| CICEControlledDTLSConnectionFactory | |
| CIndexedOpaqueUserData | |
| CInMemoryCertificateStore | |
| CInMemoryCertificateStore::Iterator | |
| CInterleavedTCPRTPStream | |
| CIntrusiveMultiMapNode | |
| CIntrusiveRedBlackTreeNode | |
| CIOCompletionPort | A simple wrapper around the I/O Completion Port API. I/O completion ports are, essentially, thread safe queues that can control how many threads are allowed to run and process items on the queue in a way that simply isn't possible if you stay entirely in "user mode". The queue keeps the threads that are waiting in fifo order to minimise memory paging and can limit the number of 'runable'threads that it releases. See here and here for more details |
| CIOCPWorkerThread | A thread that services completion packets from an I/O completion port |
| CIOPool | |
| CIOPool | An I/O thread pool implementing IIOPool |
| CIOPool::WorkerThread | A worker thread class for the CIOPool |
| CIOPoolBase | An I/O thread pool implementing IIOPool |
| CIOPoolBase::WorkerThread | |
| CIOPoolBase::WorkerThread | A worker thread class for the CIOPoolBase |
| CIOPoolEx | |
| CIOPoolEx | An I/O thread pool implementing IIOPool |
| CIOPoolEx::WorkerThread | A worker thread class for the CIOPoolEx |
| CIORecursionLimiter | |
| CIORecursionLimiter::Call | |
| CIterateUnknown | |
| CJob | A class for manipulating operating system job objects |
| CJobEventManager | |
| CJobEventManager | A class for manipulating operating system job objects |
| CJSONConfiguration | |
| CJSONDocument | |
| CJSONValue | |
| CKernelObjectNameImpl | Implements IKernelObjectName in such a way that it's easy to provide an arbitrary prefix to an unqualified name for use in the kernel object namespace |
| CLibraryLoader | A class which dynamically loads dlls |
| CLiveH264InterleavedTCPRTPStream | |
| CLiveH264RTPStream | |
| CLiveH264UDPRTPStream | |
| CLocalName | A kernel object name that is locally visible in the kernel object namespace |
| CLocalTimeProvider | |
| CLockableObject | |
| CLockableObject | |
| CLockableObjectTracksLockingThread | |
| CLoggingAsyncFileWriterCallback | A class that implements CAsyncFileWriter::Callback and logs errors and when the pending write limit is reached |
| CManualResetEvent | |
| CManualResetEvent | A class that wraps the operating system Event API and exposes just the interface for an manual reset event |
| CMD5 | |
| CMemoryBasedMessageLog | An object that implements ILogMessages and |
| CMemoryCacheStreamDataFile | |
| CMemoryInputOutputStream | An object that implements IInputStream and ICloseableOutputStream on a memory buffer |
| CMemoryInputStream | An object that implements IInputStream on a memory buffer |
| CMemoryMappedFile | A class that wraps the MapViewOfFile() API |
| CMessageLog | An object that implements ILogMessages and and allows other implementations to be plugged into it.. |
| CMiniDumper | |
| CMiniDumpGenerator | |
| CMiniDumpGenerator::SmartDiskSpaceProvider | |
| CMPEG2TransportStreamWriter | |
| CMultipleFileDeleter | |
| CMutex | |
| CNamedIndex | A class that provides a collection of named indices. That is it allows you to Add() or Find() a name to a collection and return an index that identifies that name within the collection. Once you have added as many names as you wish you can convert the collection of names into a read-only collection by calling Lock() on the collection. The class is designed to be used to allow unrelated blocks of code to request a unique index for use in accessing opaque user data from an instance of IIndexedOpaqueUserData. The blocks of code needing an index typically request one by name (usually based on the name of the class doing the requesting). Once all names have been requested, Lock() is called and the size of the user data block required is calculated by calling GetMaxIndexValue() to return the number of indices requested |
| CNamedPipe | A simple wrapper around the Named Pipe API |
| CNamedServerCollection | A class that implements a collection of named instances of IServerControl and that allows you to control all of the instances as one and also manipulate individual instances by name |
| CNetworkInterfaceAddresses::Iterator | |
| CNodeList | An invasive doubly linked list where classes that wish to be nodes in the list must derive from CNodeList::Node. The list allows nodes to remove themselves from the list as a constant time operation |
| CNodeList::Node | The node class that classes must derive from to be able to be stored in the list |
| CNTPTime | |
| CNullAsyncFileReaderMonitor | An object that implements IMonitorAsyncFileReader and does nothing |
| CNullAsyncFileWriterMonitor | An object that implements IMonitorAsyncFileWriter and does nothing |
| CNullBufferAllocationMonitor | An object that implements IMonitorBufferAllocation and does nothing |
| CNullBufferPool | |
| CNullCallbackTimerQueueMonitor | An object that implements IMonitorCallbackTimerQueue and does nothing |
| CNullConfiguration | |
| CNullDatagramSocketConnectionFilter | A connection filter that does nothing. You can use this as a base class for your own filter if you don't need to override all of the filter functionality |
| CNullDatagramSocketFlowControlMonitor | |
| CNullDebugLogConfigurationCallback | |
| CNullEnvironmentBlockProvider | An implementation of IProvideEnvironmentBlock that always returns a null block |
| CNullEventSinkCallback | An implementation of IEventSinkCallback that does nothing |
| CNullJobMonitor | An object that implements IMonitorThreadPool and does nothing |
| CNullMessageLog | An object that implements ILogMessages and does nothing |
| CNullNamedServerShutdownCallback | |
| CNullRTPStream | |
| CNullServerShutdownCallback | |
| CNullSocketAllocationMonitor | An object that implements IMonitorSocketAllocation and does nothing |
| CNullStreamDataFile | |
| CNullStreamSocketConnectionFilter | A connection filter that does nothing. You can use this as a base class for your own filter if you don't need to override all of the filter functionality |
| CNullStreamSocketFlowControlMonitor | A stream socket flow control monitor that does nothing. You can use this |
| CNullThreadedCallbackTimerQueueMonitor | An object that implements IMonitorCallbackTimerQueue and does nothing |
| CNullThreadPoolMonitor | An object that implements IMonitorThreadPool and does nothing |
| CODBCConnection | |
| CODBCEnvironment | |
| CODBCException | |
| CODBCSmartHandle | |
| CODBCStatement | |
| CODBCTransaction | |
| COneWayToggle | |
| COpaqueUserData | A class that provides a single instance of 'opaque user data' (that is data that is stored as either a void * or an unsigned long and that is basically anything that the user wants to store). This represents a single storage location so a call to GetUserPointer() and GetUserData() will return the same data, just viewed in different ways |
| Core::IWaitable | |
| COSVersionInfo | A simple class that wraps, and initialises, an OSVERSIONINFO structure |
| COverlapped | A class that wraps an OVERLAPPED structure |
| COverlappedWithEvent | A class that wraps an OVERLAPPED structure that uses an event |
| CPendingWriteLimiter | An implementation of ILimitConnections |
| CPerformanceCounter | A class that wraps the QueryPerformanceCounter() API for high performance timing of sections of code |
| CPerformanceCounterInstaller | An object which implements IInstallPerformanceMonitorCounters and which can be used to install performance counters into a system |
| CPerformanceCounterLogger | |
| CPerformanceCounterMonitor | |
| CPerformanceDataBlock | |
| CPerformanceDataCollector | An object which implements ICollectPerformanceData and represents an installed set of performance counters in memory in a perfmon performance extension dll that wishes to monitor those counters. This object is created from a CPerformanceDataSchema and provides methods for an dll which conforms to the requirements for a performance data collection dll to integrate with perfmon |
| CPerformanceDataSchema | An object which can be used to create a schema for a set of performance counters. A performance counter schema is created to define the counters that are required and is used in the process which is exporting the counters and in the DLL which is loaded into perfmon to collect the performance data |
| CPerformanceDataSchema::Object | |
| CPerformanceDataSchemaFileExporter | A class which exports CPerformanceDataSchema in the form required by the LoadPerfCounterTextStrings API |
| CPerformanceMonitorCountersBase | An object which represents an installed set of performance counters in memory in an application that wishes to export those counters. This object is created from a CPerformanceDataSchema and provides methods for an application which exports counters to create and manipulate a set of counters. These counters can then be consumed by an instance of CPerformanceDataCollector which has been created with the same schema. Each individual counter update can be guaranteed to be atomic without the need for external locking |
| CPerThreadErrorHandler | |
| CPerThreadUsageTracker | |
| CPerThreadUsageTracker::Stats | |
| CPINFOEX | |
| CProcess | A class for processes |
| CProcessInformation | A simple class that wraps, and cleans up after, a PROCESS_INFORMATION structure |
| CProcessMemory | A class which allocates and accesses memory in a specified process |
| CProcessToken | |
| CProcessToken::Enabler | |
| CProcessToken::OptionalEnabler | |
| CProcessToken::Privilege | |
| CProtocolHandler | |
| CProtocolHandlerAllocator | |
| CProtocolHandlerFactory | |
| CQueueSpaceNotifier | |
| CRAIIAtomicBool | |
| CRAIIBool | |
| CRandomByteProvider | |
| CRandomNumberProvider | |
| CRandomSSRCAllocator | |
| CRateLimiter | |
| CRawImage | |
| CReadAccumulationBuffer | |
| CReadOnlyFilterData | |
| CReadSequencingStreamSocketConnectionFilter | A connection filter that filters read completions and reorders the completions so that they occur in the order of the sequence numbers in their buffers |
| CReadTimeoutDatagramSocketConnectionFilter | A connection filter that filters supplied read timeout functionality. A call to SetReadTimeout() on a socket will set a timeout for every read operation or revc from operation that is issued on the socket. If the timeout expires then the TimerCallback::OnTimer() method of the callback that was passed to the call to SetReadTimeout() is called with the socket and user data. If you require different user data and/or timer callbacks for a particular timeout then you can call SetSingleReadTimeout() to specify this information. Normal usage is to call SetReadTimeout() when the connection is established and then, possibly, call SetSingleReadTimeout() when the 'default' timeout occurs on a socket to change the timeout parameters from this point on... Call CancelReadTimeout() to stop setting timeouts on all future reads (and to cancel any currently pending timeout) and CancelPendingTimeout() to just cancel any currently pending timeouts but to continue to set timeouts on all subsequent read operations |
| CReadTimeoutDatagramSocketConnectionFilter::TimerCallback | |
| CReadTimeoutStreamSocketConnectionFilter | A connection filter that filters supplied read timeout functionality. A call to SetReadTimeout() on a socket will set a timeout for every read operation that is issued on the socket. If the timeout expires then the TimerCallback::OnTimer() method of the callback that was passed to the call to SetReadTimeout() is called with the socket and user data. If you require different user data and/or timer callbacks for a particular timeout then you can call SetSingleReadTimeout() to specify this information. Normal usage is to call SetReadTimeout() when the connection is established and then, possibly, call SetSingleReadTimeout() when the 'default' timeout occurs on a socket to change the timeout parameters from this point on... Call CancelReadTimeout() to stop setting timeouts on all future reads (and to cancel any currently pending timeout) and CancelPendingTimeout() to just cancel any currently pending timeouts but to continue to set timeouts on all subsequent read operations |
| CReadTimeoutStreamSocketConnectionFilter::TimerCallback | |
| CRecursiveDirectorySearch | A simple class that wraps the FindFirstFile() /FindNextFile() API |
| CReentrantLockableObject | |
| CReentrantLockableObject | |
| CReentrantLockableObject | |
| CReentrantLockableObjectTracksLockingThread | |
| CReentrantLockableObjectTracksLockingThread | |
| CReferenceCount | |
| CRegistryConfiguration | |
| CRegistryKey | |
| CRegistryKey::Exception | |
| CRegistryKey::Exception | |
| CRegistryKey::SubkeyIteratorImpl | |
| CRegistryKey::Value | |
| CRegistryKey::Value::Exception | |
| CRegistryKey::ValueIteratorImpl | |
| CRegKeyIterator | |
| CRequestHeaders | |
| CRequestHeaders | |
| CRequiresElevationException | |
| CRetryAndRenameFileCreationFailureHandler | |
| CRingBuffer | |
| CRotatingAsyncFileLog | A class that implements JetByteTools::ILogMessages to provide an asynchronous file log that uses overlapped I/O to perform writes to the log file. The log can be set to automatically rotate (i.e. create a new log file) after a set period of time or when the file grows to a particular size |
| CRoundTripTime | |
| CRoundTripTimes | |
| CRTCPPacketGenerator | |
| CRTPBroadcastPacketCache | |
| CRTPFrameProcessor | |
| CRTPPacketCreator | |
| CRTPPacketStream | |
| CRTSP_1_0_RequestParser | |
| CRTSPConnection | |
| CRTSPH264FileResource | |
| CRTSPH264LiveResource | |
| CRTSPMP3FileResource | |
| CRTSPMultipleFileResource | |
| CRTSPResourceManager | |
| CRTSPServer | |
| CRTSPSession | |
| CSafeArrayHelpers | |
| CSecureConnectData | |
| CSecureConnectShim | |
| CSecureConnectShim | |
| CSecureConnectShim | |
| CSecurityAttributes | A simple class that wraps, a SECURITY_ATTRIBUTES structure |
| CSecurityBuffer | |
| CSecurityDescriptor | A simple class that wraps, and initialises, a SECURITY_DESCRIPTOR structure |
| CSecurityDescriptorAllowAll | A simple class that represents a decurity descriptor that allows access to all users |
| CSecurityPrivilege | |
| CSecurityPrivileges | |
| CSEHException | |
| CSEHException::Translator | A class that acts as a structured exception translator. Create one of these objects on each thread where you want Win32 structured exceptions translated into CSEHException |
| CSemaphore | |
| CSemaphore | A class that wraps the operating system Semaphore API |
| CSequencedBufferCollection | A class that manages a collection of IBuffer instances which have a unique and ascending sequence number in them. You are allowed to push buffers into the collection in any order and to retrieve them only in the correct sequence. If you try and retrieve a buffer when the required buffer is not present then the collection will return null. Typical usage is to ensure the correct ordering of multiple overlapped read completions. All buffers are pushed into the collection using GetNext() and a buffer is only returned to the caller for processing if it is the next in sequence. This class takes a reference on a buffer when it is added to the collection and requires that the user of a buffer that has been removed from the collection releases that reference when done |
| CSequencedStreamSocket | A stream socket that supports read and write sequencing |
| CSequencedStreamSocketAllocator | |
| CSequencedStreamSocketAllocator | A socket allocator that allocates instances of CSequencedStreamSocket Note that most of the work is down in CSocketAllocator |
| CServerCollection | A class that implements a collection of instances of IServerControl and that allows you to control all of the instances as one |
| CServerContext | |
| CServerContext | |
| CService | |
| CServiceCallbacks | |
| CServiceConfigData | |
| CServiceControlDispatcher | |
| CServiceControlManagerInterface | |
| CServiceInstanceManager | |
| CServiceManager | |
| CServiceManagerBase | |
| CServiceStatus | |
| CSHA1 | |
| CSHA1 | |
| CSharedMemory | A wrapper around the File Mapping, memory management, API which makes shared memory easier to use. Note that this class creates shared memory and if you pass in a name that's in the Global namespace then the caller needs to have the SeCreateGlobalPrivilege on their account for the code to work without an access denied exception from the constructor |
| CSharedMemoryMutexPerformanceDataBlock | |
| CSharedMemoryMutexPerformanceMonitorCounters | |
| CSharedMemoryPerformanceDataBlock | |
| CSharedMemoryPerformanceMonitorCounters | |
| CShutdownHandler | |
| CSimpleFixedSizedMemoryAllocator | A class that provides naive fixed sized memory allocation. Note that once the allocator has requested memory from the operating system it never returns it to the operating system, it simply keeps it around until another allocation request can use it. So, if you allocate 1000 1024 byte blocks and then free them all the allocator itself is still holding on to 1024000 bytes of memory. The allocator uses VirtualAlloc() to allocate the memory that it uses, this allows it to provide page aligned memory if requested to do so. It also means that internally it works in terms of multiples of the system's allocation granularity when allocating chunks of memory that it can slice up into blocks to return to the caller. Also, if you specify that you want page alignment and the memory block size that you're using is smaller than an exact page multiple then the difference between the block size and the next multiple of the page size will be 'wasted' |
| CSimpleFixedSizedMemoryAllocator::AllocationTuningParameters | |
| CSimpleMessageLog | An object that implements ILogMessages and |
| CSimpleNamedPipeClient | A wrapper around the Named Pipe API which makes it easy to manage named pipe clients |
| CSimpleNamedPipeServer | A wrapper around the Named Pipe API which makes it easy to manage named pipe servers. The pipes created are read/write, overlapped, message oriented pipes |
| CSimpleServerShutdownHandler | |
| CSimpleServiceStartupEventHandler | |
| CSimpleSQLConnection | |
| CSlimLockableObject | |
| CSlimLockableObject | |
| CSlimLockableObjectTracksLockingThread | |
| CSlimReentrantLockableObject | |
| CSlimReentrantLockableObject | |
| CSlimReentrantLockableObjectTracksLockingThread | |
| CSlimReentrantLockableObjectTracksLockingThread | |
| CSList | A class which wraps the operating system SLIST API |
| CSList::Node | A node in a CSList |
| CSmartBool | |
| CSmartHandle | A smart pointer to a HANDLE. Calls CloseServiceHandle() on any SC_HANDLE that the it owns when the CSmartHandle goes out of scope to in scope based designs |
| CSmartHandle | A smart pointer to a HANDLE. Calls CloseHandle() on any HANDLE that the it owns when the CSmartHandle goes out of scope to aid in scope based designs |
| CSmartHeapPointer | A smart pointer to memory using the HeapAlloc() API. Calls HeapFree() on any memory that the CSmartHeapPointer owns when it goes out of scope to aid in scope based designs |
| CSmartHGlobal | |
| CSmartHGlobalLock | |
| CSmartLocalPointer | A smart pointer to memory using the LocalAlloc() API. Calls LocalFree() on any memory that the CSmartLocalPointer owns when it goes out of scope to aid in scope based designs |
| CSmartStartupInfo | A simple class that wraps, and initialises, an STARTUPINFO structure and manages the lifetime of any handles within it |
| CSocket | A slightly confused class that acts as both a scope based wrapper around a SOCKET and that also provides static member functions that enable you to call wrapped socket functions on a bare SOCKET |
| CSocketAllocator | A base class for socket allocation. There are several different types of socket that are used through the library. Most of the work involved in allocating sockets and managing a pool of sockets is the same for all types. The only things that change are the type of the socket that is being allocated and the way the socket is created. Derived classes provide this functionality |
| CSocketClosedException | An exception that can be thrown if you attempt an operation on a socket that is closed |
| CSortedBufferChain | |
| CSortedBufferProcessor | |
| CSRTPKeyingMaterial | |
| CSSLStreamValidator | |
| CStartupInfo | A simple class that wraps, and initialises, an STARTUPINFO structure |
| CStreamDataFile | |
| CStreamDataFileFactory | |
| CStreamSocket | A stream socket. Note that this socket does NOT support read and write sequencing |
| CStreamSocketAllocator | |
| CStreamSocketAllocator | A socket allocator that allocates instances of CStreamSocket. Note that most of the work is down in CSocketAllocator |
| CStreamSocketBroadcastableConnectionCollection | |
| CStreamSocketBroadcastableNamedConnectionCollection | |
| CStreamSocketConnectionCollection | |
| CStreamSocketConnectionFilter | |
| CStreamSocketConnectionFilter | |
| CStreamSocketConnectionFilter | |
| CStreamSocketConnectionFilterBase | |
| CStreamSocketConnectionManager | |
| CStreamSocketConnectionManager | |
| CStreamSocketConnectionManager | |
| CStreamSocketConnectionManagerBase | A connection manager for stream sockets |
| CStreamSocketConnectionManagerCallback | An object that implements the CStreamSocketConnectionManager callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketConnectionManagerCallback | An object that implements the CStreamSocketConnectionManager callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketConnectionManagerCallback | An object that implements the CStreamSocketConnectionManager callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketConnectionManagerCallback | An object that implements the CStreamSocketConnectionManager callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketNamedConnectionCollection | |
| CStreamSocketServerCallback | |
| CStreamSocketServerCallback | An object that implements the CStreamSocketServer callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketServerCallback | |
| CStreamSocketServerCallback | |
| CStreamSocketServerExCallback | |
| CStreamSocketServerExCallback | |
| CStreamSocketServerExCallback | An object that implements the CStreamSocketServerEx callback interface and does nothing. You can derive from this class and override just the functions that you need to |
| CStreamSocketServerExCallback | |
| CStreamSocketServerExCallback | |
| CStringConverter | String conversion functions, use these in preference to USES_CONVERSION. Doesn't suffer from the stack blowing limitations of USES_CONVERSION |
| CSynchronousFileBackedH264RTPStream | |
| CSynchronousH264FileReader | |
| CSystemCertificateStore | |
| CSystemCertificateStore::Iterator | |
| CSystemInfo | A simple class that wraps, and initialises, a SYSTEM_INFO structure |
| CSystemShutdownMonitor | |
| CSystemTime | A simple class that wraps, and initialises, and manipulates a SYSTEMTIME structure |
| CSystemTime::DateDifference | A simple class that helps to manipluate the difference in date (only) between two SYSTEMTIMEs |
| CSystemTime::TimeDifference | A simple class that helps to manipluate the difference in time (only) between two SYSTEMTIMEs |
| CSystemTimeProvider | A class that implements IProvideSystemTime and returns the system time directly from a call to the operating system GetSystemTime() function. See here for more details |
| CTCPListeningSocketCreator | |
| CTempDirectory | A class which wraps the operating system GetTempPath() API and which creates and removes temporary directories in a scope based style. Directories are created in the form: TEMP_PATH\prefix + "-" + time(0) |
| CTestAlignment | |
| CThread | |
| CThread | |
| CThread | A class that wraps the operating system Threading API and provides a thread object that runs code which implements the IRunnable interface |
| CThreadAffinity | A class that wraps the operating system SetThreadAffinityMask API |
| CThreadBase | |
| CThreadedCallbackTimerQueue | |
| CThreadedCallbackTimerQueue | A class that manages a group of timers that implement IQueueTimers::Timer and which have their IQueueTimers::Timer::OnTimer() method called when the timer expires. The class uses an implementation of IManageTimerQueue to manage the timers and then manages its own timeouts using a thread to call IManageTimerQueue::BeginTimeoutHandling() every GetNextTimeout() milliseconds. You can configure it to use CCallbackTimerQueueEx or supply your own implementation of IManageTimerQueue. See here for more details |
| CThreadLocalStorage | |
| CThreadPool | A thread pool which can expand and contract (i.e. change the number of pooled threads) based on the work load. The pool has minimum and maximum sizes and a dispatch timeout. If dispatching a work item to a worker thread takes longer than the timeout then the pool is enlarged by one thread. There is also a maximum number of "dormant" threads, that is threads that are not working and when this number is reached worker threads are removed from the pool. The thread pool uses two I/O completion ports to do its work. Work items are dispatched to the dispatch port and are processed by the maintenance thread which dispatches the work items to the work port where the worker threads are waiting. This two layer dispatching means that dispatching from user code is fast but the pool can adjust its size depending on how long it takes for a worker thread to pick up a work item. Work items only ever queue on the dispatch port, the work port will only ever have a single work item on it at a time |
| CThreadPool | A thread pool which can expand and contract (i.e. change the number of pooled threads) based on the work load. The pool has minimum and maximum sizes and a dispatch timeout. If dispatching a work item to a worker thread takes longer than the timeout then the pool is enlarged by one thread. There is also a maximum number of "dormant" threads, that is threads that are not working and when this number is reached worker threads are removed from the pool. The thread pool uses two I/O completion ports to do its work. Work items are dispatched to the dispatch port and are processed by the maintenance thread which dispatches the work items to the work port where the worker threads are waiting. This two layer dispatching means that dispatching from user code is fast but the pool can adjust its size depending on how long it takes for a worker thread to pick up a work item. Work items only ever queue on the dispatch port, the work port will only ever have a single work item on it at a time |
| CThreadPool::WorkerThread | A worker thread for the CThreadPool. The user work is done by an instance of IThreadPoolWorkerThread which is created by the supplied factory in the worker thread's constructor and destroyed in the destructor |
| CThreadPool::WorkerThread | A worker thread for the CThreadPool. The user work is done by an instance of IThreadPoolWorkerThread which is created by the supplied factory in the worker thread's constructor and destroyed in the destructor |
| CThreadPoolEx | |
| CThreadPoolEx | |
| CThreadPoolEx::WorkerThread | A worker thread for the CThreadPoolEx. The user work is done by an instance of IThreadPoolExWorkerThread which is created by the supplied factory in the worker thread's constructor and destroyed in the destructor |
| CThreadPoolEx::WorkerThread | A worker thread for the CThreadPoolEx. The user work is done by an instance of IThreadPoolExWorkerThread which is created by the supplied factory in the worker thread's constructor and destroyed in the destructor |
| CThreadSafeRingBufferWorkPool | |
| CThreadSafeRingBufferWorkPool::WorkerThread | |
| CThreadSafeRingBufferWorkQueue | |
| CThreadSafeWorkQueue | |
| CThreadUsageTracker | |
| CTickCount64Provider | A class that implements IProvideTickCount64 and returns the tick count directly from a call to the operating system GetTickCount64() function |
| CTickCountCompare | |
| CTickCountProvider | A class that implements IProvideTickCount and returns the tick count directly from a call to the operating system GetTickCount() function. See here for more details |
| CTimeChangeNotificationMonitor | |
| CTimeStamp | |
| CToken | |
| CUDPAsyncConnector | |
| CUDPConnectionCreator | |
| CUDPRTPStream | |
| CUnqualifiedName | A kernel object name that is unquallifier in the kernel object namespace |
| CUsesCOM | |
| CUsesCOM | A simple object to support scope based COM initialisation and uninitialisation. Create an instance of this at the scope where you want COM to be available and it will be automatically uninitialised when the scope ends |
| CUsesCOM::Exception | |
| CUsesMSWinSockExtensions | This class acts as a dynamic function loader for the MS Winsock extension functions via a WSAIoctl() call with SIO_GET_EXTENSION_FUNCTION_POINTER. The assumption is made that all sockets passed to this class will be from the same underlying provider (or, at the very least, all sockets passed to a particular extension function will be from the same provider) |
| CUsesMSWinSockExtensions | This class acts as a dynamic function loader for the MS Winsock extension functions via a WSAIoctl() call with SIO_GET_EXTENSION_FUNCTION_POINTER. The assumption is made that all sockets passed to this class will be from the same underlying provider (or, at the very least, all sockets passed to a particular extension function will be from the same provider) |
| CUsesOLEDBConnectionPooling | |
| CUsesOpenSSL | |
| CUsesWinsock | A simple object to support scope based Winsock initialisation and uninitialisation. Create an instance of this at the scope where you want Winsock to be available and it will be automatically uninitialised when the scope ends |
| CWaitableCounter | A counter that can be incremented and decremented and where you can wait on it either becoming zero or becoming non-zero |
| CWaitableCounter::Decrementer | A class that provides support for scope based decrementing of a waitable counter. The count is decreased for the life of the Decrementer; that is, it is decremented in the constructor of the and incremented in the destrutor |
| CWaitableCounter::Incrementer | A class that provides support for scope based incrementing of a waitable counter. The count is incremented for the life of the Incrementer; that is, it is incremented in the constructor of the and decremented in the destrutor |
| CWebSocket | |
| CWebSocketException | |
| CWin32Exception | A simple exception class to replace Win32 error returns |
| CWOW64FileSystemRedirector | |
| CWriteAccumulationBuffer | |
| CWriteOnlyFilterData | |
| CXMLAttribute | |
| CXMLConfiguration | |
| CXMLConfigurationElement | |
| CXMLDocument | |
| CXMLElement | |
| CXMLNode | |
| CXMLVisitor | |
| Data | |
| Failure | |
| FastWriter | |
| FastWriter | |
| Features | |
| Features | |
| IAcceptDatagramSocketConnectionFilters | This interface works in conjunction with IFilterDatagramSocketConnections and allows datagram filters to be added to a class that can use them |
| IAcceptH264FrameData | |
| IAcceptH264NALUnits | |
| IAcceptLiveVideoData | |
| IAcceptLiveVideoDataNotifications | |
| IAcceptRuntimes | |
| IAcceptStreamData | |
| IAcceptStreamSocketConnectionFilters | This interface works in conjunction with IFilterStreamSocketConnections and allows stream filters to be added to a class that can use them |
| IAcceptWebSocketConnections | |
| IActionOnCLREvent | |
| IAddBuffersToPool | |
| IAddress | An interface that represents a Winsock address. This interface only deals with the data that's available from the underlying address; none of the 'meta-data' related to the address type is available; see IFullAddress for that stuff |
| IAddressRef | A reference counted IAddress |
| IAddressType | An interface that provides meta-data information about the type of a Winsock Address |
| IAllocatableBuffer | |
| IAllocateBuffer | |
| IAllocateBufferHandles | An interface to a class that allocates instances of CBufferHandle which can be attached to an instance of an IBuffer |
| IAllocateBuffers | An interface to a class that allocates instances of IBuffer of a fixed size. Each instance of IBuffer has opaque user data associated with it and so this allocator derives from IProvideUserData to allow the user to request user data "slots" from the allocator; you must request all of your slots before calling Allocate() for the first time |
| IAllocateCounterStorage | |
| IAllocateDatagramServerSockets | An interface for allocating IPoolableDatagramServerSocket |
| IAllocateDatagramSockets | An interface for allocating IPoolableDatagramSocket |
| IAllocateFixedSizedMemory | Provides an interface that can allocate fixed sized blocks of memory |
| IAllocateMemory | |
| IAllocatePoolableSockets | An interface for managing IPoolableSocket |
| IAllocateSequencedStreamSockets | An interface for allocating instances of IPoolableStreamSocket that support sequencing of reads and writes. Before you allocate the first socket you can request that the socket manage buffer sequencing counters for you by requesting a "sequnce id". This id can then be passed to IManageStreamSocketConnectionFilters::ReadCompleted() and IManageStreamSocketConnectionFilters::RequestWrite() calls to have the buffer sequenced using the specified sequnce id. Sockets allocated with this interface automatically support sequencing of the 'primary' byte stream |
| IAllocateSSRCs | |
| IAllocateStreamDataFiles | |
| IAllocateStreamSockets | An interface for allocating instances of IPoolableStreamSocket |
| IAssignProcessesToJobs | Provides an interface that can assign a process to a job |
| IAssociateDeviceWithIOSubSystem | |
| IAsyncIOStream | An interface onto an asynchrnonous I/O stream. Calls to Write() are not guaranteed to have completed when the call returns and calls to Read() simply request that a Read() happens and do not, in any way, result in incoming data being placed in the provided buffer before the call returns. Objects that implement this interface must provide another way to provide the caller with the data that is read from the stream when the read actually completes |
| IAsyncSocket | An interface to the functionality common to all asynchronous sockets. The "Try" functions add to the functions from JetByteTools::IO::IAsyncIOStream by adding versions that return false on failure rather than by throwing an exception |
| IAsyncWorkItem | |
| IBroadcastRTPStreams | |
| IBufferBase | An interface to a I/O buffer (with a partially refactored name!). Initially IBuffer and IBufferBase was one class, it was split to make it easier to mock and in an attempt to remove some of the socket stuff. Classes that implement this interface represent a byte buffer that can be used for overlapped I/O and that consist of a contiguous array of bytes and an insertion point which moves along the buffer as data is added to it. More work needs to be done |
| IBufferChain | |
| IBufferChain::IHandlePurgedBufferRelease | |
| IBufferIntrusiveCollectionAdapterSequenceNumberKeyAccessor | |
| IBufferProcessor | |
| IClientContext | |
| ICloseableOutputStream | An extension to IOutputStream that allows the user to call Close() on it |
| ICollectPerformanceData | An interface to an object that manages a set of performance counter data that can be exposed via a dll that conforms to the API required for perfmon performance extension dll data collection dlls |
| ICommunicateServiceStatusToSCM | |
| ICommunicateWithSCM | |
| ICompressData | |
| IConfigurableDebugLog | |
| IConfiguration | Provides an interface to a tree structured configuration such as something that could easily be modelled by an XML file or the registry |
| IConnectableProtocolHandler | |
| IContext | |
| ICreateFilteredStreamSocketConnections | An interface used to create outgoing stream socket connections |
| ICreateMiniDumps | Provides an interface that can create a mini dump of a process |
| ICreateRTPPackets | |
| ICreateRTPPackets::Data | |
| ICreateStreamSocketConnections | An interface used to create outgoing stream socket connections |
| ICreateUDPConnections | |
| ICreateUDPConnections::Callback | |
| IDataDeflatorFactory | |
| IDatagramSendSocket | |
| IDatagramServerSocket | This interface provides an equivalent interface to the one provided by IAsyncSocket for IDatagramSocket and IStreamSocket. It does not feature the ability to issue Read() calls as the sockets derived from this interface are purely disconnected, datagram, server sockets; i.e. they're how you send a datagram back to whoever sent you the datagram that has just arrived. IDatagramSocket supports a pseudo connected interface where you can issue Read() calls .. |
| IDatagramServerSocketCallback | The socket server callback interface is composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. This is, effectively, the first interface that the user would wish to implement |
| IDatagramServerSocketConnectionManager | An interface that is used to allow a socket to communicate with the connection manager that manages it. This interface is supplied to the socket in the call to Attach() |
| IDatagramServerSocketConnectionManagerIO | |
| IDatagramServerSocketEx | A socket interface that adds functionality that is used internally by the socket server classe |
| IDatagramSocket | This interface adds datagram socket specific functionality to the IAsyncSocket interface. Note that instances of IDatagramSocket support a pseudo connected interface where you can issues Read() calls and RecvFrom() any address. IDatagramServerSocket presents a much more restricted interface intended for use from "pure" datagram servers |
| IDatagramSocketCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IDatagramSocketConnectionManager | An interface that is used to allow a socket to communicate with the connection manager that manages it. This interface is supplied to the socket in the call to Attach() |
| IDatagramSocketConnectionManagerCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IDatagramSocketConnectionManagerIO | |
| IDatagramSocketEx | A socket interface that adds functionality that is used internally by the connection manager and socket server classes |
| IDatagramSocketServerCallback | The socket server callback interface is composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. This is, effectively, the first interface that the user would wish to implement |
| IDebugLogConfigurationCallback | |
| IDeflateData | |
| IDispatchServiceControls | |
| IDispatchToWorkerThread | |
| IDisplayMessageBox | |
| IEnumIterator | |
| IEnumIterator::NullIterator | |
| IEventSinkCallback | A callback interface that is used by CCLREventSink to report events |
| IFilterableDatagramSocket | An interface which adds functionality that is useful when filtering a connection |
| IFilterableStreamSocket | An interface which adds functionality that is useful when filtering a connection |
| IFilterData | |
| IFilterDatagramSocketConnections | An interface for objects that wish to filter datagrams. An instance of this interface can be added to a CDatagramSocketConnectionManager as a filter by calling AddConnectionFilter(). Filters are called in order to process calls with requests being called from "top to bottom" and completions being called from "bottom to top". For example, if we call AddConnectionFilter() with filter A and then with filter B and then make a write request the data would be processed first by filter B and then by filter A (user -> B -> A -> wire). When a read completes the data is processed first by filter A and then by filter B (wire -> A -> B -> user). Each filter can manipulate the contents of the datagram flow and may or may not pass calls onto filters below it in the chain. Thus a filter can swallow requests from layers above it by not passing them on and can also generate requests of its own. A filter is initialised once by the connection manager before it is used and during this initialisation it is given a management interface that can be used to generate new read and write events |
| IFilterStreamSocketConnections | An interface for objects that wish to filter a byte stream. An instance of this interface can be added to a CStreamSocketConnectionManager as a filter by calling AddConnectionFilter(). Filters are called in order to process calls with requests being called from "top to bottom" and completions being called from "bottom to top". For example, if we call AddConnectionFilter() with filter A and then with filter B and then make a write request the data would be processed first by filter B and then by filter A (user -> B -> A -> wire). When a read completes the data is processed first by filter A and then by filter B (wire -> A -> B -> user). Each filter can manipulate the connection and data flow and may or may not pass calls onto filters below it in the chain. Thus a filter can swallow requests from layers above it by not passing them on and can also generate requests of its own. A filter is initialised once by the connection manager before it is used and during this initialisation it is given a management interface that can be used to generate new read and write events |
| IFullAddress | An interface that represents an IAddress which knows about its address type and that can create dynamically allocated copies of itself |
| IGenerateRTCPPackets | |
| IHandleExceptions | |
| IHandleFileCreationFailure | |
| IHandleJobEvents | An interface to allow a class to handle the events that are generated by operating system Job objects |
| IHandler | An interface that represents code that handles operations on I/O buffers |
| IHandshakeParserCallback | |
| IHostAssemblyManager | |
| IHostAssemblyStore | |
| IHostControl | |
| IHostControl | An interface that extends the MSCoreE IHostControl interface.. |
| IHostPolicyManager | |
| IHostPolicyManagerCallback | A callback interface that is used by CHostPolicyManager to report events |
| IHTTPRequestProcessor | |
| IHTTPResource | |
| IHTTPResourceData | |
| IHTTPResponseProcessor | |
| IHTTPStream | |
| IICEConnection | |
| IICEConnectionCallback | |
| IICEConnectionManager | |
| IICEConnectionManagerCallback | |
| IICEControlledDTLSConnection | |
| IICEControlledDTLSConnectionCallback | |
| IICEControlledDTLSConnectionFactory | |
| IIndexedOpaqueUserData | Provides an interface that allows access to 'opaque user data' that is data that is stored as either a void * or an unsigned long and that is basically anything that the user wants to store. The data is stored by index and an implementation of this class is free to store the data in any way that it sees fit. An index represents a single storage location so a call to GetUserPointer() and GetUserData() on the same index will return the same data, just viewed in different ways |
| IInflateData | |
| IInputStream | An interface to an input stream (which may be sync or async) |
| IInstallPerformanceMonitorCounters | An interface to an object that can install performance counters on a system. See here for more details |
| IInterleavedRTPTCPStream | |
| IIOPool | An interface to an I/O thread pool (usually based on an I/O completion port) that can have operations on buffers and handlers dispatched to it (either directly or as a result of an I/O completion packet being generated by some asynchronous I/O event) and that handles these events on one of the threads in the pool |
| IIOSubSystem | |
| IIPAddress | An interface that represents an IP address which knows about its port |
| IIterateableBufferChain | |
| IKernelObjectName | An interface that represents a name in the kernel object namespace See here for more details |
| ILimitConnections | An interface to an object that manages the number of connections currently in progress and that can disallow any more connections being made. Call CanCreateConnection() when you wish to create a new connection and if it returns true then you can create your connection and call ReleaseConnection() when the connection terminates. If it returns false then you should not create your connection |
| ILimitConnections::Creator | A class that takes ownership of an attempt at connection creation. That is if you call CanCreateConnection() through it and then do not call ConnectionCreated() then the destructor will assume something went awry and call ReleaseConnection(). This class can therefore be used to support scope based connection creation |
| ILimitPendingWrites | An interface to an object that manages the number of writes currently in progress and that can disallow any more write requests being made. Call CanWrite() when you wish to issue a new write request and when it returns you can issue your write and call WriteComplete() when the write is complete |
| IListenForShutdown | |
| IListenForSystemShutdownNotifications | |
| IListenForTimeChangeNotifications | |
| IListenToThreadNaming | |
| IListenToThreadStart | |
| IListenToThreadStop | |
| ILockableObject | An interface onto objects that can be locked |
| ILoggablePerformanceMonitorCounters | |
| ILogMessages | An interface for logging messages. These can be debug trace messages or more structured logging. The messages are sent to a log, which can be pretty much anything |
| ILogMessagesWithFixedFileHeader | |
| IMaintainStreamSocketConnections | An interface used to create and maintain outgoing stream socket connections |
| IManageBufferHandleLifeCycle | A helper interface to remove a friend relationship between buffers and their allocators.. |
| IManageBufferLifeCycle | A helper interface to remove a friend relationship between buffers and their allocators.. |
| IManageDatagramSocketConnectionFilters | This interface works in conjunction with IFilterDatagramSocketConnections to allow datagram filters to issue new read and write events. Any filter that either can swallow data buffers (by not passing on calls to the next filter in the chain) or that generates data buffers (passing data to the next filter in the chain when that data wasn't generated by a previous layer in the chain) should always use this interface to pass data buffers to the next layer in the chain. Failure to do so will affect any additional filter processing that may (or may not) be occurring |
| IManageEnvironmentVariables | An interface for manipulating operating system environment variables |
| IManageHTTPResourceData | |
| IManageJobEvents | An interface to a class that manages the asynchronous events generated by an operating system job object and routes them to the supplied handler interface |
| IManageNamedServers | |
| IManagePacketStreamLifetime | |
| IManageResources | |
| IManageRTSPResources | |
| IManageRTSPSessions | |
| IManageRTSPSessionTimeouts | |
| IManageServiceNotifications | |
| IManageStreamSocketConnectionFilters | This interface works in conjunction with IFilterStreamSocketConnections to allow stream filters to issue new read and write events. Any filter that either can swallow data buffers (by not passing on calls to the next filter in the chain) or that generates data buffers (passing data to the next filter in the chain when that data wasn't generated by a previous layer in the chain) should always use this interface to pass data buffers to the next layer in the chain. Failure to do so will affect any buffer sequencing that may (or may not) be occurring. A filter can specify that its own sequence counter is used by requesting one from the socket allocator and then by passing the sequence id to the relevant calls. If a filter only ever injects new data into a stream then it can use the socket's own sequence counter and calls to the methods that don't take an explicit sequence id |
| IManageThreadPoolThreads | An interface to allow a thread pool to monitor the actions of the threads that it manages |
| IManageTimerQueue | An interface representing a class that manages timers that implement the IQueueTimers::Timer interface and and which have their IQueueTimers::Timer::OnTimer() method called when the the timer expires. See here for more details. Note that this interface extends IQueueTimers to provide the ability to deal with the timer's timeouts via IManageTimerQueue::BeginTimeoutHandling(), etc. This interface is designed for composing timer queues, such as is done in CThreadedCallbackTimerQueue and not for passing to users of timer queues |
| IManageWorkerThreads | |
| IMonitorAsyncFileReader | An interface to allow a class to monitor an instance of an async file reader |
| IMonitorAsyncFileWriter | An interface to allow a class to monitor an instance of an async file writer |
| IMonitorBufferAllocation | An interface to allow a class to monitor the operation of a class that allocates buffers. The interface assumes that buffers go through the following life-cycle: created, allocated, released, destroyed. Allocators that pool buffers can allow a buffer to be created once and then allocated and released several times before being deleted. Incrementing a counter when OnBufferCreated() is called and decrementing it when OnBufferDestroyed() is called will give you a count of the number of buffers that are in existence at any one time. A corresponding counter that is incremented in OnBufferAllocated() and decremented when OnBufferReleased() is called will give a count of the buffers that are currently in use |
| IMonitorCallbackTimerQueue | An interface to allow a class to monitor the operation of an instance of CCallbackTimerQueue |
| IMonitorDatagramSocketFlowControl | |
| IMonitorICEControlledDTLSConnection | |
| IMonitorJobs | An interface to allow a class to monitor the events that are generated by instances of CJob |
| IMonitorSocketAllocation | An interface to allow a class to monitor the operation of a class that allocates sockets. The design of the interface assumes that sockets go through the following life-cycle: created, allocated, released, destroyed. Allocators that pool sockets can allow a socket to be created once and then allocated and released several times before being deleted. Incrementing a counter when OnSocketCreated() is called and decrementing it when OnSocketDestroyed() is called will give you a count of the number of sockets that are in existence at any one time. A corresponding counter that is incremented in OnSocketAttached() and decremented in OnSocketReleased() is called will give a count of the sockets that are currently in use |
| IMonitorStreamSocketFlowControl | An interface to allow a class to monitor the operation of a class that implements flow control for stream socket connections. The design of the interface assumes that only buffers that are affected by flow control are noted by the monitor. The effects of flow control on a buffer that is being sent on a connection are as follows: delayed, sent or discarded. A buffer that is delayed is being held for a while until it can be sent. A buffer that has been sent is a buffer that was previously delayed and that has now been written to the connection. A buffer that is discarded can either be a new buffer that is being discarded rather than delayed or an existing delayed buffer that will now never be sent. Incrementing a counter when OnBufferDelayed() is called and decrementing it when OnBufferSent() is called, OR when 'wasDelayed' is true and OnBufferDiscarded() is called will give you a count of buffers that are currently delayed. Incrementing a counter when OnBufferDiscarded() is called will give you a count of all the buffers that were discarded. You can use the 'id' value as a way of maintaining these counts on a per-connection basis. The Id that you return from a call to OnConnectionEstablished() will be passed with every call to the other monitor functions. Note that if all you require is a unique id per connection then you can simply cast the address of the supplied socket to a ConnectionId in OnConnectionEstablished() and return that |
| IMonitorThreadedCallbackTimerQueue | An interface to allow a class to monitor the operation of an instance of CCallbackTimerQueue |
| IMonitorThreadPool | An interface to allow a class to monitor an instance of a thread pool. The interface assumes that threads in the pool go through the following life-cycle: created, begin processing, end processing, destroyed, and that they may optionally (hopefully not) generate errors. Obviously a thread is likely to begin and end processing several work items before it is destroyed. The methods on this interface can be called either from any thread and may not be called from the thread pool thread itself. Incrementing a counter when OnThreadCreated() is called and decrementing it when OnThreadDestroyed() is called will give you a count of the number of threads that are in existence at any one time. A corresponding counter that is incremented in OnThreadBeginProcessing() and decremented in OnThreadEndProcessing() is called will give a count of the threads that are currently in use |
| INamedServerShutdownCallback | |
| INotifyOnLastStreamDataWrite | |
| INotifyOnMemoryCacheStreamWritten | |
| INotifyProgress | |
| IODBCConnection | |
| IODBCEnvironment | |
| IODBCStatement | |
| IOutputStream | An interface to an output stream (which may be sync or async) |
| IPerformanceCounterMonitorCallback | |
| IPerformanceDataBlock | |
| IPerformanceDataBlockFactory | |
| IPoolableDatagramServerSocket | An interface that exists purely to tie together the poolable nature of a socket and the datagram server socket nature of a socket into a poolable datagram server socket. The CDatagramServerSocketAllocator object works in terms of this interface |
| IPoolableDatagramSocket | An interface that exists purely to tie together the poolable nature of a socket and the datagram socket nature of a socket into a poolable datagram socket. The CDatagramSocketAllocator object works in terms of this interface |
| IPoolableSocket | The IPoolableSocket interface provides the 'poolability' of the sockets. Poolable sockets are pooled using a CNodeList and so, for a socket to be pooled it must derive from CNodeList::Node. When a socket is used from the pool or released to the pool the allocator passes the socket's user data to the allocation monitor and so poolable sockets must support IIndexedOpaqueUserData |
| IPoolableSocketManager | A convenience interface that acts as a common base class for SocketManagers simply so that the whole of the socket allocator common code doesn't need to be templatised. Typesafety is ensured by TSocketAllocator |
| IPoolableStreamSocket | An interface that exists purely to tie together the poolable nature of a socket and the stream socket nature of a socket into a poolable stream socket. The CStreamSocketAllocator and CSequencedStreamSocketAllocator objects work in terms of this interface |
| IPoolBuffers | |
| IProcessPayloadFrames | |
| IProcessRTPFrames | |
| IProtocolHandler | |
| IProtocolHandlerAllocator | |
| IProtocolHandlerFactory | |
| IProvideDiskSpace | |
| IProvideEnvironmentBlock | An interface for providing operating system environment variable blocks as detailed here |
| IProvideH264NALUnits | |
| IProvideLocalTime | |
| IProvideRandomBytes | |
| IProvideRandomNumbers | |
| IProvideRTPData | |
| IProvideSRTPKeyingMaterial | |
| IProvideStreamData | |
| IProvideSystemTime | An interface that provides access to the operating system GetSystemTime() call. Code can access this service via an instance to IProvideSystemTime so that the provider can be replaced (usually for testing purposes). See here for more details |
| IProvideTickCount | |
| IProvideTickCount64 | |
| IProvideUserData | An interface that works with IIndexedOpaqueUserData to allow users of a class that provides opaque user data to request a named 'slot' for their data. Generally what happens is that an allocator will expose this interface and the allocated items will expose the interface to access the user data. Users of the allocator can request named slots of user data before allocating the first item and then all items are created with the required amount of user data space |
| IProvideWorkItems | A restricted interface onto a queue of work items (such as an I/O completion port, perhaps) |
| IQueueTimers | An interface representing a class that manages timers that implement the IQueueTimers::Timer interface and and which have their IQueueTimers::Timer::OnTimer() method called when the the timer expires. See here for more details |
| IQueueTimers::RefCountedTimer | |
| IQueueTimers::Timer | An interface to a timer that can be set with IQueueTimers |
| IReadableRingBufferWorkQueue | |
| IReadableRingBufferWorkQueue::WorkItem | |
| IReadableRingBufferWorkQueue::WorkItem::ItemData | |
| IReentrantLockableObject | An interface onto objects that can be locked and where the same thread is able to call Lock() multiple times successfully and where each call to Lock() needs to be balanced by a corresponding call to Unlock() to unlock the object |
| IReentrantLockableObjectTracksLockingThread | An interface onto objects that can be locked and where the same thread is able to call Lock() multiple times successfully and where each call to Lock() needs to be balanced by a corresponding call to Unlock() to unlock the object |
| IRefCountedHandler | |
| IReleaseCreatedConnections | |
| IReleaseSSRCs | |
| IRenderAddresses | An interface to an object that can take an instance of IAddress and produce a readable textual representation of that address. So, for example, it could takean IPv4 address and render it in standard dotted IP format xxx.xxx.xxx.xxx, etc |
| IReportServiceStatus | |
| IRingBufferWorkPoolThreadFactory | |
| IRingBufferWorkPoolWorkerThreadCallback | |
| IRTPPacketStream | |
| IRTPStream | |
| IRTPStreamRefCount | |
| IRTSPResource | |
| IRTSPServer | |
| IRTSPSession | |
| IRunnable | |
| IRunnable | An interface to code that can be Run() on a thread. Usually passed to the CThread constructor |
| ISaveStreamData | |
| ISecureStreamSocketCallback | |
| ISecureStreamSocketCallback | |
| ISecureStreamSocketCallback | |
| IServerContext | |
| IServerControl | An interface to a 'server' that can be started, stopped and can be toggled between accepting connections or not. The life-cycle of an object that implements this interface is; start, accept connections, stop accepting connections, initiate shutdown, shutdown. The object may go from accepting to not accepting and back again any number of times after being started. The object may go from started to stopped and stopped to started any number of times |
| IServerShutdownCallback | |
| IService | |
| IServiceCallbacks | |
| IShutdownService | |
| ISingletonDebugLog | |
| ISingleWriterMultipleReaderLock | |
| ISingleWriterMultipleReaderLock::ConditionalOwner | A base class to support the ConditionalReader and ConditionalWriter classes |
| ISingleWriterMultipleReaderLock::ConditionalReader | A class that may lock an instance of ISingleWriterMultipleReaderLock for read access. That is it calls EnterToRead() in the constructor and Leave() in the destructor if locked is true and can therefore be used to support scope based locking and unlocking |
| ISingleWriterMultipleReaderLock::ConditionalWriter | A class that may lock an instance of ISingleWriterMultipleReaderLock for write access. That is it calls EnterToWrite() in the constructor and Leave() in the destructor if locked is true and can therefore be used to support scope based locking and unlocking |
| ISingleWriterMultipleReaderLock::PotentialOwner | A base class to support the PotentialReader and PotentialWriter classes |
| ISingleWriterMultipleReaderLock::PotentialReader | A class that may lock an instance of ISingleWriterMultipleReaderLock for read access. If you call EnterToRead() or TryEnterToRead() on this class it will keep track of the fact that the lock has been entered and will call Leave() in the destructor. This can therefore be used to support scope based locking and unlocking of instances of ISingleWriterMultipleReaderLock |
| ISingleWriterMultipleReaderLock::PotentialWriter | A class that may lock an instance of ISingleWriterMultipleReaderLock for write access. If you call EnterToWrite() or TryEnterToWrite() on this class it will keep track of the fact that the lock has been entered and will call Leave() in the destructor. This can therefore be used to support scope based locking and unlocking of instances of ISingleWriterMultipleReaderLock |
| ISingleWriterMultipleReaderLock::Reader | A class that locks an instance of ISingleWriterMultipleReaderLock for read access. That is it calls EnterToRead() in the constructor and Leave() in the destructor and can therefore be used to support scope based locking and unlocking |
| ISingleWriterMultipleReaderLock::Writer | A class that locks an instance of ISingleWriterMultipleReaderLock for write access. That is it calls EnterToWrite() in the constructor and Leave() in the destructor and can therefore be used to support scope based locking and unlocking |
| ISocketCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IStream | An interface to an stream.. |
| IStreamDataFileFactory | |
| IStreamSocket | This interface adds stream socket specific functionality to the IAsyncSocket interface. As you can see that isn't much. This is the interface that you will interact with to access socket functionality when you write a client or server as this is the interface to the socket connection that you are passed when callback events occur on a connection |
| IStreamSocketCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IStreamSocketConnectionManager | An interface that is used to allow a socket to communicate with the connection manager that manages it. This interface is supplied to the socket in the call to Attach() |
| IStreamSocketConnectionManagerCallback | |
| IStreamSocketConnectionManagerCallback | |
| IStreamSocketConnectionManagerCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IStreamSocketConnectionManagerCallback | |
| IStreamSocketConnectionManagerIO | |
| IStreamSocketEx | A socket interface that adds functionality that is used internally by the connection manager and socket server classes |
| IStreamSocketServerCallback | |
| IStreamSocketServerCallback | |
| IStreamSocketServerCallback | |
| IStreamSocketServerCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| IStreamSocketServerExCallback | |
| IStreamSocketServerExCallback | |
| IStreamSocketServerExCallback | |
| IStreamSocketServerExCallback | The connection manager and socket server callback interfaces are composed from more specific interfaces using inheritance. This is purely to allow the framework to work in terms of the narrowest interface internally and does not affect the user of the code. Effectively the first interface that the user would wish to implement is at the IXXXConnectionManagerCallback level and above |
| ISupportMulticast | The interface used to support multicasting |
| IThreadPoolWorkerThreadCallback | An interface to an object that acts as a worker thread for a work queue. The life-cycle of an object that implements this interface is as follows: one call to Initialise() (and, if it returns true), 0 or many calls to Process() and then one call to Shutdown() |
| IThreadPoolWorkerThreadFactory | An interface to create instances of IThreadPoolWorkerThreadCallback. Usually passed to the CThreadPool constructor |
| ITransmitRTCPPackets | |
| ITransmitRTPPackets | |
| IUDPAsyncConnectorCallback | |
| IUnsortedBufferChain | |
| IVisitConfigurationElements | |
| IWaitable | |
| IWaitable | An interface to code that can be waited for, either via the methods on the interface or by passing a handle to one of the Wait Functions |
| IWaitable | |
| IWebSocket | |
| IWebSocket | |
| IWebSocketInputHandler | |
| IWebSocketServer | |
| IWritableAddress | An interface which represents an address that can be written to and updated. A typical way that this interface would be used is like this: getsockname(socket, address.GetStorage(), address.GetSize()) |
| IWritableAddressRef | A reference counted IWritableAddress |
| IWritableRingBufferWorkQueue | |
| jb_enable_if | |
| jb_enable_if< false, T > | |
| OSVERSIONINFOEX | |
| OVERLAPPED | |
| Path | |
| Path | |
| PathArgument | |
| PathArgument | |
| PredicateContext | Context used to create the assertion callstack on failure. Must be a POD to allow inline initialisation without stepping into the debugger |
| PROCESS_INFORMATION | |
| Reader | |
| Reader | |
| Runner | |
| SCHANNEL_CRED | |
| SEC_WINNT_AUTH_IDENTITY | |
| SecBufferDesc | |
| SECURITY_ATTRIBUTES | |
| SECURITY_DESCRIPTOR | |
| ServiceTypes | |
| SLIST_ENTRY | |
| STARTUPINFO | |
| StaticString | |
| StaticString | |
| StreamWriter | Usage: |
| StreamWriter | Usage: |
| StreamWriter::Factory | |
| StreamWriter::Factory | |
| StreamWriterBuilder | |
| StreamWriterBuilder | |
| StyledStreamWriter | |
| StyledStreamWriter | |
| StyledWriter | |
| StyledWriter | |
| SubkeyIteratorImpl | |
| SYSTEM_INFO | |
| SYSTEMTIME | |
| TActivatableObject | |
| TAddressOrderedMultiLock | A class that allows you to manipulate a collection of instances of locks as if they were a single instance. The idea being that this could be used to enforce an ordering over a sequence of locks that must be acquired together. The locks are stored in the collection keyed by address and then always locked in address ascending order and unlocked in address descending order |
| TAsyncSocket | A template class that provides most of the functionality that is shared between all socket types |
| TAtomic | |
| TAtomic | |
| TAtomicLong | |
| TAtomicOperations | |
| TAtomicOperations< __int64 > | |
| TAtomicOperations< long > | |
| TAtomicOperations< unsigned char * > | |
| TAtomicOperations< unsigned long > | |
| TAtomicOperations< void * > | |
| TBufferPool | |
| TCache | |
| TConditionalSmartPointer | A smart pointer to memory using the C++ new API. Calls delete on any memory that the TConditionalSmartPointer owns when it goes out of scope to aid in scope based designs. Note that the TConditionalSmartPointer can be told that it does NOT own the memory that it is given; this is useful if sometimes it holds dynamically allocated memory that it should own and delete and sometimes it holds a pointer to, for example, a static null object implementation |
| TConnectionManagerBase | |
| TDatagramFilteringHelper | |
| TDatagramSocketConnectionManager | A connection manager for datagram sockets |
| TDatagramSocketServer | A socket server for datagram sockets |
| TDebugLog | |
| TDynamicObjectTracker | |
| TDynamicObjectTrackerCollection | |
| TestCase | |
| TestResult | |
| TExceptionToCOMError | |
| TExpandableBuffer | A template class for an expandable buffer, that is a buffer that can be expanded and which will, if expanded, maintain its contents |
| TGlobalDebugLog | |
| TILockableObjectTracksLockingThread | An interface onto objects that can be locked and which track the thread that currently holds the lock and can tell you if you currently hold the lock |
| TIndexedOpaqueUserData | Implements IIndexedOpaqueUserData in terms of a std::vector of void * |
| TIntrusiveMap | |
| TIntrusiveMapNodeKeyAccessorKeyIsAddress | |
| TIntrusiveMultiMap | |
| TIntrusiveMultiMap::Iterator | |
| TIntrusiveMultiMap::NodeCollection | |
| TIntrusiveMultiMap::NodeCollection::Iterator | |
| TIntrusiveMultiMapNodeIsBaseClass | |
| TIntrusiveRedBlackTree | |
| TIntrusiveRedBlackTree::Iterator | |
| TIntrusiveRedBlackTreeNodeIsBaseClass | |
| TIntrusiveRedBlackTreeNodeIsEmbeddedMember | |
| TIntrusiveSet | |
| TIntrusiveSetNodeKeyAccessorKeyIsAddress | |
| TLockableObject | |
| TLockableObject | |
| TLockableObjectConditionalOwner | A class that may take ownership of a lockable object. That is it calls Lock() in the constructor and Unlock() in the destructor (but only if locked passed as true to the constructor) and can therefore be used to support scope based locking and unlocking of instances of the object |
| TLockableObjectOwner | A class that takes ownership of a lockable object. That is it calls Lock() in the constructor and Unlock() in the destructor and can therefore be used to support scope based locking and unlocking of instances of the object |
| TLockableObjectPotentialOwner | A class that could take ownership of an instance of a lockable object. If you call Lock() or TryLock() on this class it will keep track of the fact that the lockable object has been locked and will call Unlock() in the destructor. This can therefore be used to support scope based locking and unlocking of instances of the object |
| TLockableObjectTracksLockingThread | |
| TMulticastDatagramHelper | A socket server for datagram sockets |
| TMultipleRangeReusableIdManager | |
| TMultipleRangeReusableIdManagerBase | |
| TMultipleRangeReusableIdManagerBase::InitialRanges | |
| TNodeList | A template wrapper that makes an instance of CNodeList typesafe with respect of the classes stored within it. Simply wraps the CNodeList::Node access methods to work in terms of the template T rather than any class that happens to derive from CNodeList::Node |
| TOptionallyOwnedPointer | |
| TReentrantLockableObject | |
| TReentrantLockableObject | |
| TReentrantLockableObjectPotentialOwner | |
| TReentrantLockableObjectTracksLockingThread | |
| TReentrantLockableObjectTracksLockingThread | |
| TReferenceCounted | A template class that wraps a class to provide it with and manage an external reference count |
| TReferenceCountedSmartPointer | A template smart pointer class that manages objects that support AddRef() and Release() style reference counting |
| TRegistryList | |
| TRegistryList::iterator | |
| TRegKeyIterator | |
| TReleaseOnlyReferenceCountedSmartPointer | A template smart pointer class that manages objects that support Release() style reference counting |
| TReusableIdManager | |
| TReusableIdManager::Interval | |
| TReusableIdManager::SmartId | |
| TSecurityBuffers | |
| TSharedMemoryPerformanceDataBlockFactory | |
| TSingletonDebugLog | |
| TSocketAllocator | A template class that provides most of the socket allocation functionality that is shared between all socket types |
| TStreamSocketConnectionManager | A connection manager for stream sockets |
| TStreamSocketServer | |
| TStreamSocketServer | |
| TStreamSocketServer | |
| TStreamSocketServer | A socket server for stream sockets. Runs a thread to handle connection establishment using accept |
| TStreamSocketServerEx | A socket serer for stream sockets. Uses AcceptEx to handle connection establishment, does not run a thread for connection establishment. Can not handle 'accept and read' connection establishment |
| TThreadSafeReusableIdManager | |
| TTimeChangeAwareRotatingAsyncFileLog | A class that implements JetByteTools::ILogMessages to provide an asynchronous file log that uses overlapped I/O to perform writes to the log file. The log can be set to automatically rotate (i.e. create a new log file) after a set period of time or when the file grows to a particular size. Aware of time changes that occur on the system |
| TTypeSafeTypedef | |
| TWebSocketBase | |
| TWebSocketBase::AutoCloser | |
| TZeroInitialiseExpandableBuffer | A template class for an expandable buffer, that is a buffer that can be expanded and which will, if expanded, maintain its contents |
| Value | |
| Value | |
| ValueConstIterator | |
| ValueConstIterator | |
| ValueIterator | |
| ValueIterator | |
| ValueIteratorBase | |
| ValueIteratorBase | |
| WIN32_FIND_DATA | |
| Writer | |
| Writer | |
