| _NLA_BLOB | |
| _TRANSMIT_FILE_BUFFERS | |
| _TRANSMIT_PACKETS_ELEMENT | |
| _WSACMSGHDR | |
| _WSAMSG | |
| JetByteTools::Socket::CAddress | Essentially a smart pointer to a CAddressImpl instance |
| JetByteTools::Socket::CAddressImpl | A reference counted wrapper around a SOCKADDR_STORAGE structure that knows how big the address that's stored is |
| JetByteTools::Socket::CAddressInfo | A class that provides addressing information for the specified host |
| JetByteTools::Socket::CAddressInfo::Iterator | An iterator to addresses that are supported by the host |
| JetByteTools::Socket::CAddressIPv4 | An IPv4 address |
| JetByteTools::Socket::CAddressIPv6 | An IPv6 address |
| JetByteTools::Socket::CAddressRenderer | An implementation of IRenderAddresses |
| JetByteTools::Socket::CAddressType | A generic implementation of the IAddressType interface. Should be suitable for all types of addresses, just supply the appropriate values to the constructor |
| JetByteTools::Socket::CAddressTypeIPv4 | A implementation of the IAddressType interface for IPv4 |
| JetByteTools::Socket::CAddressTypeIPv6 | A implementation of the IAddressType interface for IPv6 |
| JetByteTools::Socket::CAddressWrapper | A facade that allows a SOCADDR * to be accessed via the IAddress interface |
| JetByteTools::IO::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 |
| JetByteTools::IO::CAsyncFileReader::Callback | An interface for users of the CAsyncFileReader to be notified of the results of the asynchronous read operations on the file |
| JetByteTools::IO::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 |
| JetByteTools::IO::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 |
| JetByteTools::Win32::CAutoResetEvent | A class that wraps the operating system Event API and exposes just the interface for an auto reset event |
| JetByteTools::IO::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 |
| JetByteTools::IO::CBufferAllocator | An implementation of IAllocateBuffers which pools buffer instances for later reuse |
| JetByteTools::IO::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 |
| JetByteTools::Win32::CCallbackTimerQueue | 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 HandleTimeouts() every GetNextTimeout() milliseconds. See here for more details |
| JetByteTools::Win32::CCommandLine | A class that parses the command line and can report on whether specified switches or arguments have been passed to a program |
| JetByteTools::Socket::CConnectionLimiter | An implementation of ILimitConnections |
| JetByteTools::Win32::CCriticalSection | A 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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::CDatagramServerSocketAllocator | A socket allocator that allocates datagram server sockets. Note that most of the work is down in CSocketAllocator |
| JetByteTools::Socket::CDatagramSocket | A datagram socket that allows you to RecvFrom() and SendTo() any host |
| JetByteTools::Socket::CDatagramSocketAllocator | A socket allocator that allocates datagram sockets. Note that most of the work is down in CSocketAllocator |
| JetByteTools::Socket::CDatagramSocketConnectionManager | A connection manager for datagram sockets |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::CDatagramSocketServer | A socket server for stream sockets. Runs a thread to handle connection establishment using accept |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::CDirectoryChangeMonitor | Unfinished |
| JetByteTools::Win32::CDirectoryChangeMonitor::Callback | |
| JetByteTools::Win32::CDirectorySearch | A simple class that wraps the FindFirstFile() /FindNextFile() API |
| JetByteTools::Win32::CEvent | A class that wraps the operating system Event API. See here for more details |
| JetByteTools::Win32::CEventOwner | A class that manages an instance of CEvent in a scope based style |
| JetByteTools::Win32::CException | A simple exception class |
| JetByteTools::Win32::CFileChangeMonitor | Unfinished |
| JetByteTools::Win32::CFileChangeMonitor::Callback | |
| JetByteTools::IO::CFileInputStream | An object that implements IInputStream on a file |
| JetByteTools::IO::CFileOutputStream | An object that implements ICloseableOutputStream on a file |
| JetByteTools::Win32::CGlobalName | A kernel object name that is globally visible in the kernel object namespace |
| JetByteTools::Win32::CIndexedOpaqueUserData | Implements IIndexedOpaqueUserData in terms of a std::vector of void * |
| JetByteTools::IO::CInOrderBufferList | 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 relies on the caller to maintain the correct reference counting semantics and doesn't hold a reference to the buffers that are inserted in it; this doesn't feel right.. |
| JetByteTools::Win32::CInstrumentedSharedCriticalSection | An instance of ICriticalSectionFactory, based on CSharedCriticalSection that can report on the distribution of the hash function and can be used to tune the parameters to the hash functions. It tracks how the hash distributes across the locks and reports on the distribution during factory destruction |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CIOCPWorkerThread | A thread that services completion packets from an I/O completion port |
| JetByteTools::IO::CIOPool | An I/O thread pool implementing IIOPool |
| JetByteTools::IO::CIOPool::WorkerThread | A worker thread class for the CIOPool |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CLibraryLoader | A class which dynamically loads dlls |
| JetByteTools::Win32::CLocalName | A kernel object name that is locally visible in the kernel object namespace |
| JetByteTools::IO::CLockFreeBuffer | 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. This class differs from CBuffer only in that it uses the CSList to string the buffers together in the allocator rather than the CNodeList. This makes the allocator lock free; which may have some positive performance implications in some circumstances (but we've yet to find them or even look that hard for them). Ideally the shared code between this and CBuffer could be removed |
| JetByteTools::IO::CLockFreeBufferAllocator | An implementation of IAllocateBuffers which pools buffer instances for later reuse and uses CSList to pool the buffers. This list is lock free; which may have some positive performance implications in some circumstances (but we've yet to find them or even look that hard for them). Ideally the shared code between this and CBufferAllocator could be removed |
| JetByteTools::Win32::CManualResetEvent | A class that wraps the operating system Event API and exposes just the interface for an manual reset event |
| JetByteTools::IO::CMemoryInputOutputStream | An object that implements IInputStream and ICloseableOutputStream on a memory buffer |
| JetByteTools::IO::CMemoryInputStream | An object that implements IInputStream on a memory buffer |
| JetByteTools::Win32::CMemoryMappedFile | A class that wraps the MapViewOfFile() API |
| JetByteTools::Win32::CMultiCriticalSection | A 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 |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CNamedPipe | A simple wrapper around the Named Pipe API |
| JetByteTools::Socket::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 |
| JetByteTools::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 |
| JetByteTools::CNodeList::Node | The node class that classes must derive from to be able to be stored in the list |
| JetByteTools::IO::CNullBufferAllocationMonitor | An object that implements IMonitorBufferAllocation and does nothing |
| JetByteTools::IO::CNullIOPoolMonitor | An object that implements IMonitorIOPool and does nothing |
| JetByteTools::Socket::CNullSocketAllocationMonitor | An object that implements IMonitorSocketAllocation and does nothing |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::CNullThreadPoolMonitor | An object that implements IMonitorThreadPool and does nothing |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::COptex | An "optimised" mutex class (based on original work by Jeffrey Richter) |
| JetByteTools::Win32::COSVersionInfo | A simple class that wraps, and initialises, an OSVERSIONINFO structure |
| JetByteTools::Win32::COverlapped | A class that wraps an OVERLAPPED structure |
| JetByteTools::Win32::COverlappedWithEvent | A class that wraps an OVERLAPPED structure that uses an event |
| JetByteTools::Win32::CPerformanceCounter | A class that wraps the QueryPerformanceCounter() API for high performance timing of sections of code |
| JetByteTools::Win32::CProcessInformation | A simple class that wraps, and cleans up after, a PROCESS_INFORMATION structure |
| JetByteTools::Win32::CProcessMemory | A class which allocates and accesses memory in a specified process |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::CSecurityAttributes | A simple class that wraps, a SECURITY_ATTRIBUTES structure |
| JetByteTools::Win32::CSecurityDescriptor | A simple class that wraps, and initialises, a SECURITY_DESCRIPTOR structure |
| JetByteTools::Win32::CSecurityDescriptorAllowAll | A simple class that represents a decurity descriptor that allows access to all users |
| JetByteTools::Win32::CSEHException | A 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.. |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CSemaphore | A class that wraps the operating system Semaphore API |
| JetByteTools::Socket::CSequencedStreamSocket | A stream socket that supports read and write sequencing |
| JetByteTools::Socket::CSequencedStreamSocketAllocator | A socket allocator that allocates instances of CSequencedStreamSocket Note that most of the work is down in CSocketAllocator |
| JetByteTools::Socket::CServerCollection | A class that implements a collection of instances of IServerControl and that allows you to control all of the instances as one |
| JetByteTools::Win32::CSharedCriticalSection | An instance of ICriticalSectionFactory that gives out instances of ICriticalSection from a fixed sized pool of instances that are provided to callers by hashing the key that the caller passes. This allows the factory to share a finite set of objects between all callers in (hopefully) a fair manner |
| JetByteTools::Win32::CSharedMemory | A wrapper around the File Mapping, memory management, API which makes shared memory easier to use |
| JetByteTools::Win32::CSimpleNamedPipeClient | A wrapper around the Named Pipe API which makes it easy to manage named pipe clients |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock | A simple single writer, multiple reader lock |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock::ConditionalOwner | A base class to support the ConditionalReader and ConditionalWriter classes |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock::ConditionalReader | A class that may lock an instance of CSingleWriterMultipleReaderLock 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 |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock::ConditionalWriter | A class that may lock an instance of CSingleWriterMultipleReaderLock 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 |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock::Reader | A class that locks an instance of CSingleWriterMultipleReaderLock 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 |
| JetByteTools::Win32::CSingleWriterMultipleReaderLock::Writer | A class that locks an instance of CSingleWriterMultipleReaderLock 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 |
| JetByteTools::Win32::CSList | A class which wraps the operating system SLIST API |
| JetByteTools::Win32::CSList::Node | A node in a CSList |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::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 |
| JetByteTools::Socket::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 |
| JetByteTools::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 |
| JetByteTools::Socket::CSocketClosedException | An exception that can be thrown if you attempt an operation on a socket that is closed |
| JetByteTools::Win32::CStartupInfo | A simple class that wraps, and initialises, an STARTUPINFO structure |
| JetByteTools::Socket::CStreamSocket | A stream socket. Note that this socket does NOT support read and write sequencing |
| JetByteTools::Socket::CStreamSocketAllocator | A socket allocator that allocates instances of CStreamSocket. Note that most of the work is down in CSocketAllocator |
| JetByteTools::Socket::CStreamSocketConnectionManager | A connection manager for stream sockets |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::CStreamSocketServer | A socket server for stream sockets. Runs a thread to handle connection establishment using accept |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::CStreamSocketServerEx | 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 |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::CStringConverter | String conversion functions, use these in preference to USES_CONVERSION. Doesn't suffer from the stack blowing limitations of USES_CONVERSION |
| JetByteTools::Win32::CSystemInfo | A simple class that wraps, and initialises, a SYSTEM_INFO structure |
| JetByteTools::Win32::CSystemTime | A simple class that wraps, and initialises, and manipulates a SYSTEMTIME structure |
| JetByteTools::Win32::CSystemTime::DateDifference | A simple class that helps to manipluate the difference in date (only) between two SYSTEMTIMEs |
| JetByteTools::Win32::CSystemTime::TimeDifference | A simple class that helps to manipluate the difference in time (only) between two SYSTEMTIMEs |
| JetByteTools::Win32::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>=""> + "-" + time(0) |
| JetByteTools::Win32::CThread | A class that wraps the operating system Threading API and provides a thread object that runs code which implements the IRunnable interface |
| JetByteTools::Win32::CThreadAffinity | A class that wraps the operating system SetThreadAffinityMask API |
| JetByteTools::Win32::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 a CCallbackTimerQueue object to manage the timers and then manages its own timeouts using a thread to call CCallbackTimerQueue::HandleTimeouts() every GetNextTimeout() milliseconds. See here for more details |
| JetByteTools::Win32::CThreadLocalStorage | A class that wraps the operating system Thread Local Storage API |
| JetByteTools::Win32::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 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 |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CUnqualifiedName | A kernel object name that is unquallifier in the kernel object namespace |
| JetByteTools::Win32::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 |
| JetByteTools::Socket::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) |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::CWaitableCounter | A counter that can be incremented and decremented and where you can wait on it either becoming zero or becoming non-zero |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::CWin32Exception | A simple exception class to replace Win32 error returns |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IAddressRef | A reference counted IAddress |
| JetByteTools::Socket::IAddressType | An interface that provides meta-data information about the type of a Winsock Address |
| JetByteTools::IO::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 |
| JetByteTools::Socket::IAllocateDatagramServerSockets | An interface for allocating IPoolableDatagramServerSocket |
| JetByteTools::Socket::IAllocateDatagramSockets | An interface for allocating IPoolableDatagramSocket |
| JetByteTools::Socket::IAllocatePoolableSockets | An interface for managing IPoolableSocket |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IAllocateStreamSockets | An interface for allocating instances of IPoolableStreamSocket |
| JetByteTools::IO::IAsyncIOStream | An interface onto an asynchrnonous I/O stream. Calls to Write() are not guarenteed 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 |
| JetByteTools::Socket::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 |
| JetByteTools::IO::IBuffer | An interface to a buffer used for socket I/O (this, probably should be refactored and split into two interfaces, one derived from the other and one of them should live in the Socket Tools library) |
| JetByteTools::IO::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 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 |
| JetByteTools::IO::ICloseableOutputStream | An extension to IOutputStream that allows the user to call Close() on it |
| JetByteTools::Win32::ICriticalSection | An interface onto the operating system Critical Section API. Note that this class only provides the basic Enter() and Leave() functionality, should TryEnter() ever be required then it's likely that a new interface will be added that includes this rather than extending this interface to include it |
| JetByteTools::Win32::ICriticalSection::ConditionalOwner | A 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 |
| JetByteTools::Win32::ICriticalSection::Owner | A 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 |
| JetByteTools::Win32::ICriticalSectionFactory | An interface to a factory that gives out instances of ICriticalSection. All of the methods which provide an instance of an ICriticalSection require a key of some kind to be given. This allows the factory to (optionally) have a fixed sized pool of instances that are provided to callers by hashing the key that the caller passes. This would allow the factory to share a finite set of objects between all callers in (hopefully) a fair manner. Alternatively, of course, an implementation might simply ignore the key that the caller provides and, instead, allocate a unique instance of ICriticalSection per call |
| JetByteTools::Socket::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 .. |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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() |
| JetByteTools::Socket::IDatagramServerSocketEx | A socket interface that adds functionality that is used internally by the socket server classe |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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() |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IDatagramSocketEx | A socket interface that adds functionality that is used internally by the connection manager and socket server classes |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IFilterableStreamSocket | An interface which adds functionality that is useful when filtering a connection |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IFullAddress | An interface that represents an IAddress which knows about its address type and that can create dynamically allocated copies of itself |
| JetByteTools::IO::IHandler | An interface that represents code that handles operations on I/O buffers |
| JetByteTools::Win32::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 |
| JetByteTools::IO::IInputStream | An interface to an input stream (which may be sync or async) |
| JetByteTools::Win32::IIOCPWorkerThreadCallback | An interface to an object that acts as a worker thread for an I 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() |
| JetByteTools::IO::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 |
| JetByteTools::Win32::IKernelObjectName | An interface that represents a name in the kernel object namespace See here for more details |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::IO::IManageBufferLifeCycle | A helper interface to remove a friend relationship between buffers and their allocators.. |
| JetByteTools::Socket::IManageStreamSocketConnectionFilters | This interface works in conjunction with IFilterStreamSocketConnections to and allows 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 |
| JetByteTools::IO::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 |
| JetByteTools::IO::IMonitorIOPool | An 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 |
| JetByteTools::Socket::IMonitorSocketAllocation | An interface to allow a class to monitor the operation of a class that allocates sockets. 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 |
| JetByteTools::Win32::IMonitorThreadPool | An 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 |
| JetByteTools::IO::IOutputStream | An interface to an output stream (which may be sync or async) |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::IProvideTickCount | An interface that provides access to the operating system GetTickCount() call. Code can access this service via an instance to IProvideTickCount so that the provider can be replaced (usually for testing purposes). See here for more details |
| JetByteTools::Win32::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 |
| JetByteTools::IO::IProvideWorkItems | A restricted interface onto a queue of work items (such as an I/O completion port, perhaps) |
| JetByteTools::Win32::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 |
| JetByteTools::Win32::IQueueTimers::Timer | An interface to a timer that can be set with IQueueTimers |
| JetByteTools::Socket::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 |
| JetByteTools::Win32::IRunnable | An interface to code that can be Run() on a thread. Usually passed to the CThread constructor |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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() |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::IStreamSocketEx | A socket interface that adds functionality that is used internally by the connection manager and socket server classes |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::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 |
| JetByteTools::Socket::ISupportMulticast | The interface used to support multicasting |
| JetByteTools::Win32::IThreadPoolWorkerThreadFactory | An interface to create instances of IIOCPWorkerThreadCallback. Usually passed to the CThreadPool constructor |
| JetByteTools::Win32::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 |
| JetByteTools::Socket::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()) |
| JetByteTools::Socket::IWritableAddressRef | A reference counted IWritableAddress |
| OSVERSIONINFO | |
| PROCESS_INFORMATION | |
| SECURITY_ATTRIBUTES | |
| SECURITY_DESCRIPTOR | |
| SLIST_ENTRY | |
| STARTUPINFO | |
| SYSTEM_INFO | |
| SYSTEMTIME | |
| JetByteTools::Socket::TAsyncSocket< Base, Manager, Callback > | A template class that provides most of the functionality that is shared between all socket types |
| JetByteTools::TExpandableBuffer< T > | A template class for an expandable buffer, that is a buffer that can be expanded and which will, if expanded, maintain its contents |
| JetByteTools::TLinkedClass< T > | A template class for classes that are linked together via a singly linked list that can be navigated either from an instance of the class or from the template |
| JetByteTools::TLinkedClass< T >::BadIndex | Exceptions we throw |
| JetByteTools::TLinkedClassIterator< T > | An iterator over a list of linked classes |
| JetByteTools::TLinkedClassIterator< T >::NullIterator | Exceptions we throw |
| JetByteTools::TNodeList< T > | 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 |
| JetByteTools::TReferenceCounted< T, B > | A template class that wraps a class to provide it with and manage an external reference count |
| JetByteTools::TReferenceCountedSmartPointer< T > | A template smart pointer class that manages objects that support AddRef() and Release() style reference counting |
| JetByteTools::TSingleton< T > | A naive template Singleton class. Remember, Singletons are EVIL! and what's more they're generally unnecessary. See here for more details |
| JetByteTools::Socket::TSocketAllocator< Base > | A template class that provides most of the socket allocation functionality that is shared between all socket types |
| WIN32_FIND_DATA | |
