RWTools(3C++)

Name
     librwtool - Rogue Wave library class introduction

Introduction
     The Tools.h++ Class Reference describes all the classes and functions in
     Tools.h++.  It does not provide a tutorial on how to program with the
     Tools.h++ class library.  For information on how to write programs using
     Tools.h++, consult the Tools.h++ User's Guide.  For information on
     installing and using Tools.h++, review the Tools.h++ Getting Started
     Guide.

Organization of the Class Reference
     Immediately following this introduction is a class hierarchy diagram.
     The class hierarchy lists all the classes, and illustrates the
     relationships among them.  You can refer to it for a bird's-eye view of
     the inheritance structure used in Tools.h++.  The remainder of this
     reference is an alphabetical listing of classes.  The entry for each
     class begins with an illustration showing the individual class's
     inheritance hierarchy, followed by a synopsis that lists the header
     files(s) and the Smalltalk typedef (if appropriate) associated with the
     class. The synopsis also shows a declaration and definition of a class
     object, and any typedefs that are used.  Following the synopsis is a
     brief description of the class, and a list of member and global
     functions. These functions are organized in categories according to their
     general use - for example, "constructors," "global operators," and
     "public member functions."  The categories, although somewhat arbitrary,
     provide a way of organizing the many functions.

Conventions
     All Rogue Wave class names start with the letters RW, as in
     RWCollectable, with the bold font emphasizing the class name rather than
     the prefix.  In some cases, we may refer to an instance of a class by an
     English name; for example, "the string" instead of "the RWCString
     instance."  We do this to make it easier to read when the meaning should
     be clear from context, but we use the longer form if there is a possible
     ambiguity.  All function names begin with a lower case letter, with the
     first letter of subsequent words capitalized.  Function names attempt to
     accurately describe what a function does.  For example,
     RWCString::toLower() changes all uppercase letters in itself to
     lowercase.  Underline characters and abbreviations are not generally used
     in function names.  Function names, examples, operating system commands,
     mathematical symbols and code fragments are shown in a courier font, as
     in <rw/stream.h> .  Vertical ellipses are used in code examples to
     indicate that some part of the code is missing.  Throughout this
     documentation, there are frequent references to "self."  This should be
     read as "*this".

Inheritance Notation
     Each class that inherits from another class (or other classes) includes
     an illustration that shows the inheritance hierarchy.  For example, the
     following illustration indicates that class A inherits from class B:
     When a class inherits from more than one  class, or there are multiple
     levels of inheritance, all of the inheritance relationships are shown.
     For example, the following illustration indicates that A inherits from
     class B and from class C, which inherits from class D.  The notation
     system used in the inheritance hierarchies is based on the Object
     Modeling Technique (OMT) developed by Rumbaugh and others.

Member Functions
     Within their general categories, member functions for each class are
     listed alphabetically.  Member functions fall into three general types:
          Functions that are unique to a class.  The complete documentation
          for these functions is presented in the class where they occur.  An
          example is balance(), a member of the class RWBinaryTree.

          Functions that are inherited from a base  class without being
          redefined.  The complete documentation for these functions is
          presented in the defining base class.  An example is
          clearAndDestroy(), for class RWBinaryTree, which is inherited from
          class RWCollection.  When a member function is inherited without
          being redefined, the member function appears in both places, and
          this guide refers you to the original definition.

          Functions that are redefined in a derived class.  These are usually
          virtual functions.  The documentation for these functions usually
          directs you to the base class, but may also mention peculiarities
          that are relevant to the derived class.  An example is apply(), for
          class RWBinaryTree.


Class Hierarchy
     The following list shows the public class hierarchy of the Tools.h++
     classes.  Note that this is the public class hierarchy--the
     implementation of a given class may use private inheritance.
     Additionally, some classes inherit from public, but undocumented,
     implementation classes.  Undocumented classes are omitted from the
     hierarchy. Classes derived by multiple inheritance show their additional
     base(s) in italics to the right of the class name.

Class Hierarchy
              RWBench
               RWCollection
                    RWBag
                    RWBinaryTree
                    RWBTree
                         RWBTreeDictionary
                    RWHashTable
                         RWSet
                              RWFactory
                              RWHashDictionary
                                   RWIdentityDictionary
                              RWIdentitySet
                    RWSequenceable
                         RWDlistCollectables
                         RWOrdered
                              RWSortedVector
                         RWSlistCollectables
                              RWSlistCollectablesQueue
                              RWSlistCollectablesStack
               RWCollectableAssociation
               RWCollectableDate (&RWDate)
               RWCollectableInt (&RWInteger)
               RWCollectableString (&RWCString)
               RWCollectableTime (&RWTime)
               RWModelClient
               RWCollectableString (&RWCollectable)
               RWCollectableDate (&RWCollectable)
          RWErrObject
               RWFileManager
               RWGSortedVector(val)
          RWInstanceManager
               RWCollectableInt (&RWCollectable)
               RWBagIterator
               RWBinaryTreeIterator
               RWDlistCollectablesIterator
               RWHashDictionaryIterator
               RWHashTableIterator
                    RWSetIterator
               RWOrderedIterator
               RWSlistCollectablesIterator
               RWLocaleSnapshot
          RWMessage
          RWReference
               RWCStringRef
               RWVirtualRef
               RWWStringRef
               RWCollectableTime (&RWCollectable)
          RWTPtrSlistDictionary<KeyP,ValP>
          RWTPtrSlistDictionaryIterator<KeyP,ValP>
          RWTRegularExpression<charT>
          RWTValSlistDictionary<Key,V>
          RWTValSlistDictionaryIterator<Key,V>
               ios (virtual)
                     RWvistream
                         RWbistream  (&ios: virtual)
                              RWeistream
                         RWpistream
                         RWXDRistream  (&RWios)
                     RWvostream
                         RWbostream  (&ios: virtual)
                              RWeostream
                         RWpostream
                         RWXDRostream  (&RWios)
               RWBufferedPageHeap
                    RWDiskPageHeap
               RWZoneSimple
          streambuf
               RWAuditStreamBuffer
               RWCLIPstreambuf
                    RWDDEstreambuf
          xmsg
               RWxmsg
                    RWExternalErr
                         RWFileErr
                         RWStreamErr
                    RWInternalErr
                         RWBoundsErr
                    RWxalloc



Contents