"Fossies" - the Fresh Open Source Software Archive
Member "muscle/README.html" (21 Nov 2020, 32642 Bytes) of package /linux/privat/muscle7.62.zip:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) HTML source code syntax highlighting (style: standard
) with prefixed line numbers.
Alternatively you can here view
the uninterpreted source code file.
See also the latest Fossies "Diffs"
side-by-side code changes report for "README.html": 7.61_vs_7.62
1 <HTML><HEAD><TITLE>MUSCLE: (Multi User Server Client Linking Environment)</TITLE></HEAD><BODY BGCOLOR=#ffffff>
4 MUSCLE: Crossbar Server, Portable Messaging and Support Classes<p>
5 11/20/2020 v7.62 email@example.com<p>
6 Jeremy Friesner / Meyer Sound Laboratories Inc.<p>
7 Win32 compatibility contributions by Vitaliy Mikitchenko<p>
8 C# client code by Wilson Yeung<p>
9 SSL support code contributed by Nathan Whitehorn
12 Note: To compile the server, cd to the "server" subdirectory
13 and type 'make'. The server executable, "muscled", should be
14 generated. You can run this server from the command line, (type
15 "muscled help" to get info about some options) and connect to it
16 with any MUSCLE-aware program.
18 Alternatively, if you prefer a server that runs as a GUI program
19 and you have Qt installed, you can cd to the "qtsupport/qt_muscled"
20 subdirectory and type "qmake; make". A GUI server program named
21 qt_muscled will be created.
23 The main goal of these classes is to provide an easy way to use
24 BMessage-style message passing across a network of heterogeneous
25 (MacOS/X, Linux, Windows, BSD, Unix, etc) systems. The secondary goal
26 is just to provide some handy data containers and other utility classes.
28 All of this code (except the atheossupport, besupport, and qtsupport
29 directories) should compile under any up-to-date C++ compiler--
30 no proprietary APIs are used except inside of the appropriate #ifdefs.
32 For better documentation than this, please see the <a href="https://public.msli.com/lcs/muscle/">MUSCLE web site</a>.
34 This code has been compiled (typically with gmake, or MSVC in Windows) and tested in the following environments:
37 <li>SUSE, Debian, and Ubuntu Linux on various 32-bit and 64-bit PCs</li>
38 <li>MacOS/X on various PowerPC and Intel based Macs</li>
39 <li>Microsoft Windows XP, Windows 7 and Windows 10 using Visual Studio 2008 or newer (use the projects files in the 'vc++' subfolder)</li>
42 It has no known bugs, but may have some yet-to-be-discovered ones.
43 Use at your own risk, Meyer Sound is not responsible for any disasters, blah blah blah.
45 Directory contents descriptions follow:
50 This directory contains Wilson Yeung's alpha port of the Muscle client
51 API to the C# language. Email Wilson (firstname.lastname@example.org) with questions
52 about this port.
58 This directory contains the DataIO interface class, which is an abstraction
59 for any file-like device that can read or write sequences of bytes, and
60 (optionally) seek to a specified position. The DataIO class defines an
61 interface for devices that you can Read() bytes from or Write() bytes to.
62 This folder also includes some useful implementations of the DataIO interface,
63 including the following:
66 <tr><td>AsyncDataIO</td><td>Wrapper that delegates I/O calls to an internal I/O thread</td></tr>
67 <tr><td>ByteBufferDataIO</td><td>For file-style reading/writing to a ByteBuffer held in memory</td></tr>
68 <tr><td>ChildProcessDataIO</td><td>For launching a child process and communicating with it via its stdout/stdin</td></tr>
69 <tr><td>FailoverDataIO.</td><td>Wrapper for automatic fallback to a second output when a primary output fails</td></tr>
70 <tr><td>FileDataIO</td><td>For reading/writing via a C (FILE *) file handle</td></tr>
71 <tr><td>FileDescriptorDataIO</td><td>For reading/writing via a Unix file descriptor</td></tr>
72 <tr><td>MultiDataIO</td><td>Multiplexer wrapper class for writing to multiple outputs at once</td></tr>
73 <tr><td>NullDataIO</td><td>Dummy class for directing data to the bit-bucket</td></tr>
74 <tr><td>PacketizedProxyDataIO</td><td>Wrapper for making TCP act more like "reliable UDP"</td></tr>
75 <tr><td>RS232DataIO</td><td>For communicating via an RS-232 serial port</td></tr>
76 <tr><td>SSLSocketDataIO</td><td>For communicating over SSL over TCP</td></tr>
77 <tr><td>SimulatedMulticastDataIO</td><td>For Wi-Fi; simulates multicast semantics using mostly unicast packets</td></tr>
78 <tr><td>StdinDataIO</td><td>For reading from stdin</td></tr>
79 <tr><td>TCPSocketDataIO</td><td>For communicating using a TCP socket</td></tr>
80 <tr><td>UDPSocketDataIO</td><td>For communicating using a UDP socket</td></tr>
81 <tr><td>XorDataIO</td><td>Wrapper class that applies XOR-"encryption" to all data that flows through it</td></tr>
88 This directory contains the MUSCLE client API written for the Delphi
89 programming environment. The contents of this directory were contributed
90 by Matthew Emson; see the Readme.txt file in this directory for more information.
96 This directory contains various HTML documentation for the MUSCLE project,
97 including the Beginner's Guide to MUSCLE, a document on how to create
98 custom MUSCLE servers, a directory of simple toy example programs,
99 and the autodoc folder that contains files useful for creating API
100 documentation using the DOxygen documentation tool.
106 This directory contains the AbstractMessageIOGateway interface.
107 An AbstractMessageIOGatweay is a "gateway" object that knows
108 how to manage bidirectional FIFO Message-stream traffic going to and
109 coming from a DataIO object. A gateway object queues outgoing MessageRefs,
110 and when there is room in the outgoing buffer to send one, it flattens the
111 next MessageRef in the outgoing-message-queue into a sequence of bytes,
112 and sends those bytes out via the DataIO object. It also reads bytes
113 coming in from the DataIO object and assembles those bytes back into
114 Message objects, which are then handed back to the AbstractGatewayMessageReceiver
115 specified by the calling code.
117 This directory also contains some useful implementations of the
118 AbstractMessageIOGateway interfaces, which are as follows:
121 <tr><td>MessageIOGateway</td><td>Flattens Messages to the standard MUSCLE flattened-message binary format</td></tr>
122 <tr><td>PacketTunnelIOGateway</td><td>Flattens Messages into a series of fixed-size packets suitable for UDP transmission</td></tr>
123 <tr><td>PlainTextMessageIOGateway</td><td>Converts free-form lines of ASCII text into Messages, and vice versa</td></tr>
124 <tr><td>RawDataMessageIOGateway</td><td>Converts arbitrary raw data into Messages, and vice versa</td></tr>
125 <tr><td>SLIPFramedDataMessageIOGateway</td><td>Similar to the RawDataMessageIOGateway class, except it uses SLIP framing conventions</td></tr>
126 <tr><td>SSLSocketAdapterGateway</td><td>An adapter class to provide transparent support for OpenSSL's particular I/O needs</td></tr>
127 <tr><td>SignalMessageIOGateway</td><td>Dummy gateway that doesn't send actual data, only indicates when data is available</td></tr>
135 This directory contains a Java implementation of the MUSCLE client side
136 API. You can use the code in this folder to enable your Java program
137 to talk to a MUSCLE server or any other program that speaks the MUSCLE
138 Message protocol.
144 This directory contains MUSCLE's Message class. A Message is a general-purpose
145 data structure that is similar to BeOS's BMessage class. A Message consists
146 of a 32-bit integer "what code", plus zero or more named data fields, each of
147 which can contain one or more data items of a specified type.
149 Here are some relevant details:
153 MUSCLE messages support the following field types:
157 <tr><td>int8</td><td>B_INT8_TYPE</td><td>8-bit signed integer values</td></tr>
158 <tr><td>int16</td><td>B_INT16_TYPE</td><td>16-bit signed integer values</td></tr>
159 <tr><td>int32</td><td>B_INT32_TYPE</td><td>32-bit signed integer values</td></tr>
160 <tr><td>int64</td><td>B_INT64_TYPE</td><td>64-bit signed integer values</td></tr>
161 <tr><td>bool</td><td>B_BOOL_TYPE</td><td>boolean values</td></tr>
162 <tr><td>float</td><td>B_FLOAT_TYPE</td><td>IEEE 754 floating point values</td></tr>
163 <tr><td>Pointer</td><td>B_POINTER_TYPE</td><td>Pointer values (non-flattenable)</td></tr>
164 <tr><td>Message</td><td>B_MESSAGE_TYPE</td><td>Message objects</td></tr>
165 <tr><td>Flattenable</td><td>(various types)</td><td>Flattened Flattenable objects</td></tr>
166 <tr><td>String</td><td>B_STRING_TYPE</td><td>UTF8 character strings</td></tr>
167 <tr><td>Rect</td><td>B_RECT_TYPE</td><td>Rectangles (floats for left,top,right,bottom)</td></tr>
168 <tr><td>Point</td><td>B_POINT_TYPE</td><td>Points (floats for x,y)</td></tr>
169 <tr><td>Raw Data Buffer</td><td>B_RAW_TYPE</td><td>Sequences of zero or more untyped bytes<td></tr>
170 <tr><td>Tag</td><td>B_TAG_TYPE</td><td>User-provided arbitrary objects (non-flattenable)</td></tr>
174 Message is a subclass of Flattenable (see below), and therefore a Message can be serialized
175 into a "flattened" buffer-of-bytes, which can be sent across a network or saved to a file,
176 and later the bytes can be unflattened back into an equivalent Message object. This is the
177 basis for most MUSCLE network communication. The flattening and unflattening is endian-aware,
178 so that e.g. a PowerPC machine can communicate with an Intel machine without problems.
181 Message has a GetFieldNameIterator() method, which returns
182 a MessageFieldNameIterator object, which can be used to
183 iterate over the fields of a Message.
191 This directory contains the MiniMessage and MiniMessageGateway C APIs.
192 These APIs are C implementations of the C++ Message and MessageIOGateway classes.
193 They can be used in cases where (for whatever reason) you want to code your
194 program in C only and avoid C++. They aren't as easy-to-use as the C++ implementation,
195 but they should be sufficient for simple things, and they compile down to only
196 a few dozen kilobytes of object code. See the testmini.c and minireflectclient.c
197 test files in the tests directory for examples on how they are used.
203 This directory contains the MicroMessage and MicroMessageGateway C APIs.
204 These APIs are C implementations of the C++ Message and MessageIOGateway classes.
205 These APIs go even farther towards minimalism than the minimessage APIs: in
206 particular, these APIs never allocate or free any data. Instead of converting
207 the message's flattened-data-bytes into a separate in-memory data structure like
208 Message and MiniMessage do, MicroMessage operates on the flattened-data-bytes directly.
209 This makes for a potentially much more efficient implementation; the main downside
210 is that when creating a MicroMessage, you can only append data; you cannot insert
211 or remove fields that you previously added.
217 This directory contains a minimal MUSCLE client-side API written in Python2.
218 You can use the code in this directory to enable your Python scripts to talk
219 to a MUSCLE server or any other program that speaks the MUSCLE Message protocol.
220 Also included in this directory is some C++ glue code (in PythonUtilityFunctions.cpp)
221 that is useful when embedding Python code into C++ code -- the glue code uses MUSCLE
222 Messages as to transfer arguments from C++ to Python context and back again.
228 This directory contains a minimal MUSCLE client-side API written in Python3.
229 You can use the code in this directory to enable your Python3 scripts to talk
230 to a MUSCLE server or any other program that speaks the MUSCLE Message protocol.
237 This directory contains several classes that support clients that use TrollTech's
238 Qt cross-platform GUI API. The main one is the QMessageTransceiverThread class,
239 which is a Qt-aware subclass of the MessageTransceiverThread class.
241 Using a QMessageTransceiverThread for your network I/O makes network communication
242 very simple; instead of dealing with bytes and network protocols, you simply
243 receive a Qt signal whenever incoming Messages are available, and call a method to
244 send a Message, etc.
246 This folder also contains some sub-directories that contain small example
247 programs written for MUSCLE+Qt:
250 <tr><td>qt_example</td><td>A simple multi-user 'game' and chat program</td></tr>
251 <tr><td>qt_advanced_example</td><td>A demonstration of embedding a MUSCLE server thread inside a Qt application</td></tr>
252 <tr><td>qt_muscled</td><td>A demonstration of a Qt app that runs a MUSCLE server as a child process</td></tr>
253 <tr><td>qt_muscled_browser</td><td>A hierarchical browser GUI for seeing what data is present in a muscle server's database</td></tr>
260 This directory contains server code for an n-way
261 "message crossbar server" program. This program will listen
262 on a specified port for TCP connections, and will allow the
263 TCP connections to "talk to each other" by forwarding Messages from
264 one client to another (or to multiple others).
265 The ServerProcessLoop() method implements the server's event loop,
266 while the AbstractReflectSession class is the interface for the server's side
267 of a TCP connection. There are currently two subclasses of
268 AbstractReflectSession included: the DumbReflectSession
269 class just reflects all received Messages to all connected clients, while
270 the StorageReflectSession class adds nice features like wildcard-based
271 Message routing, server-side data storage, and "notify-me-on-change"
272 subscription services. (See the MUSCLE Beginner's Guide for more info on this)
273 More elaborate logic can be added by creating subclasses of these classes.
279 This directory contains code to support the use of regular expressions.
280 This includes some C++ pattern-matching utility classes, as well as a
281 sub-folder containing Henry Spencer's freeware C regex engine, for use
282 in OS's that do not provide their own regex library.
284 Classes implemented in this directory include:
287 <tr><td>FilePathExpander</td><td>Expands shell-style wildcards into a list of file paths</td></tr>
288 <tr><td>PathMatcher</td><td>Controls wildcard-directed recursive iterations down the tree of DataNode objects</td></tr>
289 <tr><td>QueryFilter</td><td>Implements various predicate-logic operations on DataNode Message data</td></tr>
290 <tr><td>StringMatcher</td><td>Does shell-style pattern matching on arbitrary character strings</td></tr>
291 <tr><td>SegmentedStringMatcher</td><td>Like StringMatcher, except that the strings are divided up into substrings which are evaluated separately (e.g. "a*/b*")</td></tr>
298 This directory contains the SDLMessageTransceiverThread class, which is
299 a handy way to implement MUSCLE communication ability into your SDL program.
300 SDLMessageTransceiverThread class is just a thin wrapper subclass around
301 the MessageTransceiverThread class, but it interfaces MessageTransceiverThread
302 to SDL's event-notification system.
308 This contains the Makefile and main entry point for the "muscled"
309 server executable, and the "admin" muscled-server-administration utility.
315 This directory contains various "small things" needed to compile the
316 rest of the code. These include byte-ordering macros, BeOS-style type
317 codes, typedefs, and result constants, and the Flattenable
318 interface definition.
324 This directory contains functions for logging event messages to stdout
325 and/or to a file. Log messages can be "raw" (works just like printf)
326 or nicely formatted with the current time, redirected to a file, and so
327 on. The logging system also has optional functionality to rotate, compress
328 and/or delete old log files, to avoid filling up too much disk space.
334 This directory contains classes that represent "generic" interfaces
335 to OS-specific APIs; as such, they are not guaranteed to work on
336 every platform. Currently this directory contains the following classes:
340 <tr><td>AcceptSocketsThread</td><td>A thread that accepts incoming TCP connections and hands them back to the parent thread</td</tr>
341 <tr><td>AtomicCounter</td><td>Atomic-increment and atomic-decrement counter, for lock-free reference-counting</td</tr>
342 <tr><td>DetectNetworkConfigChangesSession</td><td>A session object that notifies the program when the host computer's network configuration has changed</td</tr>
343 <tr><td>GlobalMemoryAllocator</td><td>Code to monitor and optionally restrict the program's heap usage</td</tr>
344 <tr><td>MessageTransceiverThread</td><td>Runs a MUSCLE ReflectServer object in a separate thread. Provides asynchronous I/O</td</tr>
345 <tr><td>Mutex</td><td>Provides efficient in-process locking (aka critical sections) for thread-safety</td</tr>
346 <tr><td>SetupSystem</td><td>Provides standardized startup and shutdown routines that must be used by any MUSCLE process</td</tr>
347 <tr><td>SharedMemory</td><td>Implements inter-process shared memory regions, including inter-process read/write locking ability</td</tr>
348 <tr><td>SignalMultiplexer</td><td>Makes system signalling (e.g. catching of SIGINT or SIHUP) available to multiple pieces of code in the same process</td</tr>
349 <tr><td>SystemInfo</td><td>Provides information about the environment the program is operating in (current directory, OS version, etc)</td</tr>
350 <tr><td>Thread</td><td>An OS-neutral Thread class for multithreading purposes. Includes send/receive Message functionality for easy control</td</tr>
351 <tr><td>ThreadLocalStorage</td><td>An OS-neutral implementation of thread-local data storage</td</tr>
352 <tr><td>ThreadPool</td><td>A thread pool implementation to allow handling of many Messages in parallel across a finite number of threads.</td</tr>
359 This directory contains various test programs that I use
360 to test and develop the code, and a Makefile to build them with.
362 Currently this directory contains the following programs:
365 <tr><td>bandwidthtester</td><td>Generates lots of Message traffic and measures how fast a MUSCLE server can receive it</td></tr>
366 <tr><td>calctypecode</td><td>Prints out the decimal equivalent of a four-character ASCII what-code</td></tr>
367 <tr><td>printtypecode</td><td>Prints out the four-character ASCII equivalent of a given decimal value</td></tr>
368 <tr><td>chatclient</td><td>Minimalist BeShare-compatible chat client that can connect to any MUSCLE server</td></tr>
369 <tr><td>deadlock</td><td>Deliberately tries to create a deadlock. Primarily used for testing deadlockfinder.</td></tr>
370 <tr><td>deadlockfinder</td><td>Parses the output generated by MUSCLE's MUSCLE_ENABLE_DEADLOCK_FINDER feature, and detects potential deadlock issues</td></tr>
371 <tr><td>findsourcelocations</td><td>Parses source code and lists source-locations matching a specified code generated by MUSCLE's MUSCLE_INCLUDE_SOURCE_CODE_LOCATION_IN_LOGTIME feature</td></tr>
372 <tr><td>hexterm</td><td>A simple interactive terminal that sends, receives, and prints hexadecimal representation of all bytes received via TCP, UDP, etc.</td></tr>
373 <tr><td>portableplaintextclient</td><td>A simple interactive terminal for ASCII communication over TCP</td></tr>
374 <tr><td>portablereflectclient</td><td>A simple interactive terminal for Message communication over TCP (typically with a MUSCLE server)</td></tr>
375 <tr><td>portscan</td><td>Attempts to connect via TCP to a range of ports on a host, and reports which ports accepted the connection</td></tr>
376 <tr><td>printsourcelocations</td><td>Prints the source-code-location codes of all LogTime() commands. Useful for building up a directory of source-location-codes for a given codebase</td></tr>
377 <tr><td>readmessage</td><td>Reads a flattened Message from a file on disk and prints it to stdout in human-readable form</td></tr>
378 <tr><td>serialproxy</td><td>Makes a local serial port available to the network over TCP</td></tr>
379 <tr><td>svncopy</td><td>Creates a command script for bulk-adding specified files to an SVN repository</td></tr>
380 <tr><td>testatheossupport</td><td>Tests the AtheOS support files in the atheossupport folder</td></tr>
381 <tr><td>testbatchguard</td><td>Unit test for the BatchGuard class</td></tr>
382 <tr><td>testbesupport</td><td>Tests the BeOS support files in the beossupport folder</td></tr>
383 <tr><td>testbytebuffer</td><td>Unit test for the ByteBuffer class</td></tr>
384 <tr><td>testchildprocess</td><td>Unit test for the ChildProcessDataIO class</td></tr>
385 <tr><td>testendian</td><td>Unit test for the endian-swapping routines</td></tr>
386 <tr><td>testfilepathinfo</td><td>Unit test for the FilePathInfo class</td></tr>
387 <tr><td>testgateway</td><td>Unit test for the MessageIOGateway class</td></tr>
388 <tr><td>testhashtable</td><td>Unit test for the Hashtable class</td></tr>
389 <tr><td>testmatchfiles</td><td>Unit test for the ExpandFilePathWildCards() function</td></tr>
390 <tr><td>testmessage</td><td>Unit test for the Message class</td></tr>
391 <tr><td>testmicro</td><td>Unit test for the MicroMessage and MicroMessageGateway C routines</td></tr>
392 <tr><td>testmini</td><td>Unit test for the MiniMessage and MiniMessageGateway C routines</td></tr>
393 <tr><td>testnagle</td><td>Unit test to verify the presence of absence of Nagle's algorithm</td></tr>
394 <tr><td>testnetconfigdetect</td><td>Unit test for the DetectNetworkConfigChangesSession class</td></tr>
395 <tr><td>testnetutil</td><td>Unit test for the GetNetworkInterfaces() function</td></tr>
396 <tr><td>testpacketio</td><td>Unit test for the PacketizedDataIO clas</td></tr>
397 <tr><td>testpackettunnel</td><td>Unit test for the PacketTunnelIOGateway class</td></tr>
398 <tr><td>testparsefile</td><td>Unit test for the ParseFile() and ParseArgs() functions</td></tr>
399 <tr><td>testpool</td><td>Unit test for the ObjectPool class</td></tr>
400 <tr><td>testpulsenode</td><td>Unit test for the PulseNode class</td></tr>
401 <tr><td>testqueryfilter</td><td>Unit test for the QueryFilter classes</td></tr>
402 <tr><td>testqueue</td><td>Unit test for the Queue class</td></tr>
403 <tr><td>testrefcount</td><td>Unit test for the RefCount class</td></tr>
404 <tr><td>testreflectclient</td><td>Unit test for the various OS-specific MessageTransceiverThread subclasses</td></tr>
405 <tr><td>testregex</td><td>Unit test for the StringMatcher class</td></tr>
406 <tr><td>testresponse</td><td>Test to measure the response latency of a muscle server</td></tr>
407 <tr><td>testserial</td><td>Unit test for the RS232DataIO class</td></tr>
408 <tr><td>testsharedmem</td><td>Unit test for the SharedMemory class</td></tr>
409 <tr><td>testsocketmultiplexer</td><td>Unit test for the SocketMultiplexer class</td></tr>
410 <tr><td>teststring</td><td>Unit test for the String class</td></tr>
411 <tr><td>testsysteminfo</td><td>Unit test for the SystemInfo functionality</td></tr>
412 <tr><td>testthread</td><td>Unit test for the Thread class</td></tr>
413 <tr><td>testthreadpool</td><td>Unit test for the ThreadPool class</td></tr>
414 <tr><td>testtime</td><td>Unit test for the various time-string-parsing and time-string-generation functions</td></tr>
415 <tr><td>testtuple</td><td>Unit test for the Tuple class</td></tr>
416 <tr><td>testtypedefs</td><td>Unit test for MUSCLE's standard type typedefs (int32, int64, etc)</td></tr>
417 <tr><td>testudp</td><td>Test/demonstration of using MUSCLE to send/receive UDP packets</td></tr>
418 <tr><td>testzip</td><td>Unit test of the ReadZipFile() and WriteZipFile() functions</td></tr>
419 <tr><td>udpproxy</td><td>Forwards UDP packets from one computer to another, and vice versa</td></tr>
420 <tr><td>uploadstress</td><td>Spams a MUSCLE server with requests to see if the server can keep up</td></tr>
421 <tr><td>win32client</td><td>Example of integrating MUSCLE client code with a Win32 event loop</td></tr>
433 This directory contains many useful one-off classes and function
434 collections, including:
439 BatchOperator is a templated mechanism for ensuring that a specified
440 method gets called on the first-level recursion into a call tree, and
441 that a matching method gets called on the final recursion out of the call tree.
442 This is handy for making sure that setup and shutdown code is called exactly
443 once at the beginning and once at the end of a set of nested recursive function calls.
447 ByteBuffer is an intelligent byte-array class, that stores
448 its length, knows how to resize itself efficiently, is
449 reference-countable and flattenable, etc.
455 CountedObject is a class that other classes can be derived from
456 if you want to keep track of how many instances of them are in
457 memory at any given time.
463 CPULoadMeter reports the percentage of CPU time being used on
464 the local computer from moment to moment (similar to what is
465 reported in Task Manager under Windows, or Activity Monitor
466 under MacOS/X)
472 Directory is a platform-neutral API for scanning a filesystem
473 directory and iterating over its contents.
479 DebugTimer is a useful utility class that is useful for debugging
480 performance problems. It records the current time in its
481 constructor, and then in its destructor it prints out the
482 time that has elapsed since then (if the elapsed time is more
483 than a specified minimum time).
489 FilePathInfo is a platform-neutral API for querying the various
490 properties of an entry at a specified location in a file system
491 (e.g. is a file, a directory, or a symlink, how large is it,
492 when was it created or modified, etc)
498 Hashtable is a handy hash table class, with templated
499 key and value types and the traditional O(1) lookup time.
500 In addition to that, it includes other nice features, such
501 as "safe" iterators (so you can modify the Hashtable while
502 iterating through it), minimal-frequency memory allocations,
503 and the ability to sort the table by key or by value (it
504 maintains the ordering of the objects placed into the table).
505 Hashtable is used by the Message class, but is also quite
506 useful on its own.
512 IPAddress is a class that represents an IPv4 or IPv6
513 address in a standardized manner. There is also an
514 IPAddressAndPort class which represents the combination
515 of an IP address and a port number.
521 NestCount is a simple class for recording when the execution
522 path enters or exits a particular function, and (optionally)
523 making decisions based on whether a specified function is currently
524 on the stack or not.
530 MiscUtilityFunctions.cpp is a catch-all for various useful functions
531 that didn't fit anywhere else.
537 NetworkUtilityFunctions.cpp is a repository of user-friendly
538 wrapper functions around common BSD socket operations, such as setting
539 up sockets to connect or accept TCP connections, or binding a UDP socket
540 to a port.
546 The ObjectPool class is used to avoid excessive deletions and allocations
547 of commonly used objects (such as Messages or RefCountMems).
548 It works by recycling the items for re-use, and is templated so it can be
549 used for any type of object.
555 The PulseNode is an interface for objects that want to execute a particular
556 action at a specified time. It works in conjunction with the standard MUSCLE
557 event loop. Implementing classes define a Pulse() method that will be executed
558 at a specified time, and a GetPulseTime() method that returns a clock value
559 indicating when Pulse() should next be executed.
565 The Queue class is just a little templatized double-ended
566 queue (i.e. AddHead(), AddTail(), RemoveHead(), and RemoveTail()
567 are O(1) operations). It can be used as a Vector, Stack, or FIFO.
568 It's templatized for easy, type-safe reuse.
574 The RefCount class implements generic reference counting for C++
575 objects or arrays. To enable reference counting on an object, you
576 simply create a single Ref for that object, and (optionally)
577 make one or more copies of the Ref via the copy constructor
578 or the equals operator. Then, when the last Ref object
579 disappears, the C++ object or array is automatically deleted. It's
580 not a garbage collector, but it beats having to keep track of all your
581 allocations by hand...
587 A reference-countable C++ class wrapper for a socket or file descriptor.
588 Wrapping sockets and file descriptors in these objects allows them to
589 be easily shared across objects without introducing the possibility of
590 leaking them, or closing them before some other piece of code is done
591 using them.
597 An easy-to-use wrapper around the select() socket-multiplexing API.
598 It's also possible to use this as a wrapper around various select()
599 alternatives, such as poll(), epoll(), or kqueue(), by recompiling
600 the code with the appropriate compiler flags (e.g. -DMUSCLE_USE_POLL)
606 The String class is just your basic character-string class,
607 in this case inspired by the java.lang.String class from Java.
608 This class was originally written by Michael Olivero (email@example.com)
609 and modified by myself. String extends Flattenable,
610 so it can be serialized in a generic manner.
616 A string tokenizing class similar to Java's Java.util.StringTokenizer,
617 only more efficient.
623 TimeUtilityFunctions.h is a repository of functions for dealing with
624 microsecond-accurate timing issues.
632 This directory contains project files for building muscled under Visual C++
633 for Windows. These files were provided by Vitaliy Mikitchenko (aka VitViper)
639 This directory contains the Win32MessageTransceiverThread class, which is
640 useful for interface MUSCLE code to the standard Win32 GUI event loop.
641 You can use this class to enable your Win32 C and C++ programs to communicate
642 with a MUSCLE server or any other program that speaks the MUSCLE Message
649 This directory contains a subfolder named zlib (which contains the complete
650 source code of the zlib compressor/decompressor package). This directory
651 also contains some zlib-related muscle source, including ZLibCodec, which is a
652 convenience class for compressing and decompressing chunks of data, ZLibDataIO,
653 a wrapper class for transparent compression and decompression of I/O streams,
654 and ZLibUtilityFunctions, which contain some convenience functions for quickly
655 compressing and decompressing a Message in a compatible manner.
660 For more details, have a look at the <a href="https://public.msli.com/lcs/muscle/html/hierarchy.html">autodocs</a>, header files and/or the source itself.