Contents | Index

- A -

A note to those new to Smalltalk

Abstract Class

Abstract Factory

Accessing a Row

Accessing Command Line Arguments

Accessing Environment Variables

Accessing Standard I/O Streams

Accessing the Stores

Accessor Method

Additional Samples - Chat

An alternative method for describing columns

And finally??

Application Deployment Overview

Applying for a DolphinSure Certificate

Architecture

Arrays of Scalar Values

Arrays of Structures

- B -

Binary Filing Objects

Blocking

Blocking the User Interface Main Process

Bypassing finalization

- C -

Callback Entry Points

Callback Lifetime

Calling C Runtime Library Functions

Catching Exceptions

Catching Multiple Exceptions

Choosing from a list of Data Sources

Chunk Files

Class Initialization

Class Name

Class vs Instance

Cleaning up

Closure or User Data Arguments

Code Layout

COM/.Active-X Array Types

Commit

Company Certificates

Compiled Field Access

Component-based Architecture

Composite MVP Component

Connecting to a Data Source

Constant Access Method

Convenience methods for reading and writing objects

Converting STB data after instance layout changes

Creating an STB Proxy class

Creating Console Applications

Creating GUI Applications

Creating your own Trusted Data

Customising storage

- D -

Database Connectivity

Debugging Callbacks

Debugging with Command Line Parameters

Deferred fixup

Deploying Console Applications

Deployment Strategies

Distributing Console Applications

Distributing Your Application

Dolphin Developer's Guide - The Socket Connection Interface - Examples

Dolphin Professional (DPRO)

Dolphin User's Guide - Package Contents - Classes

Dolphin Value Edition (DVE)

Dolphin's Chunks

DolphinSure

DolphinSure Certificate Stores

DolphinSure Certificates

Dynamic Field Access

- E -

Elemental and Composite MVP components

Elemental MVP Components

Embedded Fields

Error Handling

Errors

Establishing a Client Connection

Exception Handling

Exception Hierarchies

Exceptions

Exceptions vs. Unwinds

Executing SQL Queries

Executing SQL Statements

Expressions

External Arrays

External Call Limitations

External Callback

External Callbacks

External Field Types

External Interfacing

External Libraries

External Library

External Memory Management

External Method Format

External Method Selector

External Methods

External Structure Limitations

External Structures

ExternalCallback Objects

ExternalStructure

- F -

Factory Method

Filler Fields

Final Step

Finalization

Flexibility

Further Information

Further Reading

- G -

General Categories of Exception

Global Name

Global Variable

Guidelines for Use

- H -

Handling Exceptions

How do Finalization and Mourning Actually Work?

How it works

How to use an STB Proxy

- I -

Image Maintenance

Importing from other Smalltalks

Inbound Argument Conversion

Inheritance vs. Composition

Initial Screen

Inspecting a Result Set

Installed Files

Installing a Certificate

Instance Creation Method

Instance Initialization

Instance Variable Name

Instance Variable Role

Intercepting Console Control Commands

Internet Addresses

- L -

Lagoon Deployment Kit

Lagoon Deployment Tutorial

Lagoon Deployment Wizard

Lazy Initialization

Listening for a Connection with a ServerSocket

- M -

Making use of the filer context

MessageCallback Objects

Method Comment

Method Name

Methods

Mixing STB with other data

Model

Model View Presenter

Monitoring Blocking Calls

My Certificates

- N -

Navigating through a Result Set

New Class

New Method

Non-Blocking

- O -

Object Liberation Strategy

ODBC Error handling

OLE/COM/Active-X Functions

Overlapped Calls

Overriding a proxy

- P -

Package Files

Packaged Class-Based Deployment

Parameter Conversion and Wrapper Methods

Parameterization and Execution

Permanent Trust

Persistency of Sockets

Personal Certificates

Pluggability

Pluggable Models

Pluggable Views

Pointer Fields

Policy

Pool Dictionaries

Preparation

Preparing Queries

Preparing SQL for Later Execution

Presenter

Private Method

Process Safe Class

Property

- Q -

Querying the Capabilities of a Data Source

Querying the Database Structure

- R -

Raising Exceptions

Read-Only Transactions

Redistributable Components

Redistributables

Reinstatement on Image Re-load

Resources

Restricting Field Access

Resumable vs Non-resumable Exceptions

Retrieving objects

Returning Structures

Rollback

Running Dolphin for the First Time

- S -

Scalar Fields

Setting up a Sample Data Source

Setup

Sharing a Model

Singleton

Software Patterns

Starting Dolphin

STB Debugging

STB Exceptions

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Storing globals

Storing objects

Streaming over a Socket Connection

Structure Packing

Supplying a Username and Password

System Requirements

- T -

Talking Bytes across a Socket Connection

Talking Objects across a Socket Connection

Target Machine Requirements

TCP/IP Sockets Connectivity

Temporary Trust

Temporary Variable Role

Testing and Debugging Console Applications

The CA Root Certificate

The Dolphin Smalltalk Product Range

The Pattern Sheet

The Rules

The Socket Connection Interface

The Workspace

Thread Pooling

To Overlap or Not to Overlap

Touring the Development System

Transactions

- U -

Unions

Unwinding Callbacks

Using the Non-Blocking Calls

- V -

View

Virtual Callbacks

Virtual Calls (C++/OLE COM Interface)

- W -

Warnings

Weak Collection

Weak References

Weak References and Finalization

What to do when things go wrong

Why are Views Observers?

Win32 Structured Exceptions

Word Capitalization

Workspace Variables

- Z -

Zen and the art of Finalization