Introduction to SourcePro®
The SourcePro Perspective
Welcome
Features and Benefits
Product Formats
Software Requirements
Compatibility
Deprecated APIs
Undocumented APIs
Dependencies
3rd-Party Software Use
Open Source or Freely Licensed Code
SourcePro Documentation
Conventions
Typographic Conventions
Pathname Conventions
Class and Function Naming
Class Relationship Notation
Consulting Services and Training
Technical Support
To Obtain Technical Support
The SourcePro Architecture
The SourcePro Organization
SourcePro Products and Modules
Packages and Class Groups
SourcePro Core
Definition
The Essential Tools Module
The Threads Module
The Advanced Tools Module
The XML Streams Module
The Internationalization Module
An Example Using the Essential Tools Module and the C++ Standard Library
An Example Using the Internationalization Module with the Threads Module and the C++ Standard Library
SourcePro DB
Definition
The DB Interface Module
The DB Access Modules
The DB XA Module
An Example Using the Threads Module and the DB Interface Module
SourcePro Net
Definition
The Essential Networking Module
The Internet Protocols Module
The Secure Communication Module
Example Using Modules from SourcePro Core, SourcePro DB, and SourcePro Net
SourcePro Analysis
Definition
The Essential Math Module
The Linear Algebra Module
The Business Analysis Module
The Currency Module
An Example Using the Linear Algebra and Essential Tools Modules
Appendix A, 3rd‑Party Licenses
OpenSSL/SSLeay Licenses
OpenSSL 1.1.1
OpenSSL 3.0.3
ICU Licenses
ICU 58.2
ICU 68.1
CLAPACK and BLAS
Snappy
Aladdin Enterprises MD5 License
BSD-3 Clause
Author Attibution
Installing and Building Your SourcePro® Products
Introduction
Welcome
What is RCB?
Creating Buildspecs
Executing Buildspecs
Features
Wizard-Like Interface
Built-In Intelligence
Understanding Your Environment
Selectable Component Set
Sequential Multiple Builds
Single, Multipurpose Buildspace
Three Selectable Build Activities
Command Line Interface
Flexible Naming Conventions
Reusable Data for Building Applications
3rd-Party Software Use
Resources
Products and Services Information
Quick Start
Getting Started
Installing RCB and Components
License Key File
Installing RCB and SourcePro Components
The Buildspace Directory
Starting RCB
Creating Buildspecs
Select a Buildspec
Specify a Buildspace
Select Components
Specify Build Options
Submit Buildspec to the Build Queue
Consider Build Queue Options
Buildspecs in the Build Queue
Buildspecs Outside the Build Queue
Navigation Buttons
Build Output Screen
Executing Buildspecs
License Message
Executing a Buildspec from the GUI
Executing a Buildspec from the Command Line
Running the Build Manager from the Command Line (Method 1)
Running make from the Command Line (Method 2)
Results of Running a Buildspec
Directory Structure
Directory Naming
Directory Structure Variations
Build Report
Keyboard Shortcuts
Accelerator Keys
Navigating Through the Items on a Screen
“Clicking” Buttons Without the Mouse
Checkbox and Radio Button Selection and Deselection
Shortcuts Specific to the Component Selection Screen
Dropdown Menus
Dismissing the Help Window
Limitations
UNC Path Incompatibility
Launching Multiple RCB Instances on Windows
Known Problems
Buildspec Details
Introducing Buildspecs
Working with Buildspecs
What is a Buildspec?
Common Buildspec Mistakes
Changing Answers and Accidentally Creating a New Buildspec
Accidentally Overwriting a Buildspec
Modifying a Buildspec Without Changing Its Name
Migrating from an Earlier RCB Version
Answering Questions to Create a Buildspec
Question List
How RCB Determines Which Questions to Ask
Context-Sensitive Q&A
Unavailable (Greyed-out) Answers
Options Dialog
Advanced Options
Welcome Screen
General Buildspec Questions
Select Buildspec
Select Buildspace
Local Buildspace
Copying Buildspecs
Export Buildspace
Select Components
Dependency Checking
Select Build Action
Select Operating System
Select Compiler
Select Dialect
Select Bitwidth
Select Linking
Select Threading
Select Debugging
C++ Standard Library Selection Screen
Select Compile and Link Options
Custom Compile Flags
Custom Executable Link Flags
Custom Library Link Flags
Select Naming Convention
Naming Conventions
Select Clean Options
Prebuild Clean Optons
Postbuild Clean Options
Module-Specific Questions
Essential Tools Module
Snappy Version
RWCString and RWWString Implementation
Requiring Four-Digit Years
Internationalization Module
ICU Selection
ICU Directory Path
Threads Module
Tracing Question
Performance Option (Windows)
Secure Communication Module
Library Location
SourcePro DB Access Modules
DB Access Modules
Microsoft SQL Server Access Module
Rerunning Example Builds After Correcting DB Connection Information
XA Module of SourcePro DB
Essential Math Module
Working with Buildspaces
Buildspace Issues
Multiple Buildspaces
Using an Imported Buildspec
Using the Export Buildspace Feature
Cleaning Up Buildspaces
Invoking rwclean
Deleting All Buildspace Files
Deleting Buildspace Files According to Buildtype and Module
Command Line Syntax
Examples Using rwclean
Compiling Issues
Invoking RCB's Makefiles from the Command Line
Example
Appendix A, Glossary
Appendix B, Third‑Party Licenses
Apache Software License v. 1.1
Sun Binary Code License 2.0
OpenJDK Java Runtime Environment
Java Runtime Environment 1.8.0.23
Appendix C, Build Tag Conventions
Summary Tables
Supported Conventions
The RCB Convention
Build Tags
Rogue Wave Component Builder (RCB)
PART I General Build Information
The Basics
The Four Basic Build Requirements
More About Include Path
More About Linking to Libraries
More About _RWCONFIG
More About System Requirements
Products and Services Information
Additional Topics
Procedure for Building Your Applications
Dueling Compiler Flags
Working With Dynamic Binding
Linking to Required Libraries
Running the Application
Windows requirements
UNIX requirements
Using Rogue Wave Static Libraries with MSVC
PART II Module-Specific Build Information
Essential Tools Module Build Information
Google Snappy
Location
Required Include Paths
Required Link Libraries
Linking to Snappy on Windows
Linking to Snappy on UNIX
Internationalization Module Build Information
International Components for Unicode (ICU)
Location
Required Include Paths
Required Link Libraries
The Default Locale
DB Interface Module Build Information
Required Link Libraries
Statically-linked Applications
Dynamically-linked Applications
Runtime Issues
Statically-linked Applications
Dynamically-linked Applications
Setting Environment Variables
Setting Environment Variables in Windows
Setting Environment Variables in UNIX
Establishing Connectivity
Establishing a Database Connection
Establishing a C Connection to the Database
Establishing a Connection Between the DB Interface Module and the Database Server
Secure Communication Module Build Information
OpenSSL
OpenSSL Location
Required Include Paths
Required Link Libraries
Linking to OpenSSL on Windows
Linking to OpenSSL on UNIX
Essential Math Module Build Information
Issues to Consider
Building the Essential Math Module Library
Building Applications that Depend on the Essential Math Module
Windows
NetLib CLAPACK Library
MKL BLA Library
UNIX
Linux
Oracle Developer Studio on Solaris or Linux
All Other Modules
No Module-Specific Explanations Needed
PART III Appendices
Appendix A, Build Tag Conventions
Summary Tables
Supported Conventions
The RCB Convention
Build Tags
Appendix B, Location of Key Files
Rogue Wave Buildspace
Essential Tools Module User's Guide
Introduction
Overview
Features and Benefits
Examples
Products and Services Information
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
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
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
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
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
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
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
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
The Debug Version of the Essential Tools Module
File System Classes
Introduction
RWFile
Example
RWFileStat
Construction
Example
RWDirectoryIterator
Flat Iteration Example
Recursive Iteration Example
RWFileManager
Construction
Member Functions
Example
RWBTreeOnDisk
Construction
Example
Scope Guard Classes
Introduction
RWScopeGuard
Construction
Member Functions
RWTRefHolder<T>
Why Use RWTRefHolder<T>
A Note on Pointer and Reference Parameters
Example
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
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
Using the Decision Trees
Decision 1: Determine the Collection Type
Set
Map
Vector
List
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
Ordered 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
Introduction
Welcome
Packages and Libraries
Examples
Products and Services Information
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
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
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
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
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
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
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
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
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
Introduction
Overview
Examples
Products and Services Information
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
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
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
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
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
Introduction
Welcome
Product Packages and Libraries
Examples
Products and Services Information
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
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
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
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
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
The Types Package
Introducing the Types Package
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
Introduction
Welcome
Product Overview
Products and Services Information
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++
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
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
Normalization
Introduction
Character Equivalence
Canonical Equivalence
Compatibility Equivalence
Normalization Forms
Using RWUNormalizer
Normalizing Strings
Detecting the Normalization Form of a String
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
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
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
Error Handling and Debugging
Overview
Exceptions
Compiling in Debug Mode
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
Advanced Topics
Overview
Working in a Multithreaded Environment
Accessing ICU Constructs
Appendix A, Glossary
XML Streams Module User’s Guide
Introduction
Welcome
Product Features
The XML Streams Module Package
Dependencies
Basic Software Dependencies
Optional Software Dependencies
Schema Dependencies
Products and Services Information
Using XML Streams
Overview
Types of Streams
When to Use XML Streams
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
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
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
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
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
DB Interface Module User’s Guide
PART I Introduction
Introduction
Overview
Features and Benefits
Comprehensive Functionality
Consistency Across Different Databases
Enhanced Performance
Module-Specific Software Requirements
Compatibility
Dependencies
Database Connectivity
Database Knowledge
Examples
Products and Services Information
Design Overview
Basic Architecture
Interface and Implementation Classes
Database-Dependent and Database-Independent Interface Classes
Producers and Products
Reference Semantics
Memory Allocation
Information Flow
Class Overview
Kinds of Classes
Datatype Classes
Database Classes
Data Manipulation Classes
Expression Classes
Bulk Classes
Open SQL Classes
Utility and Diagnostics Classes
Callback Classes
Summary of Classes
Member Function Conventions
PART II Using the Basic Features
The Database Classes
Before You Log On
Getting a Connection
Managing Connections
RWDBDatabase and RWDBConnection
Explicit and Implicit Connections
Connection Pools
Alternatives for Managing Connections
Transaction Processing with RWDBConnection
Transaction Control and Locking
Tables
Database Tables
Reading Tables: Class RWDBReader
Overloading the Extraction Operator
Derived Tables
Memory Tables
Result Tables
Summary
Table Constraints
Table Constraints Classes
Column Level Constraints
Not Null Constraints
Default Column Constraints
Identity Column Constraints
Table Level Constraints
Primary Key Constraints
Foreign Key Constraints
Unique Table Constraints
Check Table Constraints
Working with Table Level Constraints
Creating Tables with Constraints
Adding or Dropping Constraints
Fetching Table Constraints
The Data Manipulation Classes
More on Basic Classes
Expressions, Criteria, and Assignments
Creating WHERE Clauses and Check Constraints
RWDBCriterion and RWDBExpr
Assigning New Values to Table Columns
Creating CASE Expressions
Simple CASE Expressions
Searched CASE Expressions
Summary
Selecting Data
Selecting Data from a Single Table
Joins
Outer Joins
Outer Join Constructs in the FROM Clause (ANSI-Compliant)
Outer Join Constructs In the WHERE Clause (ANSI-Noncompliant)
Composing FROM Clause
Ordering and Grouping
Aggregates, Expressions, and Functions
Self-Joins
Subqueries
Summary
Inserting Data
Inserting Values
Inserting with a Selector
Inserting with a Reader
Getting Results from an Inserter
A Note About Connections
Summary
Updating Data
Subqueries and Correlated Updates
Use of Table Tags when Updating
Deleting Data
Subqueries and Correlated Deletes
Use of Table Tags when Deleting
Stored Procedures
Instantiating RWDBStoredProc
Type and Error Checking in RWDBStoredProc
Complex Stored Procedure Example
Cursors
Instantiating an RWDBCursor
Bind Operations
Fetch Operation
Insert Operation
Delete Operation
Update Operation
asString() Methods in the Data Manipulation Classes
Summary
The Error Model
Overview
Checking Status with Class RWDBStatus
Error Handlers
Exceptions
More About Error Handlers
Kinds of Errors
Capturing Database-Dependent Information
More About isValid()
Defining a Valid Object
Making Unusable Objects Usable
Summary
The Data Model
The Problem of Diverse Data Types
The SourcePro DB Solution
The Database Layer
The Value Layer
RWCString
RWDateTime
Example
Constructors
RWTimeTuple and RWTimeTupleOffset
RWDBDuration
RWDBBlob
RWDecimalPortable
RWDBValue
Internationalization Data Types
The Pointer Layer
Summary
PART III Using Advanced Features
Bulk Reading and Writing
The Bulk Classes
Examples with Bulk Classes
Bulk Read and Writes
Bulk Classes and RWDBBlob
Caching
Caching and Performance
A Database Client Perspective
Caching When Inserting and Reading Data
Caching with RWDBInserter
Caching with RWDBReader
Restrictions On Caching with RWDBReader, RWDBInserter
Result Schema Caching
Metadata Caching and the Cache Manager
Types of Cacheable Data
Using the Cache Manager
Error Handling in the Cache Manager
Keeping the Cache Up-To-Date
The In-Memory Cache Manager
Implementing a Cache Manager
Example
Database and Connection Callbacks
Callback Functionality
Callback Locations
Callback Classes
Implementing Callbacks
Implementing Database Callbacks
Providing a Password using connParams()
Implementing Connection Callbacks
Callback Sequence
Callback sequence for a database callback and explicit connection callback
Callback sequence for a database callback producing a connection callback
Callback Example
Multithreading
The DB Interface Module and Multithread Safety
Levels of Multithread Support
Sharing Objects of the DB Interface Module Among Threads
Sharing an RWDBConnection
Database-Independent Classes
The Guard Class with Templates
Guard Classes Without Templates
Portable Guard Classes
Asynchronous Usage
Definition
Architectural Overview
Handling Asynchronous Call Completions
RWDBStatus Behavior in the Asynchronous Context
Asynchronous Usage Example
Handling C++ Datatype Returns from an Asynchronous Call
Asynchronous Calls in the DB Interface Module
Running Many Asynchronous Calls on a Single RWDBConnection
Performance Issues
Asynchronous RWDBReaders
Internationalization
Definition
Character Sets
National Character Sets and C++ Data Types
RWBasicUString
RWWString
RWDBMBString
RWCString
Data Definition Language
Using Schema Information from Result Tables
Data Formatting
RWDateTime
RWDate
RWDecimalPortable
Formatting Raw Numbers
PART IV Using Open SQL
Defining Open SQL
An Alternative API
Who Should Use Open SQL
A Summary of the Open SQL Classes
Open SQL and the Standard API
Using the Open SQL Classes
Class RWDBOSql
Creating an RWDBOSql Instance
Providing an SQL Statement
Statement Type Hint
Executing the SQL Statement
Error Handling
Obtaining the Results
Class RWDBTBuffer<T>
Instantiating RWDBTBuffer
Memory Management in RWDBTBuffer
Output Binding and Fetching Using RWDBTBuffer
Using RWDBTBuffers for Input
Bulk/Array Input
The Data Callback Classes
Fetching Data
Inserting Data
Implementing a Custom Callback Class
Implementing onFetch()
Implementing onSend()
Implementing getLength()
Using a Custom Callback Class with Open SQL
Fetching Data with a Custom Callback Class
Inserting Data with a Custom Callback Class
Other Resources
RWDBMultiRow
Using RWDBMultiRow for Ad Hoc Queries
Obtaining Data from RWDBMultiRow
PART V The Tutorials
A Tutorial Overview
Introduction
List of Tutorials
Setting up the Tutorials
The Tutorial Model
Retrieving Data from a Table
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVContactRepository Constructor
VVContactRepository::mailingLabels
operator>>() for VVContact
Retrieving Data Selectively
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVContactRepository::mailingLabels
VVContactRepository::reader
Conclusion
Inserting Data into a Table
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVContactRepository::insert
operator<<() for VVContact
Conclusion
Inserting and Updating Data
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVVideoRepository::updateStock
Conclusion
Deleting Rows from a Table
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVContactRepository::remove
Conclusion
A Complicated Query
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
Conclusion
Updating Data in Multiple Tables
Goal of This Tutorial
Overview of This Tutorial
Running the Program
Checking the Output
The Program
The Main Routine
VVInvoice::addRental
VVVideoRepository::find
VVVideoRepository::update
Appendix A, Glossary
Terms and Definitions
DB XA Module User’s Guide
Introduction
Overview
Product Features
Module-Specific Software Requirements
Establishing Connectivity with the DB XA Module
Products and Services Information
Overview
The Abstract X/Open DTP Model
The DB XA Module in the X/Open DTP Environment
Class Overview
The DB XA Module Classes
Database Class Enhancements
RWDBDatabase
RWDBConnection
Using the DB XA Module Database Classes
Database Classes in the DB XA Module
Getting Connected with the DB XA Module
Databases and Connections
Managing Connections
Transaction Processing
Using the DB Access Modules With XA Functionality
Overview
Oracle OCI Access Module
Configuring the Resource Manager
Switch Table
Databases and Connections
RWDBDatabase Objects
RWDBSystemHandle and RWDBEnvironmentHandle
Sybase Access Module
Configuring the Resource Manager
Switch Table
Databases and Connections
RWDBDatabase Objects
RWDBConnection Objects
The Contents of RWDBSystemHandle
The Contents of RWDBEnvironmentHandle
DB2 CLI Access Module
Configuring the Resource Manager
Switch Table
Databases and Connections
RWDBDatabase Objects
The Contents of RWDBSystemHandle
The Contents of RWDBEnvironmentHandle
Writing Applications with the DB XA Module
Overview
Designing Programs for the X/Open Environment
Moving from the DB Interface Module to the DB XA Module
Using Data Definition Language
Using SQL Statements through RWDBConnection::executeSQL()
Mixing XA and Non-XA Connections
Appendix A, Glossary
Terms and Definitions
DB Access Module for DB2 CLI User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of DB Interface Module Datatypes
Expressions
Global Functions
Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Cursors
Caching
Inserter Caching
Reader Caching
BulkReader and BulkInserter
Support
Updater and Deleter
Use of Table Tags
Stored Procedures
Creating Stored Procedures
Executing Stored Procedures
Instantiating an RWDBStoredProc Using Schema Data
Internationalization
Data Bindings
Limitations
Metadata
Use of RWWString in Unicode Applications
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Error Messages
Errors and RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Input Binding of Data
System and Environment Handles to DB2 CLI Specific Resources
Open SQL and DB2 CLI
Placeholder Syntax
RWDBDataCallback and Open SQL
Piece Size Setting
RWDBDataCallback::getLength()
Stored Procedures and RWDBDataCallback
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Executing Cancel in Open SQL
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
Using Static Libraries with DB2 CLI Access Module and MS SQL Server Module
Callbacks
Appendix A, System Tables and Functions
System Tables
System Functions
DB Access Module for Microsoft SQL Server User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of Datatypes
Expressions
Global Functions
Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Cursors
Caching
Inserter Caching
Reader Caching
BulkReader and BulkInserter
Support
Updater and Deleter
Use of Table Tags
Stored Procedures
Creating Stored Procedures
Executing Stored Procedures
Instantiating an RWDBStoredProc Using Schema Data
Internationalization
Prerequisites
Data Bindings
Limitations
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Error Messages
Errors and ODBC Conformance
Errors and RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Using Text and Image Data
Input Binding of Data
System and Environment Handles to Microsoft SQL Server Specific Resources
Open SQL and Microsoft SQL Server ODBC
Placeholder Syntax
RWDBDataCallback and Open SQL
Piece Size Setting
RWDBDataCallback::getLength()
Stored Procedures and RWDBDataCallback
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Executing Cancel in Open SQL
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
Using Static Libraries with MS SQL Server and DB2 CLI Access Modules
Callbacks
Appendix A, System Tables and Functions
System Tables
System Functions
DB Access Module for MySQL User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of Datatypes
Expressions
Global Functions
Outer Joins
Full Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Check Constraints
Adding or Dropping Constraints
Cursors
Caching
BulkReader and BulkInserter
Updater and Deleter
Use of Table Tags
Stored Procedures
Creating Stored Procedures
Executing Stored Procedures
Instantiating an RWDBStoredProc Using Schema Data
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Internationalization
Error Messages
Errors
Errors and RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Input Binding of Data
System and Environment Handles to MySQL Specific Resources
Open SQL and MySQL
Placeholder Syntax
RWDBDataCallback and Open SQL
Executing Cancel in Open SQL
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
Callbacks
Appendix A, System Tables
System Tables
DB Access Module for ODBC User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of Datatypes
Expressions
Table and Column Names
Global Functions
Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Unique and Check Constraints
Cursors
Caching
Inserter Caching
Reader Caching
BulkReader and BulkInserter
Updater and Deleter
Use of Table Tags
Stored Procedures
Instantiating an RWDBStoredProc Using Schema Data
Transactions
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Internationalization
Prerequisites
Data Bindings
Limitations
Error Messages
Errors and ODBC Conformance
Errors and RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Input Binding of Data
System and Environment Handles to ODBC Specific Resources
Open SQL and ODBC
Placeholder Syntax
RWDBDataCallback and Open SQL
Piece Size Setting
RWDBDataCallback::getLength()
Stored Procedures and RWDBDataCallback
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Executing Cancel in Open SQL
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
Callbacks
Appendix A, System Views
System Views
DB Access Module for Oracle OCIUser’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of Datatypes
Expressions
Global Functions
rwdbCast()
Outer Joins
Table and Column Constraint Limitations
Identity Column Constraints
Cursors
Caching
Updater and Deleter
Use of Table Tags
BulkReader and BulkInserter
Stored Procedures
Creating a Stored Procedure
Input/Output Parameters and Result Sets
Instantiating an RWDBStoredProc Using Schema Data
Internationalization
Prerequisites
Environment Variables
Database NLS_NCHAR_CHARACTERSET
Database Length Semantics
Data Bindings
Limitations
Using Oracle Datatypes NCHAR and NVARCHAR2
Metadata
Using RWWString in Unicode Applications
Using RWDBMBString in Unicode Applications
Date Formats
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Error Messages: Contents of RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Large Character and Binary Data
Input Binding of Data
Output Binding of Data
System and Environment Handles to Oracle OCI Specific Resources
Open SQL and Oracle OCI
Placeholder Syntax
Supported Datatypes for Output Binding
RWDBDataCallback and Open SQL
Piece Size Setting
RWDBDataCallback::getLength()
Stored Procedures and RWDBDataCallback
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Executing Cancel in Open SQL
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
OCIStmts
Simultaneous Processing of Results on an RWDBOSql Object When Used for Stored Procedure
Callbacks
Appendix A, System Tables, Views, and Functions
System Tables
System Views
System Functions
DB Access Module for PostgreSQL User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Examples of Opening a Database
Datatypes
Restrictions on the Use of Datatypes
Serial Columns in Tables
Expressions
Global Functions
Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Cursors
Caching
Inserter Caching
Reader Caching
Updater and Deleter
BulkReader and BulkInserter
Stored Procedures
Creating a Stored Procedure
Executing a Stored Procedure
Instantiating an RWDBStoredProc Using Schema Data
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Internationalization
Error Messages
Errors and RWDBStatus
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Input Binding of Data
System and Environment Handles to PostgreSQL Specific Resources
Open SQL and PostgreSQL
Placeholder Syntax
RWDBDataCallback and Open SQL
Stored Procedures and Open SQL
Out Parameters and Return Values
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
Open SQL Stored Procedure Examples
Executing Cancel in Open SQL
Callbacks
Handling SQL Escape Strings
Appendix A, System Tables and Functions
System Tables
System Functions
DB Access Module for Sybase User’s Guide
Introduction
Overview
Technical Information
Introduction
Databases and Connections
Datatypes
Restrictions on the Use of Datatypes
Expressions
Global Functions
Joins
Outer Joins
Table and Column Constraint Limitations
Identity Constraints
Caching
Inserter Caching
Reader Caching
Cursors
Updater and Deleter
BulkReader and BulkInserter
Using an RWDBBulkInserter
Stored Procedures
Creating a Stored Procedure
Executing Stored Procedures
Instantiating an RWDBStoredProc Using Schema Data
Internationalization and Localization
Prerequisites
Changing Locales on the Fly
Data Binding
Limitations
RWWString
Date Formats
Transaction Processing
Setting Isolation Levels
Using Transaction Control Methods
Error Messages: Contents of RWDBStatus
Reporting Errors from Client-Library and CS‑Library
Reporting Errors from Adaptive Server
Result Sets
Simultaneous Processing of Results from Multiple Statements Using the Same Connection
Text and Image Data
Input Binding of Data
Output Binding of Data
System and Environment Handles to Sybase Specific Resources
Open SQL and Sybase Open Client Client-Library
Placeholder Syntax
Supported Datatypes for Input Binding
Supported Datatypes for Output Binding
Bulk Inserts and Bulk Input Binding
RWDBDataCallback and Open SQL
Piece Size Setting
Changing the Maximum Fetch Size
RWDBDataCallback::getLength()
Stored Procedures and RWDBDataCallback
Stored Procedures and Open SQL
Sequence of Fetching Result Sets and Out Parameters
Simultaneous Result Processing
Simultaneous Results Processing of RWDBOSql Objects on the Same Connection
Simultaneous Results Processing of High-Level Objects of the DB Interface Module Using the Same Connection
Executing Cancel in Open SQL
Open SQL Examples
An Open SQL Insert Example
Open SQL Query Examples
An Open SQL Stored Procedure Example
Callbacks
Appendix A, System Tables, Functions and Variables
System Tables
System Functions
System Variables
Essential Networking Module User’s Guide
PART I Overview of the Essential Networking Module
Introduction
Welcome
Examples
Products and Services Information
Basic Concepts
Product Definition
Operation
A Simple Code Example
A Comparative Code Example
Key Abstractions
About Portals
RWSocketPortal
RWPortal as a Base
About Sockets
RWSocket
RWSocketListener
Relationship to Other Modules
Essential Networking and SourcePro Net
Essential Networking and the SourcePro Product Line
Product Organization
Classes
Header Files
Architecture
Foundation
Communication Adapters Layer
Portal Layer
Communication Services Layer
Class Hierarchies
PART II The Networking Package
Portals
Using Portals to Write Client Programs
Writing a Simple Client
Handling Errors
Reading From a Portal
Understanding the Portal and Implementation Classes
Using Channel-specific Portal Classes
Streams
Using Iostreams
Using Iostream Classes for Formatted Output
Using Iostream Classes for Formatted Input
Understanding the Architecture of a Portal Stream
Understanding Virtual Streams
Using Virtual Streams
Constructing a Portable ASCII Virtual Stream for Output
Constructing a Binary Virtual Stream for Input from a Portal
Creating Chains of Objects
Socket Addresses
Introduction
The Socket Address Classes
Understanding the Base Class
Controlling Network Access
Printing Socket Addresses
Using Generic Socket Addresses
Constructing Generic Addresses
Understanding How RWSockAddr Is Implemented
Using Internet Addresses
Constructing a Host
Building Internet Addresses
Using IPv6 Addresses
Constructing a Host
Building IPv6 Addresses
Using Socket Types
Understanding Socket Types
Representing a Socket Type
The Berkeley Sockets Adapter
Introduction
Using RWSocket
Closing Sockets and Avoiding Resource Leaks
Using Socket Portals
Using Communication Services with Sockets
Socket Multiplexing
Working with Socket Attributes
Using rwSocketSelect
Examples
The Windows Socket Adapter
Introduction
Initializing and Cleaning Up
Using the Networking Package in Global Objects
Socket Security
Servers
Introduction
A Simple Synchronous Server
Socket Listeners
Complex Servers
Appendix A, Glossary
Internet Protocols Module User’s Guide
PART I Overview of the Internet Protocols Module
Introduction
Welcome
Packages in the Internet Protocols Module
Examples
Products and Services Information
Product Overview
Introduction
Definitions
Architecture
Reference-counting and the Handle-Body Implementation
Protocol Command Sequence
Multithreading and IOUs
RWTIOUResult
RWTIOUResult Callbacks
RWTIOUResult Polling
A Common Multithreading Mistake
PART II Packages of the Internet Protocols Module
The Internet Basics Package
Introduction
Classes in the Internet Basics Package
Header Files
Internet Basics Class Hierarchy
About RWDirEntry
About Protocol Replies
About RWStreamCoupler
About RWURL
The FTP Package
Introduction
Classes in the FTP Package
Header Files
FTP Class Hierarchy
About FTP Protocol Replies
Using Active and Passive Clients
Sending Generic Protocol Commands
File Retrieval: Using the FTP Agent (Part I)
File Retrieval: Using the FTP Agent (Part II)
FTP Command Demo: Using the FTP Client
The HTTP Package
Introduction
Classes in the HTTP Package
Header Files
HTTP Class Hierarchies
Using the HTTP Classes
Connecting to the Server
Creating a Request
Sending a Request
Retrieving a Reply
Interpreting the Reply
Bringing it All Together
Advanced Topics
Additional HTTP Methods
Specifying a Custom Message-Body Handler
Downloading Part of a Document
Adding and Removing Headers
Adding a Maximum Wait to Requests
Sending Requests through HTTP Proxies
Persistent Connections and Pipelined Requests
HTTP and International Documents
The POP3 Package
Introduction
Classes in the POP3 Package
Header Files
POP3 Class Hierarchy
About Protocol Replies
Saving a Mail Message to a File
Checking for the End of a Mail Message
Mail Retrieval: Using the POP3 Client
The SMTP Package
Introduction
Classes in the SMTP Package
Header Files
SMTP Class Hierarchy
About Protocol Replies
Closing the Mail Transfer Session
Mail Sender: Using the SMTP Agent
The MIME Package
Introduction
Classes in the MIME Package
Header Files
Relationship to Transport Protocols
Approach to Validating Messages
MIME Class Hierarchy
MIME Basics
Part and Message
Part Structure
MIME Headers
Part Body
The MIME Package Representation of a Message
Using the MIME Package
Preparing Data
Create an RWCString
Convert Text to Canonical Form
Encode the Data
Creating a Simple MIME Part
Create Headers for the Part
Create an RWMimePart
Add the Headers to the Part
Add the String to the Part
Create a MIME String
Program: Creating a Simple MIME Message
Creating a Multipart MIME Part
Create Parts
Create Headers for a Multipart
Create an RWMimeMultipart
Add Each Part
Add Headers to the Part
Create a MIME String
Program: Creating a Multipart MIME Message
Processing a MIME Part
Receive the Part as a String
Create a MIME Part
Fill the MIME Part From the String
Retrieve the Headers as Necessary
Process the Body
Simple MIME Parts
Multipart MIME Parts
Program: Processing a Simple MIME Message
Program: Processing a Multipart MIME Message
Advanced Example
MIME Package Advanced Topics
Using the MIME Headers Effectively
The MIME-Version Header
The Content-Type Header
The Content-Transfer-Encoding Header
The Content-ID Header
The Content-Description Header
The Content-Location Header
The Content-Disposition Header
Part Body
Constructing MIME Part Bodies
Canonical Form
Multipart Bodies
Transfer Encodings
Identity Encodings
Base 64 Encoding
Quoted-Printable Encoding
MIME and Internationalized Messages
Secure Communication Module User’s Guide
PART I Overview of the Secure Communication Module
Introduction
What Is the Secure Communication Module?
Packages in the Secure Communication Module
Module-Specific Software Requirements
Cryptographic Library Dependency
Installing the Packages
Assumptions
Examples
Products and Services Information
Product Overview
Understanding Secure Communication
The Secure Sockets Package
The HTTPS Package
Concepts
PART II Secure Sockets Package
Overview of the Secure Sockets Package
Introduction
Classes in the Secure Sockets Package
Header Files
Secure Sockets Package Class Hierarchy
Using Secure Sockets
Getting Started with Secure Sockets
Writing a Client Program That Uses RWSecureSocket
Writing a Client Program That Uses RWSecureSocketPortal
Writing a Server Program That Uses RWSecureSocket
Writing a Server Program That Uses RWSecureSocketPortal
About the Keys and Certificates in the Example Programs
Developing Secure Applications
Writing New Secure Sockets Applications
Porting Existing Networking Package Applications to the Secure Sockets Package
Obtaining Certificates
Obtaining Trusted Certificates to Verify Other Certificates
Obtaining Certificates to Identify a Specific Entity
Using Hard-Coded Keys and Certificates
Initializing the Secure Sockets Package
Seeding the Random Number Generator
Global Objects and the Secure Sockets Package Initialization
Creating the Secure Socket Context
Initializing the Context to Perform Server Authentication Only
Initializing the Context to Perform Both Client and Server Authentication
Constructing a Certificate
Checking the Validity of a Certificate
Using RWSecureSocket, RWSecureSocketPortal, and RWSecureSocketListener
Advanced Topics
Using RWPortalIStream and RWPortalOstream
Using RWAsymmetricKey
Using Encrypted Keys
Handling Exceptions
Using the Secure Sockets Callbacks
Password Callback
Certificate Verification Callback
Handshake Information Callback
Client Certificate Callback
Reusing Sessions
Implementing Both Client and Server Authentication
Client Example
Server Example
Mixing Calls to the Secure Sockets Package with Calls to the Cryptographic Library
Handling Errors from the Cryptographic Library
Secure Socket Multiplexing
Working with Secure Socket Attributes
Using RWSecureSocketAttribute
Using rwSecureSocketSelect
Multithreading, the Handle-Body Idiom, and the Secure Sockets Package
Security Issues
PART III HTTPS Package
Overview of the HTTPS Package
Introduction
Classes in the HTTPS package
Header Files
HTTPS Package Class Hierarchy
Using HTTPS
Getting Started with HTTPS
Using RWHttpAgent to Retrieve a Document Securely
Using RWHttpsSecureSocketClient to Retrieve a Document
Developing HTTPS Applications
Connecting Through a Proxy
Using the Security Callbacks
Certificate Name Check Callback
Certificate Name Mismatch Callback
Callbacks
Supplying Your Own Callbacks
Writing a Callback
Switching to the Default Callback
Using the HTTP CONNECT Method with the HTTPS Package
PART IV FTPS Package
Overview of the FTPS Package
Introduction
Classes in the FTPS Package
Header Files
FTPS Package Class Hierarchy
Using FTPS
Developing an FTPS Application
About FTPS Protocol Replies
Using the FTPS Package
PART V Resources
Appendix A, RWSocket & RWSecureSocket
Functions That Do Not Appear in the Secure Sockets Package
Functions That Are Deprecated
Appendix B, Bibliography
References
Essential Math Module User’s Guide
Introduction
Welcome
Product Features
Products and Services Information
Templatized Collection Classes
Templates Defined
Pros and Cons of Templates
Template Specializations
Nonstandard Numeric Types
Defining a New Numeric Type
Adding New Numeric Types
Modifying the Numeric Trait Information
Adding Global and Specialized Functions
Iterators
Uses of Iterators
Vector, Matrix, and Array Classes
Overview
Some Simple Examples
Vectors
Matrix Example
An Array Example
Data and Views
Copy Constructor
Assignment
Construction Versus Assignment
Function reference()
Vector Copies
Subscripting
Subscripting with Character Strings
Advanced Subscripting
Picks
Arrays of Signed and Unsigned Chars
Data Storage Schemes
High Dimension Arrays
FFT Servers
Overview
Transforms of Real Sequences
Transforms of Even and Odd Sequences
Linear Algebra Classes
Overview
LU Factorization
Condition Number
Statistics Classes
Random Number Generators
Class Histogram
Class LeastSqFit
Persistence
Overview
A Simple Example Using Streams
Technical Notes
Errors
Violated Preconditions
Invalid Input
Asynchronous Errors
Exception Hierarchy
Error Numbers and Messages
Efficiency
Slices
Overall Efficiency
Basic Linear Algebra Package
Examples
Overview
Example Using the Vector Classes
Example Using the Matrix Classes
Example Using the FFT Server Class
Type Conversion Example
Example with saveOn()and restoreFrom()
Class Derivation Example
Linear Algebra Example
Example with Multiple Inheritance and Runtime Binding
Random Number Generator Example
User-Defined Type Example
Business Analysis Module User’s Guide
Introduction
Welcome
Product Features
Products and Services Information
Library Architecture
Components
Regression Classes
Parameter Calculation Classes
The Base Calculation
Model Selection Classes
Definitions
Note
Multiple Linear Regression
Parameter Calculation by Least Squares Minimization
Model Variance
Parameter Dispersion (Variance-Covariance) Matrix
Significance of the Model (Overall F Statistic)
p-Value
Critical Value
Significance of Predictor Variables
p-Values
Critical Values
Prediction Intervals
Logistic Regression
Parameter Calculation
Parameter Variances and Covariances
Significance of the Model
G Statistic
Pearson Statistic
Hosmer-Lemeshow Statistic
Parameter Significance (Wald Test)
p-Values
Critical Values
Model Selection
Definition
Model Selection Viewed As Search
Exhaustive Search
Forward Selection
Backward Selection
Stepwise Selection
Using the Classes
Overview
Regression Classes
Updating Parameter Estimates
Intercept Option
Parameter Estimate Classes
Regression Analysis Classes
Class RWLinearRegressionANOVA
Class RWLogisticFitAnalysis
Class RWLinearRegressionFTest
Parameter Calculation Classes
Calculation Methods for Linear Regression
RWLeastSqQRCalc
RWLeastSqQRPvtCalc
RWLeastSqSVDCalc
Calculation Methods for Logistic Regression
RWLogisticIterLSQ
RWLogisticLevenbergMarquardt
Writing Your Own Parameter Calculation Class
Using the Model Selection Classes
Selection Evaluation Criteria: Function Objects
A Detailed Example
Writing Your Own Function Objects
Currency Module User’s Guide
Introduction
Welcome
Product Features
Products and Services Information
Product Overview
Currency Classes
Money Class
Money Calculator Class
Conversion Classes
Decimal Classes
Formatting Class
Strings in the Currency Module
Persistence
Classes in Currency Module
Currency Module Examples
Building and Running the Currency Examples
Using the Currency Class
Introduction
Currency Information Class
Collections of Currencies
Available Currencies
Initializing a Currency Book
Adding, Deleting, and Searching for Currencies
Money and Calculations
Introduction
Attaching a Currency to a Value
Same-Currency Calculations
Mixed-Currency Calculations
Setting the Conversion Policy
Setting the Precision and Rounding Method
Supported Money Decimal Types
Currency Conversions
Introduction
Exchange Rates and Exchange Rate Tables
Currency Exchange Classes
Currency Exchange Groups
Currency Exchange Factory
Performing Currency Exchanges
Creating Custom Exchange Objects and Groups
Class USDollarBaseExchange
Class USDollarBaseGroup
Using the Custom Classes
The Exchange Class Hierarchies
Decimal Classes
Overview
How Decimal Values Are Represented
Precision
Class RWMultiPrecisionInt<n>
RWMP1Int, RWMP2Int, and RWMP3Int Integer Types
Fixed and Floating Decimal Classes
Decimal Arithmetic
Special Values
Rounding
Conversions
Conversion from Integers and Strings
Conversion from Built-In Floating Point
Conversion to Built-In Types
Formatting for Output
Overview
Formatting Numbers
Using Pictures
Advanced Pictures
Code Positions in Pictures
Embedding Pictures in Sentences
Formatter Objects
Errors and Error‑Handling
Overview
Overflow Conditions
Inexact Conditions
Error-Handling
Installing an Inexact Error Handler
Installing an Overflow Error Handler
Error Objects
Technical Notes
Localization
Base 2 Representation of Decimal Fractions
Input Format Grammar
Multithread Safety
Linear Algebra Module User’s Guide
Introduction
Welcome
Product Features
Products and Services Information
Class Overview
The Class Concept
Kinds of Classes
A Note on Terminology
Class Groups of the Linear Algebra Module
Math Vector Classes
Sparse Matrix Classes
Factorization Classes
Symmetric Eigenvalue Decomposition Classes
Nonsymmetric Eigenvalue Decomposition Classes
Least Squares Factorization Classes
Decomposition Classes
Vectors and Matrices
Defining Vectors
Defining Matrices
Matrix Precision and Shape
Copy Constructors: References and Copies
Accessing Data
Individual Elements
Bounds Checking
Changing Elements with operator()()
val() and set()
Rows, Columns and Diagonals
Components of Complex Matrices
Direct Access to Data
Type Conversion
Converting Precisions
Converting Shapes
Submatrices
General Matrices
Leading Submatrices
Factorizations
Defining Factorizations
Solving a System of Equations
Error Checking
Solving Several Systems of Equations
Calculating the Determinant, Inverse, and Condition Number
Determinants
Matrix Inverses
Condition Number
Least Squares Factorizations
Defining the Problem
Solving a Least Squares Problem
Implementations Provided
Solving a Numerically Underdetermined System
Symmetric Eigenvalue Problems
Defining the Problem
Decomposition Object
Servers
Computing Selected Eigenvalues
Nonsymmetric Eigenvalue Problems
Defining the Problem
Decomposition Object
Servers
Schur Decompositions
Hessenberg and Balance Decompositions
Other Decompositions
Kinds of Decompositions
Singular Value Decomposition
SVD Server Objects
QR Decomposition and Complete Orthogonal Decomposition
Complete Orthogonal Decomposition
Technical Notes
Function operator()(int, int)
Matrix Entry Helper Classes
Helper Class Member Functions
Basic Linear Algebra Package
Introduction to SourcePro®
Basic Linear Algebra Package
RCB-Interface-Overview
RCB-Opening-Screen
rcbug-using-rcb_SpecifyABuildspace
rcbug-using-rcb_SelectComponents
Build-Options
Buildspec-Editing-Sessions-Summary
Build-Queue
Build-Specifications
Options-Dialog
rcbug-buildspecs_GeneralBuildspecQuestions
Buildspace-Selection-Screen
Component-Selection-Screen
Build-Action
Operating-System
Compiler
Dialect
Bitwidth
Linking
Threading
Debugging
Standard-Library-Options
Compile-and-Link-Options
Naming-Convention
Clean-Options
rcbug-buildspecs_ModuleSpecificQuestions
Essential-Tools-Module
Snappy-Version
Internationalization-Module
rcbug-buildspecs_ThreadsModule
Threads-Tracing
Threads-Performance-Option
Secure-Communication-Module
Secure-Communication-Library-Location
SourcePro-DB-Access-Modules
SQL-Server-Client
Essential-Math-Module
Basic-Linear-Algebra-Library-Selection