•  Essential Tools Module User's Guide
  •  Chapter 1 Introduction
    • Overview
    • Features and Benefits
    • Examples
    • Products and Services Information
  •  Chapter 2 Class Overview
    • Introduction
    •  Class Groups
      • Date and Time Class Group
      • String Processing Class Group
      • Virtual Stream Class Group
      • Collection Class Group
      • Internationalization Class Group
      • File System Classes
      • Miscellaneous Class Group
    •  Abstract and Concrete Classes
      •  Concrete Classes
        • Simple Classes
        • Template-based Collection Classes
      • Abstract Base Classes
    •  Common Functionality Among Classes
      •  Common Member Functions
        • Persistence Functions
        • Store Size Functions
        • Stream I/O Functions
        • Comparison Functions
      • Memory Allocation and Deallocation
      • Information Flow
      •  Multithread Safety
        • Assigning Thread Safety Levels to Classes and Libraries
        • Thread Safety in the Essential Tools Module
      • Indexing
      • Version
  •  Chapter 3 Date and Time Classes
    • Introduction
    • Calendar and Time Formats
    •  International Standards for Dates and Times
      • SourcePro’s ISO 8601 Parsers
    • Setting the Time Zone
    •  RWDateTime
      • About Two or Four Digit Years
      • Member Functions
      •  RWDateTime Sentinels
        • The “Invalid” Sentinel and Other Invalid Instances
        • The “Null” Sentinel
        • The Past and Future Sentinels
        • User-Defined Sentinels
    • RWTimeTuple and RWTimeTupleOffset
    • RWDate
    • RWTime (deprecated)
    • The Date and Time Collectable Class
  •  Chapter 4 String Processing Classes
    • Introduction
    • RWCString and RWWString
    • An Introductory Example
    • Lexicographic Comparisons
    • Substrings
    •  Pattern Matching
      •  Regular Expressions
        • The RWTRegex<T> Interface
        • Using Regular Expressions Efficiently
        • Introductory Examples Using Regular Expressions
    •  String I/O
      • Iostreams
      • Virtual Streams
    • Tokenizer
    • Multibyte Strings
    • Wide Character Strings
    • Performance Considerations
  •  Chapter 5 Stream Classes
    • Introduction
    • RWvios, RWvistream, and RWvostream
    • Specializing Virtual Streams
    • Simple Virtual Streams Example
    • Virtual Steams Recap
    • RWAuditStreamBuffer
    •  Compressed IOStreams
      • Buffer Size
      • Typedefs
      • Custom Compressor Interface
  •  Chapter 6 Collection Classes
    • Introduction
    •  Collection Class Groups
      • Traditional Collection Classes
      • STL-based Collection Classes
      • STL Extension-based Collection Classes
      • RWCollectable Classes
    •  Storage Methods of Collection Classes
      • Value-based and Reference-based Collections
      • Examples of Value-based and Reference-based Collections
      • A Note on Memory Management
    •  Copying Collection Classes
      • Copying Reference-based Collection Classes
      • Copying Value-based Collection Classes
    •  Retrieving Objects in Collections
      • Retrieval Methods
    •  Iterators for Collection Classes
      • Traditional Essential Tools Module Iterators
    • Collection Class Templates
    •  Template Overview
      • Template Naming Convention
      •  Value vs. Reference Semantics in Templates
        • An Important Distinction
      • Intrusive Lists in Templates
    •  Essential Tools Module Templates and C++ Standard Library Containers
      • The C++ Standard Library Containers
      • Commonality of Interface
    • Parameter Requirements
    •  Function Objects for Comparison
      • More on Total Ordering
    • Function Objects for Hashing and Equality
    •  Iterators in Class Templates
      • C++ Standard Library Iterators
      • Map-Based Iteration and Pairs
      • Iterators as Generalized Pointers
    • Iterators and the std() Gateway
    • Example Using the Essential Tools Module with the C++ Standard Library
    •  Designing an RWCollectable Class
      •  Bus Example Scenario
        • Serialization Support Macros
        • Exporting Symbols in a Windows Environment
      • The Role of RWCollectable
      • Bus Example Code
    •  Creating an RWCollectable Object
      • Define a Default Constructor
      • Add RW_DECLARE_COLLECTABLE_CLASS() to your Class Declaration
      •  Provide a Class Identifier for Your Class
        • Virtual Function isA()
        • Virtual Function newSpecies()
        • Function stringID()
      •  Add Definitions for Virtual Functions
        • Virtual Function compareTo()
        • Virtual Function isEqual()
        • Virtual Function hash()
        • An Example of compareTo(), isEqual(), and hash()
      • Object Destruction
      •  How to Add Polymorphic Persistence
        • Virtual Functions saveGuts(RWFile&) and saveGuts(RWvostream&)
        • Virtual Functions restoreGuts(RWFile&) and restoreGuts(RWvistream&)
        • Multiply-referenced Objects
        • Virtual Function binaryStoreSize()
        • Polymorphically Persisting Custom Collections
      • A Note on the RWFactory
    • Complete Listing for Class Bus
    •  Smalltalk‑like Collection Classes
      • Tables of the Smalltalk-like Classes
      • Smalltalk-like Classes Example
      •  Choosing a Smalltalk-like Collection Class
        • Bags Versus Sets Versus Hash Tables
        • Sequenceable Classes
        • Dictionaries
      •  Virtual Functions Inherited From RWCollection
        • insert()
        • find() and Friends
        • remove() Functions
        • apply() Functions
        • Functions clear() and clearAndDestroy()
      •  Other Functions Shared by All RWCollections
        • Class Conversions
        • Inserting and Removing Other Collections
        • Selection
      • Virtual Functions Inherited from RWSequenceable
      •  A Note on How Objects are Found
        • Hashing
  •  Chapter 7 Internationalization Classes
    • Introduction
    • Localizing Alphabets with RWCString and RWWString
    • Challenges of Localizing Currencies, Numbers, Dates, and Times
    •  RWLocale and RWZone
      • RWLocaleSnapshot and RWAnsiLocale
      • Dates
      • Time
      • Numbers
      • Currency
  •  Chapter 8 Persistence
    • Introduction
    •  Levels of Persistence
      • A Note About Terminology
      • About the Examples in this Section
    • No Persistence
    •  Simple Persistence
      •  Two Examples of Simple Persistence
        • Example One: Simple Persisting Objects of Fundamental Type
        • Example Two: Simple Persistence and Pointers
    •  Isomorphic Persistence
      • Isomorphic versus Simple Persistence
      • Isomorphic Persistence of an Essential Tools Module Class
      •  Designing Your Class to Use Isomorphic Persistence
        • Make All Necessary Class Data Available
        • Add RW_DECLARE_PERSISTABLE to Your Header File
        • Add RW_DEFINE_PERSISTABLE to One Source File
        • Check for Possible Problems
        • Define rwSaveGuts and rwRestoreGuts
      •  Writing rwSaveGuts and rwRestoreGuts Functions
        • Guidelines for Writing rwSaveGuts
        • Guidelines for Writing rwRestoreGuts
      • Isomorphic Persistence of a User-designed Class
    •  Polymorphic Persistence
      • Operators
      • Designing your Class to Use Polymorphic Persistence
      •  Polymorphic Persistence Example
        • Example One: Saving Polymorphically
        • Example Two: Restoring Polymorphically
        • Example Two Revisited
        • Choosing Which Persistence Operator to Use
    •  A Few Friendly Warnings
      • Always Save an Object by Value Before Saving the Identical Object by Pointer
      • Don't Save Distinct Objects with the Same Address
      • Don't Use Sorted RWCollections to Store Heterogeneous RWCollectable Objects
      • Define All RWCollectable Objects To Restore
  •  Chapter 9 Error Handling and Reporting
    • Introduction
    •  Error Categories
      • The Essential Tools Module Error Model
      •  Internal Errors
        • Non-recoverable Internal Errors
        • Recoverable Internal Errors
      • External Errors
    •  Error Reporting and Error Handling
      •  Essential Tools Module Exception Architecture
        • RWxmsg
        • RWExternalErr
        • RWStreamErr
        • RWFileErr
        • RWxalloc
        • RWInternalErr
        • RWRegexErr
        • RWBoundsErr
      •  Using the Error Reporting Classes to Handle Errors
        • When Exceptions are Supported
        • When Exceptions are Not Supported
    • The Debug Version of the Essential Tools Module
  •  Chapter 10 File System Classes
    • Introduction
    •  RWFile
      • Example
    •  RWFileStat
      • Construction
      • Example
    •  RWDirectoryIterator
      • Flat Iteration Example
      • Recursive Iteration Example
    •  RWFileManager
      • Construction
      • Member Functions
      • Example
    •  RWBTreeOnDisk
      • Construction
      • Example
  •  Chapter 11 Scope Guard Classes
    • Introduction
    •  RWScopeGuard
      • Construction
      • Member Functions
    •  RWTRefHolder<T>
      • Why Use RWTRefHolder<T>
      • A Note on Pointer and Reference Parameters
    • Example
  •  Chapter 12 Advanced Topics
    • Introduction
    •  Copy on Write
      • A More Comprehensive Example
    •  RWStringID
      • Duration of Identifiers
      • Programming with RWStringIDs
      •  Implementation Details of RWStringID
        • Automatic RWClassIDs
        • Implementing Virtuals Via Statics
        • Polymorphic Persistence
        • Efficiency
        • Identification Collisions
    • More on Storing and Retrieving RWCollectable Objects
    • Multiple Inheritance
    •  Using Custom Allocators
      • Template Functions
      • Example
  •  Chapter 13 Common Mistakes
    • Introduction
    • Redefinition of Virtual Functions
    • Iterators
    • Return Type of operator>>()
    • Avoid Persisting Value Collections of Pointers
    • Include Path
    • Match Memory Models and Other Qualifiers
    •  Keep Related Methods Consistent
      • DLL
    • Use the Capabilities of the Module!
  •  Appendix A Choosing a Collection
    • Introduction
    •  Selecting an Essential Tools Module Collection Class
      • How to Use the Decision Tree
      • Additional Selection Criteria
    •  Time and Space Considerations
      • RWTBitVec<Size>, RWTPtrVector, and RWTValVector<T>
      • Singly-Linked Lists
      • Doubly-Linked Lists
      • Ordered Vectors
      • Sorted Vectors
      • Stacks and Queues
      • Deques
      • Binary Tree
      • (multi)map and (multi)set family
      • RWBTree, RWBTreeDictionary
      • Hash-based Collections
  •  Appendix B Constants, Typedefs, Pointers, and Enumerations
    • Constants
    • Typedefs
    • Pointers to Functions
    • Enumerations
    • Standard Smalltalk Interface Typedefs
