The C++ framework for developing highly scalable, high performance servers on Windows platforms.

The Server Framework - v6.9.1 Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_AsyncServerEvent
Base
CAccumulationBuffer
CAccumulationBuffer
CAccumulationBuffer
CActivatableObject
CActivatableObject::Callback
CActivatableObject::CommandData
CActivatableObject::CommandWrapper
CActivatableObject::IProcessQueuedCommand
CActivatableObject::QueuedCommands
CAddressEssentially a smart pointer to a CAddressImpl instance
CAddressBluetooth
CAddressImplA reference counted wrapper around a SOCKADDR_STORAGE structure that knows how big the address that's stored is
CAddressImplReferenceTracker
CAddressInfoA class that provides addressing information for the specified host
CAddressInfo::IteratorAn iterator to addresses that are supported by the host
CAddressIPv4An IPv4 address
CAddressIPv6An IPv6 address
CAddressRendererAn implementation of IRenderAddresses
CAddressTypeA generic implementation of the IAddressType interface. Should be suitable for all types of addresses, just supply the appropriate values to the constructor
CAddressTypeBluetooth
CAddressTypeIPv4A implementation of the IAddressType interface for IPv4
CAddressTypeIPv6A implementation of the IAddressType interface for IPv6
CAddressWrapperA facade that allows a SOCADDR * to be accessed via the IAddress interface
CApplicationProtocolSelection
CAsyncConnector
CAsyncConnector
CAsyncConnector
CAsyncConnector::ICallback
CAsyncConnector::ICallback
CAsyncConnector::IDataAvailable
CAsyncConnectorTest
CAsyncFileLogA class that implements JetByteTools::Win32::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()
CAsyncFileReaderA 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::CallbackAn interface for users of the CAsyncFileReader to be notified of the results of the asynchronous read operations on the file
CAsyncFileWriterA 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::CallbackAn interface for users of the CAsyncFileWriter to be notified of any errors that occur during the asynchronous write operations on the file
CAsyncFileWriterExA 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
CAsyncFileWriterEx::DataA simple structure to enable 'gather' style multiple buffer writes with minimal data copying
CAsynchronousFileBackedH264InterleavedTCPRTPStream
CAsynchronousFileBackedH264RTPStream
CAsynchronousFileBackedH264UDPRTPStream
CAsynchronousH264FileReader
CAsyncServerEventHelper
CAsyncSocketConnector
CAsyncSocketConnector::ICallback
CAtomicBool
CAtomicCounter
CAtomicCounter::Decrementer
CAtomicCounter::Incrementer
CAutoDetectProtocolHandler
CAutoDetectProtocolHandlerAllocator
CAutoResetEventA class that wraps the operating system Event API and exposes just the interface for an auto reset event
CBitParser
CBufferAn 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
CBufferAllocatorAn implementation of IAllocateBuffers which pools buffer instances for later reuse
CBufferAllocator
CBufferBasedBufferAllocator
CBufferChain
CBufferChainStoresNulls
CBufferHandleAn 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
CBufferHandleAllocatorAn implementation of IAllocateBufferHandles which pools buffer handle instances for later reuse
CBufferHandleAllocator
CBufferHistory
CBufferingSubNegotiator
CBufferProcessor
CBufferReferenceTracker
CBufferReferenceTracker::UsesTracker
CBufferRingBuffer
CCallbackTimerQueueExA 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
CCallTracker
CCallTracker::CallLocation
CCallTracker::DataIterator
CCatInfo
CCatInformation
CCatInformation::Exception
CCatRegister
CCatRegister::Exception
CCertificate
CClientContext
CClientContext
CClientImpersonator
CCLREventSinkA class that manages subscriptions to CLR events via the IActionOnCLREvent interface
CCLRGCManager
CCLRHostA class that hosts the CLR in unmanaged code
CCLRHostFactory
CCLRMetaHost
CCLRPolicyManager
CCodePage
CComExeServer
CCommandLineA class that parses the command line and can report on whether specified switches or arguments have been passed to a program
CCommandLine
CCompareStrings
CComPortControlClientSubNegotiator
CComPortControlSubNegotiator
CComServerModule
CConnectionLimiterAn implementation of ILimitConnections
CConnectionMaintainingStreamSocketConnectionFilterA 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()
CConnectObject
CConnectResponse
CContext
CContext
CContext
CCountedCertificateContext
CCountedCertificateStoreHandle
CCountedCredentialsHandle
CCountedRegKey
CCountedSecurityContext
CCounterStorageAllocator
CCredentials
CCredentials
CCredentials::Data
CCredentials::Data
CCriticalSectionA class that wraps the operating system Critical Section API and that implements the ICriticalSection interface. The addition of the ICriticalSection interface has increased the size of this object and added a layer of indirection into the Enter() and Leave() calls. If this proves to be a performance problem then we can simply create a 'CSmallAndFastCriticalSection which doesn't inherit from the interface
CCrtReportHook
CCustomPoolSmartBuffer
CDatabaseConnection
CDatabaseConnection::Exception
CDatabaseConnection::Transaction
CDatabaseConnectionDetails
CDataCompressor
CDataDeflator
CDataDeflatorFactory
CDatagramServerSocketA 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
CDatagramServerSocketAllocatorA socket allocator that allocates datagram server sockets. Note that most of the work is down in CSocketAllocator
CDatagramSocketA datagram socket that allows you to RecvFrom() and SendTo() any host
CDatagramSocketAllocatorA socket allocator that allocates datagram sockets. Note that most of the work is down in CSocketAllocator
CDatagramSocketConnectionManagerBaseA connection manager for datagram sockets
CDatagramSocketConnectionManagerCallbackAn 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
CDatagramSocketConnectionManagerCallback
CDatagramSocketServerBaseA socket server for datagram sockets
CDatagramSocketServerCallbackAn 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
CDatagramSocketServerCallback
CDataInflator
CDebugServiceDispatcher
CDebugServiceDispatchThread
CDebugTrace
CDebugTrace::LogInstallerA 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
CDirectorySearchA simple class that wraps the FindFirstFile() /FindNextFile() API
CDispatchRestrictor
CDispatchRestrictor::AllowDispatch
CDispatchRestrictor::AllowDispatchForThisSocket
CEmptyBase
CEnvironmentBlockA class for building and manipulating operating system Environment Blocks
CEnvironmentVariablesA class that wraps the operating system Environment Variable API
Certificate
CEventA class that wraps the operating system Event API. See here for more details
CEventLog
CEventOwnerA class that manages an instance of CEvent in a scope based style
CException
CException
CException
CExceptionA simple exception class
CException
CFileBasedCertificateStore
CFileDeleter
CFileInputStreamAn object that implements IInputStream on a file
CFileOutputStreamAn object that implements ICloseableOutputStream on a file
CFilterDataBase
CFilterDataBase::ICallback
CFilterDataBase::ICallback
CFilterHolder
CFilterHolder
CFilteringDatagramSocketConnectionManagerBase
CFilteringStreamSocketConnectionManagerBaseA connection manager for stream sockets
CFlowControlDatagramSocketConnectionFilter
CFlowControlDatagramSocketConnectionFilterData
CFlowControlListProcessorA 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
CFlowControlStreamSocketConnectionFilterA 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
CFullAddressA 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
CFullAddressWrapperA 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
CGlobalNameA kernel object name that is globally visible in the kernel object namespace
CGUID
CGUIDRegistryList
CH264FrameProcessor
CH264FrameSource
CH264NALUnit
CH264ParameterSetReader
CH264RTPSource
CH264SequenceParameterSetParser
CH264SliceHeaderParser
CH264StreamParser
CH264StreamReader
CHandshakeParser
CharReaderInterface for reading JSON from a char array
CharReaderInterface for reading JSON from a char array
CharReader::Factory
CharReader::Factory
CharReaderBuilder
CharReaderBuilder
CHeaders
CHeaders
CHLSFileResource
CHLSH264LiveResource
CHLSLiveResource
CHLSMemoryCacheResourceData
CHLSResource
CHostAssemblyManagerA class that provides a default implementation of the CLR assembly mangement interfaces; IHostAssemblyManager and IHostAssemblyStore
CHostAutoEvent
CHostControl
CHostCriticalSection
CHostMalloc
CHostManualEvent
CHostMemoryManager
CHostPolicyManagerA class that provides a default implementation of the CLR assembly mangement interfaces; IHostPolicyManager
CHostSemaphore
CHostSyncManager
CHostTask
CHostTaskManager
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
CIndexedOpaqueUserDataImplements IIndexedOpaqueUserData in terms of a std::vector of void *
CInMemoryCertificateStore
CInMemoryCertificateStore::Iterator
CInputFilterProcessor
CInputFilterProcessor::Callback
CInterleavedTCPRTPStream
CIntrusiveMultiMapNode
CIntrusiveRedBlackTreeNode
CIOCompletionPortA 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
CIOCPWorkerThreadA thread that services completion packets from an I/O completion port
CIOPoolAn I/O thread pool implementing IIOPool
CIOPool
CIOPool::WorkerThreadA worker thread class for the CIOPool
CIOPoolBaseAn I/O thread pool implementing IIOPool
CIOPoolBase::WorkerThread
CIOPoolBase::WorkerThreadA worker thread class for the CIOPoolBase
CIOPoolExAn I/O thread pool implementing IIOPool
CIOPoolEx
CIOPoolEx::WorkerThreadA worker thread class for the CIOPoolEx
CIORecursionLimiter
CIORecursionLimiter::Call
CIterateCATEGORYINFO
CIterateCATID
CIterateGUID
CIterateString
CIterateUnknown
CJobA class for manipulating operating system job objects
CJobEventManager
CJobEventManagerA class for manipulating operating system job objects
CJSONConfiguration
CJSONDocument
CJSONValue
CKernelObjectNameImplImplements 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
CLibraryLoaderA class which dynamically loads dlls
CLiveH264InterleavedTCPRTPStream
CLiveH264RTPStream
CLiveH264UDPRTPStream
CLocalNameA kernel object name that is locally visible in the kernel object namespace
CLocalTimeProviderA class that implements IProvideLocalTime and returns the local time directly from a call to the operating system GetLocalTime() function. See here for more details
CLockableBufferProcessor
CLockableObject
CLockableObjectTracksLockingThread
CLockableSortedBufferProcessor
CLoggingAsyncFileWriterCallbackA class that implements CAsyncFileWriter::Callback and logs errors and when the pending write limit is reached
CManualResetEventA class that wraps the operating system Event API and exposes just the interface for an manual reset event
CMarshalledInterface
CMemoryBasedMessageLogAn object that implements ILogMessages and
CMemoryCacheStreamDataFile
CMemoryInputOutputStreamAn object that implements IInputStream and ICloseableOutputStream on a memory buffer
CMemoryInputStreamAn object that implements IInputStream on a memory buffer
CMemoryMappedFileA class that wraps the MapViewOfFile() API
CMessageFilter
CMessageFilter::Exception
CMessageLogAn object that implements ILogMessages and and allows other implementations to be plugged into it..
CMiniDumper
CMiniDumpGenerator
CMockAsyncConnectorCallback
CMockICEControlledDTLSConnectionFactory
CMockUDPAsyncConnectorCallback
CMPEG2TransportStreamWriter
CMultiCriticalSectionA class that allows you to manipulate a collection of instances of ICriticalSection 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 locked in the order that they were added to the collection and unlocked in the reverse order
CMultipleFileDeleter
CNamedIndexA 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
CNamedPipeA simple wrapper around the Named Pipe API
CNamedServerCollectionA 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
CNameInfoA class that provides name lookup and formatting for specified addresses
CNAWSSubNegotiator
CNodeListAn 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::NodeThe node class that classes must derive from to be able to be stored in the list
CNotify
CNotify::Exception
CNTPTime
CNullAsyncFileReaderMonitorAn object that implements IMonitorAsyncFileReader and does nothing
CNullAsyncFileWriterMonitorAn object that implements IMonitorAsyncFileWriter and does nothing
CNullBufferAllocationMonitorAn object that implements IMonitorBufferAllocation and does nothing
CNullBufferPool
CNullCallbackTimerQueueMonitorAn object that implements IMonitorCallbackTimerQueue and does nothing
CNullDatagramSocketConnectionFilterA 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
CNullEnvironmentBlockProviderAn implementation of IProvideEnvironmentBlock that always returns a null block
CNullEventSinkCallbackAn implementation of IEventSinkCallback that does nothing
CNullIOPoolMonitorAn object that implements IMonitorIOPool and does nothing
CNullJobMonitorAn object that implements IMonitorThreadPool and does nothing
CNullMessageLogAn object that implements ILogMessages and does nothing
CNullNamedServerShutdownCallback
CNullRTPStream
CNullServerShutdownCallback
CNullSocketAllocationMonitorAn object that implements IMonitorSocketAllocation and does nothing
CNullStreamDataFile
CNullStreamSocketConnectionFilterA 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
CNullStreamSocketFlowControlMonitorA stream socket flow control monitor that does nothing. You can use this
CNullThreadedCallbackTimerQueueMonitorAn object that implements IMonitorCallbackTimerQueue and does nothing
CNullThreadPoolMonitorAn object that implements IMonitorThreadPool and does nothing
CObject
CODBCConnection
CODBCEnvironment
CODBCException
CODBCSmartHandle
CODBCStatement
CODBCTransaction
COneWayToggle
COpaqueUserDataA 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
COperationManager
COptexAn "optimised" mutex class (based on original work by Jeffrey Richter). 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
COptionNegotiator
COptions
COSVersionInfoA simple class that wraps, and initialises, an OSVERSIONINFO structure
COverlappedA class that wraps an OVERLAPPED structure
COverlappedWithEventA class that wraps an OVERLAPPED structure that uses an event
CPacketDecoder
CPendingWriteLimiterAn implementation of ILimitConnections
CPerformanceCounterA class that wraps the QueryPerformanceCounter() API for high performance timing of sections of code
CPerformanceCounterInstallerAn object which implements IInstallPerformanceMonitorCounters and which can be used to install performance counters into a system
CPerformanceCounterLogger
CPerformanceDataBlock
CPerformanceDataCollectorAn 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
CPerformanceDataSchemaAn 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
CPerformanceDataSchemaFileExporterA class which exports CPerformanceDataSchema in the form required by the LoadPerfCounterTextStrings API
CPerformanceMonitorCountersAn 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
CPerThreadErrorHandler
CPerThreadUsageTracker
CPerThreadUsageTracker::Stats
CPINFOEX
CProcessA class for processes
CProcessInformationA simple class that wraps, and cleans up after, a PROCESS_INFORMATION structure
CProcessMemoryA class which allocates and accesses memory in a specified process
CProcessToken
CProcessToken::Enabler
CProcessToken::OptionalEnabler
CProcessToken::Privilege
CProtocolHandler
CProtocolHandler
CProtocolHandlerAllocator
CProtocolHandlerAllocator
CProtocolHandlerFactory
CRAIIAtomicBool
CRAIIBool
CRandomByteProvider
CRandomNumberProvider
CRandomSSRCAllocator
CRawImage
CReadAccumulationBuffer
CReadOnlyFilterData
CReadSequencingStreamSocketConnectionFilterA connection filter that filters read completions and reorders the completions so that they occur in the order of the sequence numbers in their buffers
CReadTimeoutDatagramSocketConnectionFilterA 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
CReadTimeoutStreamSocketConnectionFilterA 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
CRecursiveDirectorySearchA simple class that wraps the FindFirstFile() /FindNextFile() API
CReentrantLockableObject
CReentrantLockableObjectTracksLockingThread
CReentrantSingleWriterMultipleReaderLockA fully reentrant single writer, multiple reader lock
CReentrantSingleWriterMultipleReaderLock2A fully reentrant single writer, multiple reader lock
CReferenceTracker
CRegistryConfiguration
CRegistryKey
CRegistryKey::Exception
CRegistryKey::Exception
CRegistryKey::SubkeyIteratorImpl
CRegistryKey::Value
CRegistryKey::Value::Exception
CRegistryKey::ValueIteratorImpl
CRegKeyIterator
CRequestHeaders
CRequestHeaders
CRequestHeaders
CRequiresElevationException
CResponse
CRetryAndRenameFileCreationFailureHandler
CRingBuffer
CRotatingAsyncFileLogA 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
CSecurityAttributesA simple class that wraps, a SECURITY_ATTRIBUTES structure
CSecurityBuffer
CSecurityDescriptorA simple class that wraps, and initialises, a SECURITY_DESCRIPTOR structure
CSecurityDescriptorAllowAllA simple class that represents a decurity descriptor that allows access to all users
CSecurityPrivilege
CSecurityPrivileges
CSEHExceptionA exception class used by a structured exception translator to translate Win32 structured exceptions into C++ exceptions. Note that it's a deliberate choice not to derive from CException. Win32 structured exceptions include things like "Stack Overflow" so you want to be sure you know what you're doing if you catch one... We could split the SE exception into two, ones we might be able to recover from and those that we can't recover from and derive the ones we might be able to recover from from CException, but..
CSEHException::TranslatorA 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
CSemaphoreA class that wraps the operating system Semaphore API
CSequencedBufferCollectionA 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
CSequencedStreamSocketA stream socket that supports read and write sequencing
CSequencedStreamSocketAllocatorA socket allocator that allocates instances of CSequencedStreamSocket Note that most of the work is down in CSocketAllocator
CServerCollectionA 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
CSetPathObject
CSharedMemoryA 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
CShutdownHandler
CSimpleFixedSizedMemoryAllocatorA 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
CSimpleMessageLogAn object that implements ILogMessages and
CSimpleNamedPipeClientA wrapper around the Named Pipe API which makes it easy to manage named pipe clients
CSimpleNamedPipeServerA 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
CSingleWriterMultipleReaderLockA simple single writer, multiple reader lock
CSingleWriterMultipleReaderLockExA simple single writer, multiple reader lock
CSlimLockableObject
CSlimLockableObjectTracksLockingThread
CSlimReentrantLockableObject
CSlimReentrantLockableObjectTracksLockingThread
CSListA class which wraps the operating system SLIST API
CSList::NodeA node in a CSList
CSmartBool
CSmartHandleA 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
CSmartHandleA 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
CSmartHeapPointerA 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
CSmartLocalPointerA 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
CSmartStartupInfoA simple class that wraps, and initialises, an STARTUPINFO structure and manages the lifetime of any handles within it
CSocketA 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
CSocketAllocatorA 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
CSocketClosedExceptionAn exception that can be thrown if you attempt an operation on a socket that is closed
CSocketReferenceTracker
CSocketReferenceTracker::UsesTracker
CSocketServer
CSortedBufferChain
CSortedBufferProcessor
CStartupInfoA simple class that wraps, and initialises, an STARTUPINFO structure
CStreamDataFile
CStreamDataFileFactory
CStreamProcessor
CStreamProcessor::ICallback
CStreamSocketA stream socket. Note that this socket does NOT support read and write sequencing
CStreamSocketAllocatorA 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
CStreamSocketConnectionManagerBaseA connection manager for stream sockets
CStreamSocketConnectionManagerCallbackAn 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
CStreamSocketConnectionManagerCallbackAn 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
CStreamSocketConnectionManagerCallbackAn 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
CStreamSocketConnectionManagerCallbackAn 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
CStreamSocketServerCallbackAn 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
CStreamSocketServerCallback
CStreamSocketServerExCallbackAn 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
CStreamSocketServerExCallback
CStreamSocketServerExCallback
CStringConverterString 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
CSystemInfoA simple class that wraps, and initialises, a SYSTEM_INFO structure
CSystemShutdownMonitor
CSystemTimeA simple class that wraps, and initialises, and manipulates a SYSTEMTIME structure
CSystemTime::DateDifferenceA simple class that helps to manipluate the difference in date (only) between two SYSTEMTIMEs
CSystemTime::TimeDifferenceA simple class that helps to manipluate the difference in time (only) between two SYSTEMTIMEs
CSystemTimeProviderA 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
CTelnetProtocolHandler
CTelnetProtocolStreamSocketConnectionFilter
CTempDirectoryA 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)
CTerminalTypeSubNegotiator
CTestLog
CTestServerConnector
CThreadA class that wraps the operating system Threading API and provides a thread object that runs code which implements the IRunnable interface
CThreadAffinityA class that wraps the operating system SetThreadAffinityMask API
CThreadedCallbackTimerQueue
CThreadedCallbackTimerQueueA 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
CThreadLocalStorageA class that wraps the operating system Thread Local Storage API
CThreadPoolA 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::WorkerThreadA 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::WorkerThreadA 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
CTickCount64ProviderA class that implements IProvideTickCount64 and returns the tick count directly from a call to the operating system GetTickCount64() function
CTickCountCompare
CTickCountProviderA class that implements IProvideTickCount and returns the tick count directly from a call to the operating system GetTickCount() function. See here for more details
CTimeChangeAwareRotatingAsyncFileLogA 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
CTimeChangeNotificationMonitor
CTimeStamp
CToken
CUDPAsyncConnector
CUDPAsyncConnectorTest
CUDPConnectionCreator
CUDPRTPStream
CUnqualifiedNameA kernel object name that is unquallifier in the kernel object namespace
CUnsortedBufferProcessor
CUsesCOM
CUsesCOMA 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
CUsesMSWinSockExtensionsThis 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
CUsesSecurity
CUsesSecurity::Exception
CUsesWinsockA 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
CUsesXPBluetooth
CUTF8StreamConverter
CWaitableCounterA counter that can be incremented and decremented and where you can wait on it either becoming zero or becoming non-zero
CWaitableCounter::DecrementerA 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::IncrementerA 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
CWebSocket
CWebSocketException
CWin32ExceptionA simple exception class to replace Win32 error returns
CWOW64FileSystemRedirector
CWriteAccumulationBuffer
CWriteOnlyFilterData
CXMLAttribute
CXMLConfiguration
CXMLConfigurationElement
CXMLDocument
CXMLElement
CXMLNode
Failure
FastWriter
FastWriter
Features
Features
IAcceptDatagramSocketConnectionFiltersThis 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
IAcceptStreamSocketConnectionFiltersThis interface works in conjunction with IFilterStreamSocketConnections and allows stream filters to be added to a class that can use them
IAcceptWebSocketConnections
IActionOnCLREvent
IAddBuffersToPool
IAddressAn 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
IAddressRefA reference counted IAddress
IAddressTypeAn interface that provides meta-data information about the type of a Winsock Address
IAllocatableBuffer
IAllocateBuffer
IAllocateBufferHandlesAn interface to a class that allocates instances of CBufferHandle which can be attached to an instance of an IBuffer
IAllocateBuffersAn 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
IAllocateDatagramServerSocketsAn interface for allocating IPoolableDatagramServerSocket
IAllocateDatagramSocketsAn interface for allocating IPoolableDatagramSocket
IAllocateFixedSizedMemoryProvides an interface that can allocate fixed sized blocks of memory
IAllocateMemory
IAllocatePoolableSocketsAn interface for managing IPoolableSocket
IAllocateSequencedStreamSocketsAn 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
IAllocateStreamSocketsAn interface for allocating instances of IPoolableStreamSocket
IAssignProcessesToJobsProvides an interface that can assign a process to a job
IAsyncIOStreamAn 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
IAsyncSocketAn 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
IBroadcastRTPStreams
IBufferBaseAn 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 attemp 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
ICloseableOutputStreamAn extension to IOutputStream that allows the user to call Close() on it
ICollectPerformanceDataAn 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
IConfigurationProvides an interface to a tree structured configuration such as something that could easily be modelled by an XML file or the registry
IConnectableProtocolHandler
IContext
ICreateFilteredStreamSocketConnectionsAn interface used to create outgoing stream socket connections
ICreateMiniDumpsProvides an interface that can create a mini dump of a process
ICreateRTPPackets
ICreateRTPPackets::Data
ICreateStreamSocketConnectionsAn interface used to create outgoing stream socket connections
ICreateUDPConnections
ICreateUDPConnections::Callback
ICriticalSectionAn interface onto the operating system Critical Section API
ICriticalSection::ConditionalOwnerA class that may take ownership of an instance of ICriticalSection. That is it calls Enter() in the constructor and Leave() 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 ICriticalSection
ICriticalSection::OwnerA class that takes ownership of an instance of ICriticalSection. That is it calls Enter() in the constructor and Leave() in the destructor and can therefore be used to support scope based locking and unlocking of instances of ICriticalSection
ICriticalSection::PotentialOwnerA class that may take ownership of an instance of ICriticalSection. If you call Enter() or TryEnter() on this class it will keep track of the fact that the critical section 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 ICriticalSection
IDataDeflatorFactory
IDatagramSendSocket
IDatagramServerSocketThis 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 ..
IDatagramServerSocketCallbackThe 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
IDatagramServerSocketConnectionManagerAn 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
IDatagramServerSocketExA socket interface that adds functionality that is used internally by the socket server classe
IDatagramSocketThis 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
IDatagramSocketCallbackThe 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
IDatagramSocketConnectionManagerAn 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()
IDatagramSocketConnectionManagerCallbackThe 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
IDatagramSocketExA socket interface that adds functionality that is used internally by the connection manager and socket server classes
IDatagramSocketServerCallbackThe 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
IDeflateData
IDispatchServiceControls
IDispatchToWorkerThread
IDisplayMessageBox
IEnumIterator
IEnumIterator::NullIterator
IEventSinkCallbackA callback interface that is used by CCLREventSink to report events
IFilterableDatagramSocketAn interface which adds functionality that is useful when filtering a connection
IFilterableStreamSocketAn interface which adds functionality that is useful when filtering a connection
IFilterData
IFilterDatagramSocketConnectionsAn 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
IFilterStreamSocketConnectionsAn 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
IFullAddressAn interface that represents an IAddress which knows about its address type and that can create dynamically allocated copies of itself
IGenerateRTCPPackets
IHandleExceptions
IHandleFileCreationFailure
IHandleJobEventsAn interface to allow a class to handle the events that are generated by operating system Job objects
IHandlerAn interface that represents code that handles operations on I/O buffers
IHandshakeParserCallback
IHostAssemblyManager
IHostAssemblyStore
IHostAutoEvent
IHostControl
IHostControlAn interface that extends the MSCoreE IHostControl interface..
IHostCrst
IHostMalloc
IHostManualEvent
IHostMemoryManager
IHostPolicyManager
IHostPolicyManagerCallbackA callback interface that is used by CHostPolicyManager to report events
IHostSemaphore
IHostSyncManager
IHostTask
IHostTaskManager
IHTTPRequestProcessor
IHTTPResource
IHTTPResourceData
IHTTPResponseProcessor
IHTTPStream
IICEConnection
IICEConnectionCallback
IICEConnectionManager
IICEConnectionManagerCallback
IICEControlledDTLSConnection
IICEControlledDTLSConnectionCallback
IICEControlledDTLSConnectionFactory
IIndexedOpaqueUserDataProvides 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
IInputStreamAn interface to an input stream (which may be sync or async)
IInstallPerformanceMonitorCountersAn interface to an object that can install performance counters on a system. See here for more details
IInterleavedRTPTCPStream
IIOCPWorkerThreadCallbackAn interface to an object that acts as a worker thread for an I/O completion port driven 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()
IIOPoolAn 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
IIPAddressAn interface that represents an IP address which knows about its port
IIterateableBufferChain
IKernelObjectNameAn interface that represents a name in the kernel object namespace See here for more details
ILimitConnectionsAn 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::CreatorA 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
ILimitPendingWritesAn 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
ILockableBufferProcessor
ILockableObjectAn interface onto objects that can be locked
ILockableObjectTracksLockingThreadAn 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
ILoggablePerformanceMonitorCounters
ILogMessagesAn 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
IMaintainStreamSocketConnectionsAn interface used to create and maintain outgoing stream socket connections
IManageBufferHandleLifeCycleA helper interface to remove a friend relationship between buffers and their allocators..
IManageBufferLifeCycleA helper interface to remove a friend relationship between buffers and their allocators..
IManageDatagramSocketConnectionFiltersThis 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
IManageEnvironmentVariablesAn interface for manipulating operating system environment variables
IManageHTTPResourceData
IManageJobEventsAn 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
IManageStreamSocketConnectionFiltersThis 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
IManageThreadPoolThreadsAn interface to allow a thread pool to monitor the actions of the threads that it manages
IManageTimerQueueAn 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
IMessageFilter
IMonitorAsyncFileReaderAn interface to allow a class to monitor an instance of an async file reader
IMonitorAsyncFileWriterAn interface to allow a class to monitor an instance of an async file writer
IMonitorBufferAllocationAn 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
IMonitorCallbackTimerQueueAn interface to allow a class to monitor the operation of an instance of CCallbackTimerQueue
IMonitorDatagramSocketFlowControl
IMonitorICEControlledDTLSConnection
IMonitorIOPoolAn interface to allow a class to monitor an instance of an I/O 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 I/O thread itself. Incrementing a counter when OnIOPoolThreadCreated() is called and decrementing it when OnIOPoolThreadDestroyed() 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 OnIOPoolThreadBeginProcessing() and decremented in OnIOPoolThreadEndProcessing() is called will give a count of the threads that are currently in use
IMonitorJobsAn interface to allow a class to monitor the events that are generated by instances of CJob
IMonitorSocketAllocationAn 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
IMonitorStreamSocketFlowControlAn 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
IMonitorThreadedCallbackTimerQueueAn interface to allow a class to monitor the operation of an instance of CCallbackTimerQueue
IMonitorThreadPoolAn interface to allow a class to monitor the operation of an instance of CThreadPool. Incrementing a counter when OnThreadPoolThreadStarted() is called and decrementing it when OnThreadPoolThreadStopped() is called will give you a count of the number of threads that are in the thread pool. A corresponding counter that is incremented in OnThreadPoolProcessingStarted() and decremented when OnThreadPoolProcessingStopped() is called will give a count of the threads that are currently processing work items
INamedServerShutdownCallback
INotifyOnLastStreamDataWrite
INotifyOnMemoryCacheStreamWritten
INotifyProgress
IODBCConnection
IODBCEnvironment
IODBCStatement
IOptionSubNegotiator
IOutputStreamAn interface to an output stream (which may be sync or async)
IPoolableDatagramServerSocketAn 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
IPoolableDatagramSocketAn 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
IPoolableSocketThe 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
IPoolableSocketManagerA 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
IPoolableStreamSocketAn 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
IProcessingInputFilterProcessor
IProcessPayloadFrames
IProcessRTPFrames
IProtocolHandler
IProtocolHandlerAllocator
IProtocolHandlerAllocator
IProtocolHandlerFactory
IProvideEnvironmentBlockAn interface for providing operating system environment variable blocks as detailed here
IProvideH264NALUnits
IProvideLocalTimeAn interface that provides access to the operating system GetLocalTime() call. Code can access this service via an instance to IProvideLocalTime so that the provider can be replaced (usually for testing purposes). See here for more details
IProvideRandomBytes
IProvideRandomNumbers
IProvideRTPData
IProvideStreamData
IProvideSystemTimeAn 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
IProvideTickCountAn interface that provides access to the operating system GetTickCount() call. Code can access this service via an instance of IProvideTickCount so that the provider can be replaced (usually for testing purposes). See here for more details
IProvideTickCount64An interface that provides access to the operating system GetTickCount64() call. Code can access this service via an instance of IProvideTickCount64 so that the provider can be replaced (usually for testing purposes). See here for more details
IProvideUserDataAn 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
IProvideWorkItemsA restricted interface onto a queue of work items (such as an I/O completion port, perhaps)
IQueueTimersAn 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::TimerAn interface to a timer that can be set with IQueueTimers
IReentrantLockableObjectAn 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
IReentrantLockableObjectTracksLockingThreadAn 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
IReleaseCreatedConnections
IReleaseSSRCs
IRenderAddressesAn 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
IRTPPacketStream
IRTPStream
IRTPStreamRefCount
IRTSPResource
IRTSPServer
IRTSPSession
IRunnableAn interface to code that can be Run() on a thread. Usually passed to the CThread constructor
ISaveStreamData
ISecureStreamSocketCallback
ISecureStreamSocketCallback
ISecureStreamSocketCallback
IServerContext
IServerControlAn 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
ISingleWriterMultipleReaderLock
ISingleWriterMultipleReaderLock::ConditionalOwnerA base class to support the ConditionalReader and ConditionalWriter classes
ISingleWriterMultipleReaderLock::ConditionalReaderA 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::ConditionalWriterA 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::PotentialOwnerA base class to support the PotentialReader and PotentialWriter classes
ISingleWriterMultipleReaderLock::PotentialReaderA 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::PotentialWriterA 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::ReaderA 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::WriterA 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
ISocketCallbackThe 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
IStreamAn interface to an stream..
IStreamDataFileFactory
IStreamSocketThis 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
IStreamSocketCallbackThe 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
IStreamSocketConnectionManagerAn 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
IStreamSocketConnectionManagerCallbackThe 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
IStreamSocketConnectionManagerCallback
IStreamSocketConnectionManagerIO
IStreamSocketExA socket interface that adds functionality that is used internally by the connection manager and socket server classes
IStreamSocketServerCallback
IStreamSocketServerCallback
IStreamSocketServerCallback
IStreamSocketServerCallbackThe 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
IStreamSocketServerExCallbackThe 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
ISubNegotiationController
ISupportMulticastThe interface used to support multicasting
ITelnetProtocolHandler
ITelnetProtocolHandlerCallback
ITelnetProtocolHandlerFactory
IThreadPoolWorkerThreadFactoryAn interface to create instances of IIOCPWorkerThreadCallback. Usually passed to the CThreadPool constructor
ITrackLockingThreadAn 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
ITrackReferences
ITransmitRTCPPackets
ITransmitRTPPackets
IUDPAsyncConnectorCallback
IUnsortedBufferChain
IWaitableAn 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
IWebSocket
IWebSocket
IWebSocket
IWebSocketInputHandler
IWebSocketServer
IWebSocketServer
IWritableAddressAn 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())
IWritableAddressRefA reference counted IWritableAddress
jb_enable_if
jb_enable_if< false, T >
OSVERSIONINFOEX
OVERLAPPED
Path
Path
PathArgument
PathArgument
PredicateContextContext 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
Registry::TRegistryList
Runner
SCHANNEL_CRED
SEC_WINNT_AUTH_IDENTITY
SecBufferDesc
SECURITY_ATTRIBUTES
SECURITY_DESCRIPTOR
ServiceTypes
SLIST_ENTRY
StackWalker
StackWalker::CallstackEntry
STARTUPINFO
StaticString
StaticString
StreamWriterUsage:
StreamWriterUsage:
StreamWriter::Factory
StreamWriter::Factory
StreamWriterBuilder
StreamWriterBuilder
StyledStreamWriter
StyledStreamWriter
StyledWriter
StyledWriter
SubkeyIteratorImpl
SYSTEM_INFO
SYSTEMTIME
TAddressOrderedMultiLockA 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
TAsyncSocketA template class that provides most of the functionality that is shared between all socket types
TCache
TComEnumerator
TConditionalSmartPointerA 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
TDatagramSocketConnectionManagerA connection manager for datagram sockets
TDatagramSocketServerA socket server for datagram sockets
TestCase
TestResult
TExceptionToCOMError
TExpandableBufferA template class for an expandable buffer, that is a buffer that can be expanded and which will, if expanded, maintain its contents
TIntrusiveMap
TIntrusiveMapNodeKeyAccessorKeyIsAddress
TIntrusiveMultiMap
TIntrusiveMultiMap::Iterator
TIntrusiveMultiMap::NodeCollection
TIntrusiveMultiMap::NodeCollection::Iterator
TIntrusiveMultiMapNodeIsBaseClass
TIntrusiveRedBlackTree
TIntrusiveRedBlackTree::Iterator
TIntrusiveRedBlackTreeNodeIsBaseClass
TIntrusiveRedBlackTreeNodeIsEmbeddedMember
TIntrusiveSet
TIntrusiveSetNodeKeyAccessorKeyIsAddress
TLinkedClass
TLockableObject
TLockableObjectConditionalOwnerA 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
TLockableObjectOwnerA 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
TLockableObjectPotentialOwnerA 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
TMarshalledInterface
TMulticastDatagramHelperA socket server for datagram sockets
TMultipleRangeReusableIdManager
TMultipleRangeReusableIdManagerBase
TMultipleRangeReusableIdManagerBase::InitialRanges
TNodeListA 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
TNotify
TReentrantLockableObject
TReentrantLockableObjectPotentialOwner
TReentrantLockableObjectTracksLockingThread
TReferenceCountedA template class that wraps a class to provide it with and manage an external reference count
TReferenceCountedSmartPointerA template smart pointer class that manages objects that support AddRef() and Release() style reference counting
TRegistryList
TRegistryList::iterator
TRegKeyIterator
TReleaseOnlyReferenceCountedSmartPointerA template smart pointer class that manages objects that support Release() style reference counting
TReusableIdManager
TReusableIdManager::Interval
TReusableIdManager::SmartId
TSecurityBuffers
TSocketAllocatorA template class that provides most of the socket allocation functionality that is shared between all socket types
TStreamSocketConnectionManagerA connection manager for stream sockets
TStreamSocketServer
TStreamSocketServer
TStreamSocketServerA socket server for stream sockets. Runs a thread to handle connection establishment using accept
TStreamSocketServer
TStreamSocketServerExA 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
TTypeSafeTypedef
TWebSocketBase
TWebSocketBase::AutoCloser
TZeroInitialiseExpandableBufferA 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

Generated on Wed Jan 17 15:18:24 2018 for The Server Framework - v6.9.1 by doxygen 1.5.3