Contents

Preface

Guide to Distributed Computing

CommonPoint information set

Getting started

Taxonomy

Developer guides

Usage and tools guidelines

Application documentation

Documented sample programs and sample code

Installation and late-breaking information

Typographical conventions

Reading notation diagrams

part 1 - SQL Data Access Services

SQL Data Access Services Overview

SQL dialects

Vendor-specific connectivity layers

SQLDAS interfaces

Client interfaces

Base Client interface

Extended Client interface

Provider interface

Understanding record sources

Understanding how to use SQLDAS

SQLDAS usage considerations

Connections

Understanding connections

Connections classes

Connecting to a datastore

SQL Commands

Understanding SQL commands

SQL command classes

Understanding transactions

SQL clock classes

Base Client interface SQL commands

Using proper statement syntax

CREATE TABLE

DELETE FROM

DROP TABLE

SELECT

UPDATE

Querying a datastore

Copying a table

Base Client interface SQL commands

Record Sources Framework

Understanding record sources

Understanding records and record sources

Read-once stream versus random access

Understanding the data transfer protocol

Streaming

Record Source framework classes

Providing a record source

Record Classes

Macros

Templates

Catalogs

Understanding Catalogs

Catalog Classes

part 2 - Caucus framework

Caucus framework

Understanding the Caucus framework

Abstract interface features

Standard implementation features

Communication outside the caucus

Error recovery in caucuses

Caucus framework classes

Abstract caucus interface

Standard caucus implementation

Using the standard caucus implementation

Joining a caucus

Sending messages within a caucus

Receiving messages from a caucus

Pausing and resuming a caucus

Pausing a caucus

Resuming a caucus

Retrieving identities

Leaving a caucus

Extending the caucus framework

Deriving a new caucus member class

Defining a class to receive messages

Defining a class to send messages

part 3 - Remote object services

RPC Services

Understanding RPC Services

Class hierarchy for caller-dispatcher pairs

Transport classes

Designing servers

Child objects in RPC Services

Using the Service Access framework

RPC Services classes

Classes for designing caller-dispatcher pairs

Classes

Macros

Classes for transport

Classes for dispatching

Classes for creating child objects

How classes interact in the RPC model

Interaction within the server

Interaction within the client

Passing parameters to remote member functions

Passing parameters in stubs

Parameter limitations

Implementing a caller-dispatcher pair

Defining the abstract base class

Defining the implementation

Defining a caller

Writing the caller class interface

Defining the caller class constructor

Writing the caller stubs

Using the caller definitions macro

Defining the dispatcher

Writing the dispatcher class interface

Writing the dispatcher class constructor

Writing the dispatcher stubs

Starting the dispatcher thread

Using TDispatcherThread

Writing a class to start the dispatcher thread

Adding a request to an existing caller

Designing servers

Single-threaded servers

Basic multithreaded servers

Protecting Data

Managing concurrency

Introduction to child objects

Child object interaction

Using the child directory

Class hierarchy for child objects

Implementing a collection of child objects

Defining and using a child directory

Initializing a child directory

Defining a new child directory

Defining an abstract parent base class

Designing a parent caller

Implementing a parent dispatcher

Writing the parent implementation

Multithread safety

Defining an abstract child base class

Designing a child caller

Implementing a child dispatcher

Writing the child implementation

part 4 - Licensing services

Licensing Service overview

Key features of the Licensing Service

What licensing does

Using a license activation key

Securing a licensed product

Licensing benefits

Tailored functionality

Lowered cost

Licensing Service parts

Licensing framework

Product Preparation framework

Software Administration framework

Licensing servers

Licensing Service usage

User tries and orders product

Product developer mints key

Product developer sends key to user site

System administrator installs key

User accesses full-featured product

Developer roadmap

Client

Provider

ELFIN

Licensing framework client API

Licensing framework

Runtime states

Challenge mechanism

Getting started with implementation

Developer cookbook

Example licensed product implementation

Flow diagrams

Classes and member functions

TLicenseUse

Time modalities

Licensing unit acquisition and release

Elapsed time

Recyclable and consumable licensing units

Placing business terms in license activation keys

Basic member functions

Extended member functions

Concurrency

TLicenseVendor

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

TLicenseProduct

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

Supporting Classes

Extensions to the cookbook

Licensing framework provider API

License provider services

Plugging an implementation into the Licensing framework

Binding a TLicenseUse to a TLicenseProvider

Storage Management

TLicenseProvider

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

TLicense ProviderSession

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

Provider operation mechanism

TProviderOperation

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

TBasicChallenge

Instantiation

Member functions

Data members

Deriving classes

Concurrency

Resource use

TMessageDigest

Instantiation

Member functions

Deriving classes

Concurrency

Resource use

TMD4 and TMD5

Instantiation

Member functions

Deriving classes

Concurrency

Resource Use

Licensing exceptions

Base class for all licensing exceptions

License configuration

License denied

License usage

No units available

Product unknown

No acceptable providers

Invalid provider

Reporting

Generic exception

ELFIN Licensing framework provider

Getting started with ELFIN

Mapping licensed product to Elan License Manager feature

The ELFIN provider-specific Client API

Recognizing ELFIN in SelectProvider and Accept OperationsResults

Configuring ELFIN

Instantiation

Member functions

Deriving Classes

Concurrency

Getting details of an Elan License Manager license key

Instantiation

Member functions

Accessors for Elan License Manager information

Deriving Classes

Concurrency

ELFIN exceptions

Member functions

Member functions

Deploying ELFIN at an end-user site