Server Smalltalk Guide
Typically in Smalltalk, all objects are local; they live in one
running image and are processed by one virtual machine. With the
introduction of remote messaging comes the notion of remote objects and the
need for an addressing alternative to the standard memory address used by the
local virtual machines.
Object spaces represent a home for objects. Essentially they manage
a namespace and expose the names to objects in other object spaces thus
allowing inter-space references. In the simplest case (with
SstSimpleObjectSpace) the name assigned is just a simple key such
as a number or symbol. Exporting an object is the act of assigning a
key to an object. Objects used as export keys must conform to the
IuSstExportKey interface, which defines the following
protocol:
- sstIsExportKey
- Returns true to indicate that the receiver is a valid export
key. Note that the receiver must be an immutable object. (See
sstImmutable).
Objects referenced using this simple key are not globally unique in and of
themselves. In combination with an invocation handler, however, they do
uniquely specify an object. If used as the receiver of a request,
invocation handlers will correctly resolve the key and replace it with the
associated object.
This sort of export key is typically used in client-server
applications. For example, a server would export its services by
locally unique keys (such as DatabaseServer or http) and
clients construct and send messages to these services specifying the export
key as the message receiver.
Objects spaces provide the following API for explicitly managing exported
objects:
- export: object
- Ensures that @object is externally known. If
@object is not already exported, automatically generates an export
key. Returns the export key used.
- export: object as:
objectId
- Makes @object externally known as @objectId.
Overwrites any existing mapping for @objectId. Returns
@object.
- exportIdFor: object
- Answers the ID under which @object is exported. Answers
nil if @object has not been exported.
- objectExportedAs: key
- Returns the object which has been exported using @key in the
receiver. If @key is not found, returns
nil.
- objectExportedAs: key
ifAbsent: absentHandler
- Returns the object which has been exported using @key in the
receiver. If @key is not found, returns the result of
evaluating @absentHandler.
- resolve: key ifAbsent:
absentHandler
- Returns the object exported by the receiver using @key.
If @key is not found, returns the result of evaluating
@absentHandler.
- unexportId: key
- Removes any mapping for @key from the export list of the
receiver. Returns the object exported as @key or
nil if none exists.
- unexportObject: object
- Removes any export mapping with @object as the value.
Returns @object or nil if it cannot be found in the
receiver.
Object handles are a more general exporting mechanism where objects are
exported as {object space, object ID} pairs. Assuming that the object
space IDs are globally unique (within some application context) and the spaces
manage their namespace such that each object has a locally unique name, these
pairs are globally unique (within that application context). The
object-to-object handle mapping is maintained by the export set of each object
space. When an object is passed by reference out of a space, it is
replaced in the outgoing message by its globally unique object handle.
More sophisticated object spaces also have an import set which maintains a
mapping from object handle to local representation (for example,
proxy). This ability is essential for maintaining object
identity. The same handle passed twice to the same object space will
resolve to the same physical object in that space. Object spaces
support the following API for managing the collection of imported
objects:
- import: handle as:
object
- Makes the external @object internally known as
@handle. Overwrites any existing mapping for
@handle.
- import: handle as:
object for: importer
- Makes the external @object internally known as
@handle. Overwrites any existing mapping for
@handle.
- objectImportedAs: key
- Returns the object which has been imported using @key in the
receiver. If @key is not found, returns
nil.
- objectImportedAs: key
ifAbsent: absentHandler
- Returns the object which has been imported using @key in the
receiver. If @key is not found, returns the result of
evaluating @absentHandler.
- resolve: key ifAbsent:
absentHandler
- Returns the object imported by the receiver using @key.
If @key is not found, returns the result of evaluating
@absentHandler.
- unimportHandle: key
- Removes any import mapping with @key as the key. Returns
the object imported as @key or nil if none
exists.
- unimportObject: object
- Removes any import mapping with @object as the value.
Returns @object or nil if it cannot be found in the
receiver.
[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]