•  Threads Module User's Guide
  •  PART I Introduction
    •  Chapter 1 Introduction
      • Welcome
      • Packages and Libraries
      • Examples
      • Products and Services Information
    •  Chapter 2 Threads Module Overview
      • Background
      •  The Threads Module Packages
        • Threading Package
        • Synchronization Package
        • Interthread Communication Package
        • Smart Pointer Package
        • Functor Package
        • Execution Tracing Package
        • Thread-compatible Exception Package
      • Using the Packages Together
  •  PART II Concurrency Packages
    •  Chapter 3 The Threading Package
      •  Introducing the Threading Package
        • Interpackage Dependencies
        • Including the Header Files
      •  Definitions
        • Threads and Concurrency
        • Threads and Memory
        • Thread Safety
      •  Threading Class Hierarchies
        •  The Runnable Class Hierarchy
          • Runnable Handle Classes
          • Runnable Body Classes
          • Thread Pool Class
        • The Attribute Class Hierarchy
        • The IOU Class in the Threading Package
      •  Using Threads
        • Creating Threads
        • Introducing the Runnable
        • Explicitly Constructing Functors and Runnables
      •  The Runnable Object Classes
        •  Defining a Runnable’s Task
          • Functor-Based Runnables
          • Runnable Servers
          • Guard Functors
        • Creating Functor-based Runnables
        • Runnable State
        • Runnable Operations
        •  Starting a Runnable
          • Starting Synchronous Runnables
          • Checking the Completion State
          • Starting Threaded Runnables
          • Distinguishing Between Synchronous and Threaded Runnables
          • Restarting a Threaded Runnable
        •  Joining a Runnable
          • Types of Join Functions
          • Joining Unstarted or Inactive Runnables
        • Monitoring the Completion State of a Runnable
        •  Catching and Rethrowing Exceptions
          • Testing After Successful Joins
          • Types of Rethrown Exceptions
        •  Interrupting a Runnable
          • Avoiding Deadlock
          • Interrupting a Runnable from Another Thread
          • Completing the Interrupt Request
          • Types of requestInterrupt() Functions
          • Shutting Down a Continuous Process
          • Rendezvous Synchronization
          • Interrupting Threads at Startup
        •  Canceling a Runnable
          • Canceling a Runnable from Another Thread
          • Completing a Cancellation Request
          • Aborting a Cancellation
          • Types of requestCancellation Functions
          • Undoing a Cancellation Request
          • Using Synchronization Classes to Service Cancellation Requests
          • Designing Your Code
        • Sleeping
        •  Yielding Execution
          • Executing Under a Preemptive Scheduling Policy
          • Yielding to Lower Priority Threads
        •  Suspending and Resuming Execution
          • Using the suspend() and resume() Functions
          • Deciding Whether Suspension Is Available
        • Terminating Execution
        •  Monitoring the Execution State of a Runnable
          • Getting the Instantaneous Execution State of a Runnable
          • Monitoring Changes in Execution State
          • Using Wait Functions
          • Using Callbacks
          • Registering the Callback
          • Changing the Execution State
          • Reusing Functors
          • Removing a Callback
        •  Execution Nesting
          • Starting Synchronous Runnables
          • Using the Nested Runnable Information
        • Thread Identification
      •  The Server Classes
        • Constructing a Server
        • Starting a Server
        • Enqueuing Runnables on a Server
        • Stopping a Server
        • Interrupting a Server
        • Canceling a Server
        • Using Server Pool Thread Attributes
        •  Resizing a Server Pool
          • Contracting a Server Pool
          • Creating or Expanding a Server Pool
      •  The Thread Pool Class
        • Constructing a Thread Pool
        • Starting a Thread Pool
        • Enqueuing Work on a Thread Pool
        • Stopping a Thread Pool
        •  Considerations
          • Pool Thread Attributes
          • Pool Expansion and Contraction
      •  Using Threads To Build Active Objects
        •  Using Runnables
          • Example
          • Other Solutions to the Join Problem
        • Using Runnable Servers
      •  Thread Attributes
        •  Thread Attribute Families
          • Scheduling Attributes
          • Stack Management Attributes
        • Thread Attribute Portability
        •  Testing For Support
          • Using Feature Test Macros
          • “Get” Test Functions
          • “Set” Test Functions
          • “Is Set” Test Functions
        • Querying Attribute Values
        • Setting Attribute Values
        • Default Attribute Values
        • Restoring Default Attribute Values
        • Determining the Legal Range For An Attribute
        •  Scheduling Attributes
          • Start Policy
          • Scheduling Contention Scope
          • Scheduling Inheritance Policy
          • Concurrency Policy
          • Scheduling Policy
          • Scheduling Priority
          • Scheduling Time-Slice Quantum
        •  Stack Attributes
          • Allocating and Managing a Thread Stack
          • System-Managed Stack Attributes
          • User-Managed Stack Attributes
        •  Initializing Threaded Runnables
          • Supplying RWThreadAttribute Instances To Threaded Runnables
          • Supplying RWThreadAttribute Instances At Construction
          • Supplying RWThreadAttribute Instances After Construction
        • Querying Threaded Runnables For Thread Creation Attributes
    •  Chapter 4 The Synchronization Package
      •  Introducing the Synchronization Package
        • Interpackage Dependencies
        • Including the Header Files
      • Definitions
      •  Synchronization Class Hierarchy
        • The Synchronization Class Hierarchy
        • The Guard Class Hierarchy
      •  Getting Started
        • Creating Two or More Threads that Access the Same Resources
        •  Using Mutexes
          • Using a Basic Mutex Mechanism
          • Using a Try-Catch Block
        • Using Guards
        •  Building Monitors
          • Count Synchronization
          • Read Synchronization
          • The RWTMonitor<Lock> Class
        •  Using Condition Variables
          • Combining the Condition Variable with Mutual Exclusion
          • Using the Condition Variable for Producer-Consumer Synchronization
      •  The Synchronization Classes
        •  The RWMutexLock Class
          • Avoiding a Block
          • Using Timed Waits
          • Attempting Recursive Acquisition
          • Acquiring Mutex Ownership
          • Using a Guard Class
          • Initializing a Mutex
          • Servicing Cancellation Requests
        • The RWFIFOMutexLock Class
        • The RWNullMutexLock Class
        •  The RWTRecursiveLock Class
          • Identifying Threads
          • Using RWTRecursiveLock
        • The RWReadersWriterLock Class
        • The RWCriticalSection Class
        • The RWSemaphore Class
        • The RWCondition Class
        • The RWBarrier Class
        • The RWTMonitor Class
      •  The Guard Classes
        • Using a Lock Guard
        • Releasing and Reacquiring a Guarded Lock
        • Using the Unlock Guard Class
        • Using the RWTTryLockGuard Template Class
        • Using Classes with Read-Write Synchronization Resources
    •  Chapter 5 The Interthread Communication Package
      •  Introducing the Interthread Communication Package
        • Interpackage Dependencies
        • Including the Header Files
      •  Definitions
        • Futures, IOUs, and Escrows
        • Producers, Consumers, and Blocking
      •  Interthread Communication Class Hierarchies
        • The Producer-Consumer Class Hierarchy
        • The IOU Class Hierarchy
      •  Using Interthread Communication
        •  Using Producer-Consumer Queues
          • The RWTPCValQueue Family of Classes
          • Example
      •  The IOU Classes
        • Testing for Empty IOU Handles
        • Constructing an IOU
        •  Closing an IOU
          • The close() Function
          • The setException() Function
          • Example
        •  Redeeming an IOU
          • Rules about Threads and IOUs
          • Aborting a Request
          • Querying the Status of an IOU Object
        •  Using IOUs
          • Example
          • Closing and Redeeming an IOU
          • Using Active Objects
        •  Waiting for IOUs
          • Asynchronous Example
        •  Trapping IOUs with RWTIOUTrap
          • Waiting for Trapped IOUs
          • Using Timed Waits
          • Improving the Asynchronous Example
          • Another Asynchronous Example
      •  The Producer‑Consumer Classes
        • Value and Pointer Classes
        • Guarded and Prioritized Classes
  •  PART III Foundation Packages
    •  Chapter 6 The Execution Tracing Package
      •  Introducing the Execution Tracing Package
        • Interpackage Dependencies
        • Including the Trace Header Files
        • Trace Severity Levels
      •  Execution Tracing Package Architecture
        • The Trace Output Pipeline
        • Trace Class Hierarchy
      • Using Trace
      •  Using Set Declaration Macros
        • Package Declaration Macros
        •  Class Declaration Macros
          • Implications for Template Classes
        •  Function Declaration Macros
          • Macros for Global Functions
          • Macros for Member Functions
          • Macros for Static Member Functions
          • Macros for Friend Functions
          • Implications for Template Classes
          • Assigning functionTag Names
        • Setting Environment Variables for Event Sets
      •  Using Event Generation Macros
        • Macros for Global Functions
        • Macros for Member Functions
        • Including Variables in Trace Messages
        • Trace Macros Example
      •  Using the Trace Manager
        • The Trace Manager Buffer
        • Stopping Trace
        • Trace Manager Environment Variables
      •  Using Trace Clients
        • Using the Predefined Client
        •  Creating User-defined Clients
          • Including a Timestamp in Trace Output
          • Including Thread IDs in Trace Output
          • Using Your Client
      •  Using Trace Filters
        •  Using the Predefined Filters
          • Using RWTraceLevelFilter
          • Using RWTraceMultiClientFilter
        • Chaining Multiple Filters
        •  Creating User-defined Filters
          • Creating the Filter’s Body Class
          • Creating the Filter’s Handle Class
          • Instantiating Your Derived Filter
      • Using Package-level Tracing
      •  Controlling Trace Output
        • The RW_USER_TRACE_LEVEL Macro
        • The RW_TRACE_LEVEL Environment Variable
        • The RWTraceLevelFilter Class
        • Combining All Filtering Methods
    •  Chapter 7 The Smart Pointer Package
      •  Introducing the Smart Pointer Package
        • Interpackage Dependencies
        • Including the Smart Pointer Header Files
      •  Smart Pointer Class Hierarchy
        • Template Parameter Naming Conventions
        • Handle-Body Classes in Class Hierarchies
      •  Using the Handle-Body Classes
        •  Understanding the Handle-Body Idiom
          • Simplifying Memory Management
          • Decomposing Complex Abstractions
          • Decoupling Interfaces from Implementations
          • Handle-Body Mechanics
        •  Implementing Your Own Handles and Bodies
          • Defining Handle Classes that Automatically Create Bodies
          • Defining Handle Classes that Don’t Create Bodies
          • Handle-Body Example
      • Using the RWTSingleton Class
      •  Using the Smart Pointer Classes
        • Using RWTOnlyPointer
        •  Using RWTCountedPointer
          • Deriving from RWTCountingBody for Reference Counting
        •  Using RWTCountingPointer
          • Providing RWTCountingPointer with a Counter
      • Smart Pointer Class Architecture
    •  Chapter 8 The Functor Package
      •  Introducing the Functor Package
        • Interpackage Dependencies
        • Including the Functor Header Files
        • What Are They For?
        •  How Do They Work?
          • When the Function Signature Matches the Functor Invocation
          • When Function Arguments Won’t Change Across Invocations
          • When You’re Not Using a Return Value
          • When the Types Don’t Quite Match
      •  Constructing Functors
        • Analyzing Functor Requirements
        • Copying and Assigning Functors
      •  Invoking Functors
        • Running Unknown Functions
      •  Binding Functor Arguments
        • Binding Reference Types
        • Binding Member Functions
        • Using Placeholder Arguments
    •  Chapter 9 The Thread‑Compatible Exception Package
      •  Introducing the Thread-compatible Exception Package
        • Interpackage Dependencies
        • Including the Exception Header Files
      • Exception Class Hierarchy
      • Default Exception Messages
      •  Using the Thread-compatible Exception Classes
        • Creating Your Own Exception Classes
        • Creating Your Own Error Handler
        • Making Existing Exceptions Thread-Compatible
  •  PART IV Resources
    •  Appendix A Acknowledgements
      • People
      • Citations
