Class Reference

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:

A ->- 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.

    ->- B 
A 
    ->- C ->- D 

The notation system used in the inheritance hierarchies is based on the Object Modeling Technique (OMT) developed by Rumbaugh and others.[1]

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.

RWBench 
RWBitVec   
RWBTreeOnDisk   
RWCacheManager  
RWCollectable  
       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 
RWCRegexp 
RWCRExpr 
RWCString 
       RWCollectableString (&RWCollectable) 
RWCSubString 
RWCTokenizer 
RWDate 
       RWCollectableDate (&RWCollectable) 
RWErrObject 
RWFactory 
RWFile 
       RWFileManager 
RWGBitVec(size) 
RWGDlist(type) 
RWGDlistIterator(type) 
RWGOrderedVector(val) 
RWGQueue(type) 
RWGSlist(type) 
RWGSlistIterator(type) 
RWGStack(type) 
RWGVector(val) 
       RWGSortedVector(val) 
RWInstanceManager 
RWInteger 
       RWCollectableInt (&RWCollectable) 
RWIterator 
       RWBagIterator  
       RWBinaryTreeIterator  
       RWDlistCollectablesIterator  
       RWHashDictionaryIterator  
       RWHashTableIterator  
               RWSetIterator  
        RWOrderedIterator  
       RWSlistCollectablesIterator  
RWLocale   
       RWLocaleSnapshot   
RWMessage   
RWModel   
RWReference   
       RWCStringRef   
       RWVirtualRef   
       RWWStringRef    
RWTime     
       RWCollectableTime (&RWCollectable)    
RWTimer   
RWTBitVec<size>  
RWTIsvDlist<T> (Type)  
RWTIsvDlistIterator<T> (Type)  
RWTIsvSlist<T> (Type)   
RWTIsvSlistIterator<T> (Type)   
RWTPtrDeque<T> (Type)   
RWTPtrDlist<T> (Type)   
RWTPtrDlistIterator<T> (Type)   
RWTPtrHashMap<K,T,H,EQ> (Key, Type, Hash, EQ)  
RWTPtrHashMapIterator<K,T,H,EQ> (Key, Type, Hash, EQ)  
RWTPtrHashMultiMap<K,T,H,EQ> (Key, Type, Hash, EQ)  
RWTPtrHashMultiMapIterator<K,T,H,EQ> (Key, Type, Hash, EQ)  
RWTPtrHashMultiSet<T,H,EQ> (Type, Hash, EQ)  
RWTPtrHashMultiSetIterator<T,H,EQ> (Type, Hash, EQ)  
RWTPtrHashSet<T,H,EQ> (Type, Hash, EQ)  
RWTPtrHashSetIterator<T,H,EQ> (Type, Hash, EQ)  
RWTPtrMap<K,T,C> (Key,Type,Compare)  
RWTPtrMapIterator<K,T,C> (Key,Type,Compare)  
RWTPtrMultiMap<K,T,C> (Key,Type,Compare)  
RWTPtrMultiMapIterator<K,T,C> (Key,Type,Compare)  
RWTPtrMultiSet<T,C> (Type,Compare)  
RWTPtrMultiSetIterator<T,C> (Type,Compare)  
RWTPtrOrderedVector<T> (Type)  
RWTPtrSet<T,C> (Type,Compare)  
RWTPtrSetIterator<T,C> (Type,Compare)  
RWTPtrSlist<T> (Type)  
RWTPtrSlistIterator<T> (Type)  
RWTPtrSlistDictionary<KeyP,ValP>  
RWTPtrSlistDictionaryIterator<KeyP,ValP>  
RWTPtrSortedDlist<T,C> (Type,Compare)  
RWTPtrSortedDlistIterator<T,C> (Type,Compare)  
RWTPtrSortedVector<T,C> (Type,Compare)  
RWTPtrVector<T> (Type)  
RWTQueue<T,C> (Type, Container)  
RWTRegularExpression<charT>  
RWTStack<T,C> (Type, Container) 
RWTValDeque<T> (Type)  
RWTValDlist<T> (Type)  
RWTValDlistIterator<T> (Type)  
RWTValHashMap<K,T,H,EQ> (Key, Type, Hash, EQ)  
RWTValHashMapIterator<K,T,H,EQ> (Key, Type, Hash, EQ)   
RWTValHashMultiMap<K,T,H,EQ> (Key, Type, Hash, EQ)    
RWTValHashMultiMapIterator<K,T,H,EQ> (Key, Type, Hash, EQ)   
RWTValHashMultiSet<T,H,EQ> (Type, Hash, EQ)   
RWTValHashMultiSetIterator<T,H,EQ> (Type, Hash, EQ)  
RWTValHashSet<T,H,EQ> (Type, Hash, EQ)   
RWTValHashSetIterator<T,H,EQ> (Type, Hash, EQ)   
RWTValMap<K,T,C> (Key,Type,Compare)  
RWTValMapIterator<K,T,C> (Key,Type,Compare)  
RWTValMultiMap<K,T,C> (Key,Type,Compare)  
RWTValMultiMapIterator<K,T,C> (Key,Type,Compare) 
RWTValMultiSet<T,C> (Type,Compare)  
RWTValMultiSetIterator<T,C> (Type,Compare)  
RWTValOrderedVector<T> (Type)  
RWTValSet<T,C> (Type,Compare) 
RWTValSetIterator<T,C> (Type,Compare)  
RWTValSlist<T> (Type)    
RWTValSlistIterator<T> (Type) 
RWTValSlistDictionary<Key,V>  
RWTValSlistDictionaryIterator<Key,V>  
RWTValSortedDlist<T,C> (Type,Compare)   
RWTValSortedDlistIterator<T,C> (Type,Compare)  
RWTValSortedVector<T,C> (Type,Compare)  
RWTValVector<T> (Type)  
RWTValVirtualArray<T> (Type)  
RWvios  
       ios (virtual)  
              RWvistream  
                     RWbistream  (&ios: virtual)  
                            RWeistream  
                     RWpistream  
                     RWXDRistream (Unix only)  (&RWios)  
              RWvostream  
                     RWbostream  (&ios: virtual)  
                            RWeostream  
                     RWpostream  
                     RWXDRostream (Unix only)  (&RWios)  
RWVirtualPageHeap  
       RWBufferedPageHeap  
              RWDiskPageHeap  
RWWString  
RWWSubString  
RWWTokenizer  
RWZone  
       RWZoneSimple  
streambuf  
       RWAuditStreamBuffer  
       RWCLIPstreambuf  
              RWDDEstreambuf  
xmsg  
       RWxmsg   
              RWExternalErr  
                     RWFileErr  
                     RWStreamErr  
              RWInternalErr  
                     RWBoundsErr  
              RWxalloc  



[1] The notation is similar to the notation used in Design Patterns by Gamma, Helm, Johnson, and Vlissides.