| _MByteBuffer | Definition of our byte-array class, including size value |
| _MMessageIterator | This object is used in field name iterations |
| _MPoint | Definition of our Point class -- two floats |
| _MRect | Definition of our Rect class -- four floats |
| AbstractGatewayMessageReceiver | Interface for any object that wishes to be notified by AbstractMessageIOGateway::DoInput() about received Messages |
| AbstractMessageIOGateway | Abstract base class representing an object that can send/receive Messages via a DataIO byte-stream |
| AbstractObjectGenerator | An interface that must be implemented by all ObjectPool classes |
| AbstractObjectManager | This class is just here to usefully tie together the object generating and object recycling capabilities of its two superclasses into a single interface |
| AbstractObjectRecycler | An interface that must be implemented by all ObjectPool classes |
| AbstractReflectSession | This is the abstract base class that defines the server side logic for a single client-server connection |
| AbstractSessionIOPolicy | This class is an interface for objects that can be used by a ReflectServer to control how and when I/O in a particular direction is performed for a session or group of sessions |
| AcceptSocketsThread | A thread that waits for TCP connections on a given port, and when it gets one, it sends the socket to its owner via a SocketRef |
| AndOrQueryFilter | This class matches iff at least (n) of its children match |
| AThread< BaseThread > | This class is templated to use as a AtheOS-specific subclass of any MUSCLE Thread subclass |
| AtomicCounter | This is a teensy little class that works as a cross-platform atomic counter variable |
| AutoCleanupProxyMemoryAllocator | This MemoryAllocator decorates its slave MemoryAllocator to call a list of OutOfMemoryCallback objects when the slave's memory allocation fails |
| BitChord< NumBits > | A templated class for implement an N-bit-long bit-chord |
| BThread< BaseThread > | This class is templated to use as a BeOS-specific subclass of any MUSCLE Thread subclass |
| ByteBuffer | This class is used to hold a raw buffer of bytes, and is also Flattenable and RefCountable |
| ByteBufferDataIO | Data I/O class to allow reading from/writing to a ByteBuffer object (as if it was an I/O device) The ByteBuffer will behave much like a file would (automatically being resized larger when you Write() past the end of it, etc), except of course it's all in memory, not on disk |
| ChildProcessDataIO | This DataIO class is a handy cross-platform way to spawn and talk to a child process |
| CompleteSetupSystem | This class is a global setup/tear-down class; It contains one member variable of each of the other SetupSystem classes, so that when you instantiate one of these objects, all the systems MUSCLE uses get set up |
| CPULoadMeter | This class knows how to measure the total load on the host computer's CPU |
| DataIO | Abstract base class for a byte-stream Data I/O interface, similar to Be's BDataIO |
| DataNode | Each object of this class represents one node in the server-side data-storage tree |
| DebugTimer | This is a little class that can be helpful for debugging |
| DrainTag | This little class is used to help us track when workers' output queues are empty |
| DumbReflectSession | This class represents a single TCP connection between a muscled server and a client program |
| DumbReflectSessionFactory | This is a factory class that returns new DumbReflectSession objects |
| FailoverDataIO | This DataIO holds a list of one or more other DataIO objects, and uses the only first one until an error occurs |
| FileDataIO | Data I/O to and from a stdio FILE |
| FileDescriptorDataIO | Data I/O to and from a file descriptor (useful for talking to Linux device drivers and the like) |
| FilterSessionFactory | This is a convenience decorator factory; it holds a set of "ban patterns", and a set of "require patterns" |
| FlatCountable | This class is used simply to more succinctly designate any object that derives from both Flattenable and RefCountable |
| Flattenable | This class is an interface representing an object that knows how to save itself into an array of bytes, and recover its state from an array of bytes |
| FunctionOutOfMemoryCallback | A handy little class--instead of having to subclass, it will call the function you specify |
| HashFunctor< T > | This hashing functor type handles the "easy" cases, where the KeyType is something that can be static_cast<> into a uint32 by the compiler |
| HashFunctor< const char * > | |
| HashFunctor< const Ref< Item > * > | |
| muscle::HashFunctor< QString > | Enables the use of QStrings as keys in a MUSCLE Hashtable |
| HashFunctor< Ref< Item > > | |
| Hashtable< KeyType, ValueType, HashFunctorType > | This is a handy templated Hashtable class, rather similar to Java's java.util.Hashtable, but with a number of enhancements |
| HashtableIterator< KeyType, ValueType, HashFunctorType > | This class is an iterator object, used for iterating over the set of keys or values in a Hashtable |
| IFailoverNotifyTarget | This class represents any object that can receive a callback notification that a failover has occurred |
| IMemoryAllocationStrategy | This interface is used to represent any object that knows how to allocate, reallocate, and free memory in a special way |
| muscle::IMessageTransceiverMaster | This is an interface that identifies an object that QMessageTransceiverHandlers can attach themselves to |
| IPAddressAndPort | This simple class holds an IP address and a port number, and lets you do useful things on the two such as using them as key values in a hash table, converting them to/from user-readable strings, etc |
| ITraversalPruner | This class is an interface to an object that can prune the traversals used by RestoreNodeTreeFromMessage(), SaveNodeTreeToMessage(), and CloneDataNodeSubtree() so that only a subset of the traversal is done |
| LogCallback | Callback object that can be added with PutLogCallback() Whenever a log message is generated, all added LogCallback objects will have their Log() methods called |
| LogLineCallback | Specialization of LogCallback that parses the Log() calls into nicely formatted lines of text, then calls LogLine() to hand them to your code |
| MathSetupSystem | This SetupSystem handles initializing the system's math routines as necessary |
| MemoryAllocator | Interface class representing an object that can allocate and free blocks of memory |
| Message | This class is similar to a BMessage, but portable |
| MessageFieldNameIterator | This is an iterator that allows you to efficiently iterate over the field names in a Message |
| MessageIOGateway | A "gateway" object that knows how to send/receive Messages over a wire, via a provided DataIO object |
| MessageQueryFilter | This class matches iff the specified sub-Message exists in our target Message, and (optionally) our child QueryFilterRef can match that sub-Message |
| MessageTransceiverThread | This is a class that holds a ReflectServer object in an internal thread, and mediates between it and the calling code |
| MultiDataIO | This DataIO holds a list of one or more other DataIO objects, and passes any calls made to all the sub-DataIOs |
| MultiQueryFilter | A semi-abstract base class for any QueryFilter that holds a list of references to child filters |
| MuscleQueryFilterFactory | This class is MUSCLE's built-in implementation of a QueryFilterFactory |
| Mutex | This class is a platform-independent API for a recursive mutual exclusion semaphore (a.k.a mutex) |
| MutexGuard | This convenience class can be used to automatically lock/unlock a Mutex based on the MutexGuard's ctor/dtor |
| NandNotQueryFilter | This class matches iff at most (n) of its children match |
| NestCount | This class represents a counter of nested function calls |
| NestCountGuard | A trivial little class that simply increments the NestCount in its constructor and decrements the NestCount in its destructor |
| NetworkInterfaceInfo | This little container class is used to return data from the GetNetworkInterfaceInfos() function, below |
| NetworkSetupSystem | This SetupSystem handles initializing the environment's TCP stack |
| NullDataIO | Data I/O equivalent to /dev/null |
| NumericQueryFilter< DataType, DataTypeCode, ClassTypeCode > | This templated class is used to generate a number of numeric-comparison-query classes, all of which are quite similar to each other |
| ObjectPool< Object > | A thread-safe templated object pooling class that helps reduce the number of dynamic allocations and deallocations in your app |
| OutOfMemoryCallback | Interface class representing an object that can be called by an AutoCleanupProxyMemoryAllocator in case of an out-of-memory emergency |
| PacketizedDataIO | This class can be used to "wrap" a streaming I/O object (e.g |
| PacketTunnelIOGateway | This I/O gateway class is a "wrapper" class that you can use in conjunction with any other AbstractMessageIOGateway class |
| PathMatcher | This class is used to do efficient regex-pattern-matching of one or more query strings (e.g |
| PathMatcherEntry | This class represents one entry in a PathMatcher object |
| PlainTextMessageIOGateway | This gateway translates lines of text (separated by "\r", "\n", or "\r\n") into Messages |
| Point | A portable version of Be's BPoint class |
| PolicyHolder | A simple data-holding class; holds an AbstractSessionIOPolicy and a boolean to indicate whether it is using us as an input or not |
| ProxyMemoryAllocator | Convenience class, used for easy subclassing: holds a slave MemoryAllocator and passes all method calls on through to the slave |
| ProxySessionFactory | This is a partially specialized factory that knows how to act as a facade for a "slave" factory |
| PulseNode | Interface class for any object that can schedule Pulse() calls for itself via its PulseNodeManager |
| PulseNodeManager | Subclasses of this class are allowed to manage PulseNode objects by calling their GetPulseTimeAux() and PulseAux() methods (indirectly) |
| muscle::QAcceptSocketsThread | This is a Qt-specific subclass of AcceptSocketsThread |
| muscle::QMessageTransceiverHandler | This class can be used in conjunction with the QMessageTransceiverThread class to make it easier to manage multiple sessions inside a single I/O thread |
| muscle::QMessageTransceiverThread | This is a Qt-specific subclass of MessageTransceiverThread |
| muscle::QMessageTransceiverThreadPool | This class represents a demand-allocated pool of QMessageTransceiverThread objects |
| QSocketDataIO | This class was contributed to the MUSCLE archive by Jonathon Padfield (jpadfield@hotkey.net.au) |
| QueryFilter | Interface for any object that can examine a Message and tell whether it matches some criterion |
| QueryFilterFactory | Interface for any object that knows how to instantiate QueryFilter objects |
| Queue< ItemType > | This class implements a templated double-ended queue data structure |
| QueueGatewayMessageReceiver | Handy utility class for programs that don't want to define their own custom subclass just to gather incoming Messages a gateway -- this receiver just adds the received Messages to the tail of the Queue, which your code can then pick up later on at its leisure |
| RateLimitSessionIOPolicy | This policy allows you to enforce an aggregate maximum bandwidth usage for the set of AbstractReflectSessionSessions that use it |
| RawDataMessageIOGateway | This gateway is very crude; it can be used to write raw data to a TCP socket, and to retrieve data from the socket in chunks of a specified size range |
| RawDataQueryFilter | This class matches on raw data buffers |
| Rect | A portable version of Be's BRect class |
| Ref< Item > | This is a ref-count token object that works with any instantiation type that is a subclass of RefCountable |
| RefCountable | This class represents objects that can be reference-counted using the Ref class |
| ReflectServer | This class represents a MUSCLE server: It runs on a centrally located machine, and many clients may connect to it simultaneously |
| ReflectSessionFactory | This is an interface for an object that knows how to create new AbstractReflectSession objects when needed |
| RS232DataIO | A serial port DataIO for serial communications |
| SanitySetupSystem | This SetupSystem just does some basic sanity checks to ensure that the code was compiled in a way that has some chance of working (e.g |
| SDLMessageTransceiverThread | This class is useful for interfacing a MessageTransceiverThread to the SDL event loop |
| ServerComponent | This class represents any object that can be added to a ReflectServer object in one way or another, to help define the ReflectServer's behaviour |
| SetupSystem | SetupSystem is the base class for an object that sets up the environment to handle the sort of things we'll be wanting to do |
| SharedFilterSessionFactory | This is a convenience decorator factory; whenever it is asked to create a session, it will open the shared-memory area with the specified name (using the MUSCLE SharedMemory class) and look in that area for IP addresses |
| SharedMemory | This class is a simple platform-independent API wrapper around the native OS's shared-memory facilities |
| SharedUsageLimitProxyMemoryAllocator | This MemoryAllocator decorates its slave MemoryAllocator to enforce a user-defined per-process-group limit on how much memory may be allocated at any given time |
| SignalMessageIOGateway | This gateway is simple almost to the point of being crippled |
| Socket | A simple socket-holder class to make sure that socket fd's added to Messages get properly closed and not leaked if said Messages never get processed |
| SocketRef | SocketRef is subclassed rather than typedef'd so that I can override the == and != operators to check for equality based on the file descriptor value rather than on the address of the referenced Socket object |
| SSLSocketDataIO | |
| StdinDataIO | This DataIO handles I/O to and from the STDIN_FILENO file descriptor |
| StorageReflectSession | An intelligent AbstractReflectSession that knows how to store data on the server, and filter using wildcards |
| StorageReflectSession::NodePathMatcher | A slightly extended version of PathMatcher that knows how to handle DataNodes directly |
| StorageReflectSessionFactory | This is a factory class that returns new StorageReflectSession objects |
| String | A character string class |
| StringMatcher | A utility class for doing globbing or regular expression matching |
| StringMatcherQueue | Just a reference-countable list of references to StringMatcher objects |
| StringQueryFilter | This class matches on string field values |
| StringTokenizer | String tokenizer class, similar to Java's java.util.StringTokenizer |
| TCPSocketDataIO | Data I/O to and from a TCP socket! |
| Thread | This class is an platform-independent class that creates an internally held thread and executes it |
| ThreadSetupSystem | This SetupSystem handles initializing the environment's threading mechanisms |
| ThreadSupervisorSession | This is the session that acts as the main thread's agent inside the MessageTransceiverThread's held ReflectServer object |
| ThreadWorkerSession | This is a session that represents a connection to another computer or etc |
| ThreadWorkerSessionFactory | A factory class that returns new ThreadWorkerSession objects |
| Tuple< NumItems, ItemType > | Templated base class representing a fixed-size set of numeric values that can be operated on in parallel |
| UDPSocketDataIO | Data I/O to and from a UDP socket! |
| UsageLimitProxyMemoryAllocator | This MemoryAllocator decorates its slave MemoryAllocator to enforce a user-defined per-process limit on how much memory may be allocated at any given time |
| ValueExistsQueryFilter | This filter merely checks to see if the specified value exists in the target Message |
| ValueQueryFilter | Semi-abstract base class for all query filters that test a single item in a Message |
| WhatCodeQueryFilter | This filter tests the 'what' value of the Message |
| Win32FileHandleDataIO | Data I/O to and from a Win32 style file descriptor |
| Win32MessageTransceiverThread | This is a Win32-API-specific subclass of MessageTransceiverThread |
| XorDataIO | This DataIO is a "wrapper" DataIO that adds an XOR operation to any data that it reads or writes before passing the call on to the DataIO that it holds internally |
| XorQueryFilter | This class matches only if an odd number of its children match |