•  Threads Module Platform Guide
  •  Chapter 1 Introduction
    • Overview
    • Examples
    • Products and Services Information
  •  Chapter 2 AIX Technical Information
    • AIX Thread Attributes: An Overview
    •  AIX POSIX 1003.1c Thread Attribute Support
      •  Scheduling Attributes
        • Start Policy
        • Contention Scope
        • Scheduling Inheritance Policy
        • Concurrency Policy
        • Scheduling Policy
        • Scheduling Priority
        • Scheduling Time-Slice Quantum
      •  Stack Attributes
        • System-Managed Stack Attributes
        • User-Managed Stack Attributes
  •  Chapter 3 HP‑UX Technical Information
    • HP-UX Thread Attributes: An Overview
    •  HP-UX POSIX 1003.1c Thread Attribute Support
      •  Scheduling Attributes
        • Start Policy
        • Contention Scope
        • Scheduling Inheritance Policy
        • Concurrency Policy
        • Scheduling Policy
        • Scheduling Priority
        • Scheduling Time-Slice Quantum
      •  Stack Attributes
        • System-Managed Stack Attributes
        • User-Managed Stack Attributes
  •  Chapter 4 Linux Technical Information
    • Linux Thread Attributes: An Overview
    •  Linux POSIX 1003.1c Thread Attribute Support
      •  Scheduling Attributes
        • Start Policy
        • Contention Scope
        • Scheduling Inheritance Policy
        • Concurrency Policy
        • Scheduling Policy
        • Scheduling Priority
        • Scheduling Time-Slice Quantum
      • Stack Attributes
  •  Chapter 5 Solaris Technical Information
    • Solaris Threading APIs
    • Solaris Thread Attributes: An Overview
    •  Solaris Threads Attribute Support
      •  Scheduling Attributes
        • Start Policy
        • Scheduling Contention Scope
        • Scheduling Inheritance Policy
        • Concurrency Policy
        • Scheduling Policy
        • Scheduling Priority
        • Scheduling Time-Slice Quantum
      •  Stack Attributes
        • System-Managed Stack Attributes
        • User-Managed Stack Attributes
      • Signal Handling Considerations
  •  Chapter 6 Windows Technical Information
    •  Win32 Thread Attribute Support
      •  Scheduling Attributes
        • Start Policy
        • Scheduling Contention Scope
        • Scheduling Inheritance Policy
        • Concurrency Policy
        • Scheduling Policy
        • Scheduling Priority
        • Scheduling Time-Slice Quantum
      •  Stack Attributes
        • System-Managed Stack Attributes
        • User-Managed Stack Attributes
    • Using the Threads Module with MFC
