"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 or download 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>
    2 
    3 <H2>
    4 MUSCLE:  Crossbar Server, Portable Messaging and Support Classes<p>
    5 11/20/2020 v7.62 jaf@meyersound.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
   10 </H2>
   11 <p>
   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. 
   17 <p>
   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.
   22 <p>
   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.  
   27 <p>
   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.
   31 <p>
   32 For better documentation than this, please see the <a href="https://public.msli.com/lcs/muscle/">MUSCLE web site</a>.
   33 <p>
   34 This code has been compiled (typically with gmake, or MSVC in Windows) and tested in the following environments:
   35 <p>
   36 <ol>
   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>
   40 </ol>
   41 <p>
   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.
   44 <p>
   45 Directory contents descriptions follow:
   46 <p>
   47 <ol>
   48 <b>csharp/</b>
   49 <p>
   50    This directory contains Wilson Yeung's alpha port of the Muscle client
   51    API to the C# language.  Email Wilson (wilson@whack.org) with questions
   52    about this port.
   53 <p>
   54 </li>
   55 <li>
   56 <b>dataio/</b>
   57 <p>
   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:
   64    <p> 
   65    <table>
   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>
   82    </table>
   83 <p>
   84 </li>
   85 <li>
   86 <b>delphi/</b>
   87 <p>
   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.
   91 <p>
   92 </li>
   93 <li>
   94 <b>html/</b>
   95 <p>
   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.
  101 <p>
  102 </li>
  103 <li>
  104 <b>iogateway/</b>
  105 <p>
  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.
  116 
  117    This directory also contains some useful implementations of the  
  118    AbstractMessageIOGateway interfaces, which are as follows:
  119    <p> 
  120    <table>
  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>
  128    </table>
  129 
  130 <p>
  131 </li>
  132 <li>
  133 <b>java/</b>
  134 <p>
  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.
  139 <p>
  140 </li>
  141 <li>
  142 <b>message/</b>
  143 <p>
  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.
  148 <p>
  149    Here are some relevant details:
  150 <p>
  151 <ol>
  152 <li>
  153     MUSCLE messages support the following field types:
  154 
  155 <p>
  156 <table>
  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>
  171 </table>
  172 <p>
  173 <li>
  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.
  179 </li>
  180 <li>
  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.
  184 </li>
  185 </ol>
  186 </li>
  187 <p>
  188 <li>
  189 <b>minimessage/</b>
  190 <p>
  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.
  198 <p>
  199 </li>
  200 <li>
  201 <b>micromessage/</b>
  202 <p>
  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.
  212 <p>
  213 </li>
  214 <li>
  215 <b>python/</b>
  216 <p>
  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.
  223 <p>
  224 </li>
  225 <li>
  226 <b>python3/</b>
  227 <p>
  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.
  231 <p>
  232 </li>
  233 <p>
  234 <li>
  235 <b>qtsupport/</b>
  236 <p>
  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.  
  240 
  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.
  245 
  246    This folder also contains some sub-directories that contain small example
  247    programs written for MUSCLE+Qt:
  248    <p>
  249    <table>
  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>
  254    </table>
  255 <p>
  256 </li>
  257 <li>
  258 <b>reflector/</b>
  259 <p> 
  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.
  274 <p>
  275 </li>
  276 <li>
  277 <b>regex/</b>
  278 <p> 
  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.
  283 <p>
  284    Classes implemented in this directory include:
  285    <p>
  286    <table>
  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>
  292    </table>
  293 <p>
  294 </li>
  295 <li>
  296 <b>sdlsupport/</b>
  297 <p> 
  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.
  303 <p>
  304 </li>
  305 <li>
  306 <b>server/</b>
  307 <p>
  308    This contains the Makefile and main entry point for the "muscled"
  309    server executable, and the "admin" muscled-server-administration utility.
  310 <p>
  311 </li>
  312 <li>
  313 <b>support/</b>
  314 <p>
  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.
  319 <p>
  320 </li>
  321 <li>
  322 <b>syslog/</b>
  323 <p>
  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.
  329 <p>
  330 </li>
  331 <li>
  332 <b>system/</b>
  333 <p>
  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:
  337 
  338    <p>
  339    <table>
  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>
  353    </table>
  354    <p>
  355 </li>
  356 <li>
  357 <b>test/</b>
  358 <p>   
  359    This directory contains various test programs that I use
  360    to test and develop the code, and a Makefile to build them with.
  361    <p>
  362    Currently this directory contains the following programs:
  363    <p>
  364     <table>
  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>
  422    <p>
  423    <table>
  424 
  425    </table>
  426    <p>
  427 
  428 <p>   
  429 </li>
  430 <li>
  431 <b>util/</b>
  432 <p>
  433    This directory contains many useful one-off classes and function
  434    collections, including:
  435    <ol>
  436    <li>
  437    <b>BatchOperator</b>
  438    <p>
  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.
  444    </p>
  445    <b>ByteBuffer</b>
  446    <p>
  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.
  450    <p>
  451    </li>
  452    <li>
  453    <b>CountedObject</b>
  454    <p>
  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.
  458    <p>
  459    </li>
  460    <li>
  461    <b>CPULoadMeter</b>
  462    <p>
  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)
  467    <p>
  468    </li>
  469    <li>
  470    <b>Directory</b>
  471    <p>
  472       Directory is a platform-neutral API for scanning a filesystem
  473       directory and iterating over its contents.
  474    <p>
  475    </li>
  476    <li>
  477    <b>DebugTimer</b>
  478    <p>
  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).
  484    <p>
  485    </li>
  486    <li>
  487    <b>FilePathInfo</b>
  488    <p>
  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)
  493    <p>
  494    </li>
  495    <li>
  496    <b>Hashtable</b>
  497    <p>
  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.
  507    <p>
  508    </li>
  509    <li>
  510    <b>IPAddress</b>
  511    <p>
  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.
  516    <p>
  517    </li>
  518    <li>
  519    <b>NestCount</b>
  520    <p>
  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.
  525    <p>
  526    </li>
  527    <li>
  528    <b>MiscUtilityFunctions</b>
  529    <p>
  530       MiscUtilityFunctions.cpp is a catch-all for various useful functions
  531       that didn't fit anywhere else.
  532    <p>
  533    </li>
  534    <li>
  535    <b>NetworkUtilityFunctions</b>
  536    <p>
  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.
  541    <p>
  542    </li>
  543    <li>
  544    <b>ObjectPool</b>
  545    <p>
  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.
  550    <p>
  551    </li>
  552    <li>
  553    <b>PulseNode</b>
  554    <p>
  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.
  560    <p>
  561    </li>
  562    <li>
  563    <b>Queue</b>
  564    <p>  
  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.
  569    <p>
  570    </li>
  571    <li>
  572    <b>RefCount</b>
  573    <p>
  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...
  582    <p>
  583    </li>
  584    <li>
  585    <b>Socket</b>
  586    <p>
  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.
  592    <p>
  593    </li>
  594    <li>
  595    <b>SocketMultiplexer</b>
  596    <p>
  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)
  601    <p>
  602    </li>
  603    <li>
  604    <b>String</b>
  605    <p>
  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 (mike95@mike95.com) 
  609       and modified by myself.  String extends Flattenable, 
  610       so it can be serialized in a generic manner.
  611    <p>
  612    </li>
  613    <li>
  614    <b>StringTokenizer</b>
  615    <p>
  616       A string tokenizing class similar to Java's Java.util.StringTokenizer,
  617       only more efficient.
  618    <p>
  619    </li>
  620    <li>
  621    <b>TimeUtilityFunctions</b>
  622    <p>
  623       TimeUtilityFunctions.h is a repository of functions for dealing with 
  624       microsecond-accurate timing issues.
  625    <p>
  626    </li>
  627    </ol>
  628 </li>
  629 <li>
  630 <b>vc++/</b>
  631 <p>   
  632    This directory contains project files for building muscled under Visual C++
  633    for Windows.  These files were provided by Vitaliy Mikitchenko (aka VitViper)
  634 <p>   
  635 </li>
  636 <li>
  637 <b>winsupport/</b>
  638 <p>   
  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 
  643    protocol.
  644 <p>
  645 </li>
  646 <li>
  647 <b>zlib/</b>
  648 <p>   
  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.
  656 <p>   
  657 </li>
  658 </ol>
  659 <p>
  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.
  661 <p>
  662 -Jeremy 
  663