•  Advanced Tools Module User’s Guide
  •  PART I Advanced Tools Module
    •  Chapter 1 Introduction
      • Welcome
      • Product Packages and Libraries
      • Examples
      • Products and Services Information
    •  Chapter 2 Package Overview
      •  Advanced Tools Module Packages
        • The Streams Package
        • The Serialization Package
        • The Types Package
      • Using the Packages Together
      • Introduction to the Handle-Body Architecture
  •  PART II Advanced Tools Module Packages
    •  Chapter 3 The Streams Package
      • Introducing the Streams Package
      •  The Stream Families
        • Memory Streams
        • Interpackage Dependencies
      • Definitions
      •  Streams Package Architecture
        •  The Common Framework
          • The Handle Classes
          • The Abstract Body Classes
        •  The Extended Framework
          • The Memory Stream Handle Classes
          • The Memory Stream Abstract Body Classes
          • The Memory Stream Concrete Body Classes
        •  The Common Filtered Streams
          • Buffered Streams
          • Synchronized Streams
          • Guarded Streams
      •  The Streams Package Classes
        •  The Binary Streams
          • The RWByteToStreambufOutputStreamImp Class
          • The RWByteFromStreambufInputStreamImp Class
          • The RWStreambufToByteOutputStream Class
          • The RWStreambufFromByteInputStream Class
        •  The Narrow Character Streams
          • The RWCharToStreambufOutputStreamImp Class
          • The RWCharFromStreambufInputStreamImp Class
          • The RWStreambufToCharOutputStream Class
          • The RWStreambufFromCharInputStream Class
        •  The Unicode Character Streams
          • The RWUCharToByteOutputStreamImp Class
          • The RWUCharFromByteInputStreamImp Class
          • The RWUCharToUTF8ByteOutputStreamImp Class
          • The RWUCharFromUTF8ByteInputStreamImp Class
        •  The Wide Character Streams
          • The RWWCharToWStreambufOutputStreamImp Class
          • The RWWCharFromWStreambufInputStreamImp Class
        •  The Data Streams
          • The RWNativeDataToByteOutputStreamImp Class
          • The RWNativeDataFromByteInputStreamImp Class
          • The RWOstreamDataToCharOutputStreamImp Class
          • The RWIstreamDataFromCharInputStreamImp Class
          • The RWvostreamToDataOutputStream Class
          • The RWvistreamFromDataInputStream Class
    •  Chapter 4 Using Streams
      •  Introduction
        • The Streams Header Files
        •  Using the Streams Package with Other Streaming Libraries
          • Using the Standard iostreams Library
          • Using Essential Tools Module Virtual Streams
      •  Examples
        • Creating and Using Streams with Only One Streaming Element
        •  Creating and Using Chains of Streaming Elements
          • Output Example
          • Input Example
        •  Creating and Using Thread-safe Chains of Streaming Elements
          • Creating a Synchronized Data Output Stream
          • Creating and Managing Threads Using Active Objects
          • Creating and Sharing a Synchronized Data Output Stream Among Several Active Objects
          • Active Objects and Data Input Streams
          • Creating and Sharing a Synchronized Data Input Stream Among Several Active Objects
        •  Creating and Using Stream Adapter Classes
          • The iostreams Adapter Classes
          • Virtual Streams Adapter Classes in the Essential Tools Module
          • Architecture of the Adapter Classes
          • Using the Adapter Classes for Output
          • Using the Adapter Classes for Input
      •  Error Handling
        • Handling Errors Using the Stream Status Functions
        • Streams Package Exception Classes
    •  Chapter 5 The Serialization Package
      •  Introducing the Serialization Package
        • Classes Supported by the Serialization Package
        • Object Serialization for Saving Program State
        • Object Serialization and Distributed Applications
        • Interpackage Dependencies
      •  Object Serialization Concepts
        • Writing and Reading the Object State
        • Type Information (Polymorphism)
        • Object Identity (Isomorphism)
        • Intrusive and External Serialization
        • Symmetry of Object Input and Output
        • Annotated Streams and Embedded Schemas
      •  Supported Streaming Formats
        •  The Compact Object Stream Format
          • Object Streams With Data Streams
          • Object Streams With Virtual Streams
          • Object Streams With Collectable Objects
      •  Serialization Package Architecture
        • How Does Serialization Work?
        • Relationship to the Streams Package
        • Handle-Body Architecture
      • Serialization Package Classes
    •  Chapter 6 Using Object Serialization
      •  Introduction
        • Including the Header Files
      •  Getting Started
        • Serialization Requirements
        •  Simple Examples
          • Declaring the Streaming Operators
          • Defining the streamContents() Function
          • Streaming the Serialized Object
          • Writing to and Reading from Compact Object Streams
          • Writing to and Reading from Compact Object Streams With Virtual Streams
      •  Using the Stream Contents Macros
        • Header File Macros
        • Source File Macros
        • Macros for External Serialization
        • Macro Summary
      •  Basic Examples
        •  Saving and Restoring an Object by Value
          • First Change
          • Second Change
        •  Saving and Restoring an Object by Pointer
          • First Change
          • Second Change
          • Third Change
          • A Caution on Using Streaming Pointers
        •  Associations with Other Objects
          • Data Member is an Object
          • Data Member is a Pointer to an Object
          • Data Member is a Value-based or Pointer-based Collection
        • Templates
        • Default Constructors
        • External Serialization
        • External Serialization of Templates and Nested Classes
      •  Advanced Examples
        • Using Object Streams with RWCollectable-Derived Objects
        • Making RWCollectable Objects That Are Also Serializable
        • Writing Custom streamContents() Functions
        •  Controlling the Scope of Object Reference Resolution
          • Streaming Out Multiple Objects
          • Streaming Multiple Objects into One Document
    •  Chapter 7 The Types Package
      • Introducing the Types Package
    •  Chapter 8 International Features of the Advanced Tools Module
      •  Introduction
        • An Introduction to Unicode
      •  Determining your Character Encoding Needs
        • The Advanced Tools Module’s Character Encoding Requirements
        • When You Do Not Need the Internationalization Module
        • When You Do Need the Internationalization Module
        • Choosing the Appropriate String Class
      •  International Features of the Streams Package
        •  Using the Streams Package without the Internationalization Module
          • Unicode-Based Stream Classes
          • Unicode Converter Classes
          • Example
        • Using the Streams Package with the Internationalization Module
      •  International Features of the Serial Package
        •  Using the Serial Package without the Internationalization Module
          • Compact Object Streams
        •  Using the Serial Package with the Internationalization Module
          • Converting from a Local Encoding to UTF-16
          • Converting from UTF-16 to a Local Encoding
•  Internationalization Module User’s Guide
  •  Chapter 1 Introduction
    • Welcome
    • Product Overview
    • Products and Services Information
  •  Chapter 2 Concepts
    • Overview
    • Basic Terminology
    •  Representing Text in Computers
      • Abstract Characters
      • Character Sets
      • Coded Character Sets
      • Character Encoding Forms
      • Character Encoding Schemes
      • Character Map
    •  The Unicode Standard
      • Unicode Coded Character Set
      • Unicode Character Encoding Forms
      • Unicode Character Encoding Schemes
    • The ISO-10646 Standard
    • Multilingual Text in C++
  •  Chapter 3 Character and String Processing
    • Overview
    • Representing Characters
    •  Character Properties
      • Valid Code Points
      • Surrogate Pairs
      • Character Blocks
      • Character Scripts
      • General Character Categories
      • Character Names
      • Character Directionality
      • Character Width
      • Combining Classes
      • Character Case
      • Character Mirroring
      • Numeric Values
    •  Representing Strings
      • RWBasicUString and RWCString
      •  Memory Management in RWBasicUString
        • Creating and Using Deallocators
        • Null Termination
      • RWUString and RWBasicUString
      • Creating an RWUString
      • Converting to Unicode
      • Converting from Unicode
      • Escape Sequences
      • String Length
      • Comparing Strings
      • Accessing SubStrings
    •  Iterating Over Strings
      • Accessing Code Points with Iterators
      • Modifying Code Points with Iterators
  •  Chapter 4 Conversion
    • Overview
    •  Character Encodings
      • Listing Encoding Names
      • Listing Encoding Name Aliases
      • Listing Encoding Name Standards
    •  Explicit Conversions
      • Creating Converters
      • Explicitly Converting to Unicode
      • Explicitly Converting from Unicode
      • Conversion Errors
      • Saving and Restoring the Error Response State
      • Resetting Converters
    •  Implicit Conversions
      • The Conversion Context Stacks
      • Creating Conversion Contexts
      • Implicitly Converting to Unicode
      • Implicitly Converting from Unicode
      • Bidirectional Conversions
  •  Chapter 5 Normalization
    • Introduction
    •  Character Equivalence
      • Canonical Equivalence
      • Compatibility Equivalence
    • Normalization Forms
    •  Using RWUNormalizer
      • Normalizing Strings
      • Detecting the Normalization Form of a String
  •  Chapter 6 Collation
    • Overview
    • Locale-Sensitive String Comparison
    •  Customizing a Collator
      • Finding Collation Elements
      •  Forming Collation Weights
        • Case Order
        • Punctuation Shifting
      •  Examining Collation Levels
        • Collation Strength
        • Case Level
        • French Collation
    •  Using Collation Keys
      • Using RWUCollationKey
      • Sorting Strings with Collation Keys
  •  Chapter 7 Boundary Analysis and Tokenizing
    • Overview
    •  Boundary Analysis
      • Creating an RWBreakSearch
      • Using an RWBreakSearch
      • Direct Queries
    •  Tokenizing
      • Creating an RWUTokenizer
      • Specifying Delimiters
      •  Extracting Tokens
        • Using the Function Call Operator
        • Using the nextToken() Method
  •  Chapter 8 Pattern Matching
    • Overview
    • Lexical String Searching
    •  Locale-Sensitive String Searching
      • Creating an RWUStringSearch
      • Iteration-Style Searches
      • Direct Queries
      • Search and Replace
    •  Regular Expression String Searching
      • A Note on Support by UTR Version Number
      • POSIX Extended Regular Expression Syntax
      •  Unicode Regular Expressions
        • Basic Unicode Regular Expression Extensions
        • Tailored Unicode Regular Expression Extensions
        • How to Use Tailored Regular Expressions
      • How to Create an RWURegularExpression
      • Searching for Pattern Matches
      • Manipulating Match Results
      • Replacing Pattern Matches
      • Iterating Over Pattern Matches
  •  Chapter 9 Error Handling and Debugging
    • Overview
    • Exceptions
    • Compiling in Debug Mode
  •  Chapter 10 Locales and Localized Resources
    • Overview
    •  Named Locales
      • Listing Language Codes
      • Listing Country Codes
      • Listing Available Locales
    •  Locale Objects
      • Creating Locales
      • Using Locales
      • The Default Locale
    •  Localized Resources
      • The Resource Hierarchy
      • Defining Resource Bundles
      • Compiling Resource Bundles
      • Packaging Resource Bundles
      • Retrieving a Resource Bundle
      • Accessing a Resource
  •  Chapter 11 Advanced Topics
    • Overview
    • Working in a Multithreaded Environment
    • Accessing ICU Constructs
  • Appendix A Glossary
•  XML Streams Module User’s Guide
  •  Chapter 1 Introduction
    • Welcome
    •  Product Features
      • The XML Streams Module Package
    •  Dependencies
      • Basic Software Dependencies
      • Optional Software Dependencies
      • Schema Dependencies
    • Products and Services Information
  •  Chapter 2 Using XML Streams
    • Overview
    • Types of Streams
    • When to Use XML Streams
  •  Chapter 3 A Simple XML Streams Use Case
    • Introduction
    • Use Case Description
    • Serialization Requirements
    •  Examining the Code
      • Declaring the Basic Classes
      •  Making the Basic Classes Serializable
        • Header File Changes
        • Source File Changes
      • Persisting the Serializable Objects
  •  Chapter 4 Enhanced Streams
    • Introduction
    •  The Difference Between Enhanced Streams and Basic Streams
      • Comparison Example of Basic XML Streams with Enhanced XML Streams
    •  Example
      • Example Discussion
      • Serializing the book Object to a File
      • Restoring the book Object
      • Examining the XML Output
  •  Chapter 5 Performing Transformations
    •  Introduction
      • Character-based C++ Transformations
      • Element-based Transformations
    •  Transforming your XML Documents
      • Overview of the Transformation Process
      • Adding Serialization Support
      •  Serializing the book Object to a File
        • For a Character-based C++ Transformation
        • For an Element-based C++ Transformation
      •  Restoring the book Object
        • For a Character-based C++ Transformation
        • For an Element-based C++ Transformation
      •  Examining the XML Output
        • For a Character-based C++ Transformation
        • For an Element-based C++ Transformation
    • Discussion
  •  Chapter 6 XSLT Transformations
    •  Introduction
      • Your XSLT Processor
      • The XSLT Transformation Procedure
    •  Creating the Objects and Streams
      • Defining a Transformation Object
      • Defining a Character Transformation Stream
      •  Defining an XSLT Transformation Stream
        • Defining the XSLT Transformation Input Stream
        • Defining the XSLT Transformation Output Stream
    •  Performing the Transformation
      • Serializing the book Object to a File
      • Restoring the book Object
      • Examining the XML Output
  •  Chapter 7 International Features of the XML Streams Module
    •  Introduction
      • An Introduction to Unicode
    •  Determining your Character Encoding Needs
      •  Deciding if You Need the Internationalization Module
        • When You Do Not Need the Internationalization Module
        • When You Do Need the Internationalization Module
      •  The XML Streams Package Character Encoding Requirements
        • Narrow Character Interfaces
        • Wide and Unicode Character Interfaces
    •  Using the XML Streams Package without the Internationalization Module
      • Choosing the Appropriate String Class Interface
      •  Converting to and from UTF-8 and UTF-16
        • Converting RWCStrings and RWBasicUStrings
        • Converting RWWStrings to and from UTF-8
    •  Using the XML Streams Package with the Internationalization Module
      • Output Stream Example
      • Input Stream Example

Essential Tools Module User's Guide

Using the XML Streams Package with the Internationalization Module