eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'WeakIdentityDictionary':

Home

Documentation
www.exept.de
Everywhere
for:
[back]

Class: WeakIdentityDictionary


Inheritance:

   Object
   |
   +--Collection
      |
      +--Set
         |
         +--Dictionary
            |
            +--IdentityDictionary
               |
               +--WeakIdentityDictionary
                  |
                  +--Registry
                  |
                  +--WeakDependencyDictionary

Package:
stx:libbasic
Category:
Collections-Weak
Version:
rev: 1.68 date: 2022/09/26 09:56:49
user: matilk
file: WeakIdentityDictionary.st directory: libbasic
module: stx stc-classLibrary: libbasic

Description:


WeakIdentityDictionaries behave like IdentityDictionaries,
as long as the keys are still referenced by some other (non-weak) object.

However, once the last non-weak reference to a key ceases to exist,
the object will be automatically removed from the Weakcollection
(with some delay: it will be removed after the next garbage collect).

This class was added to support keeping track of dependents without
keeping the values alive - a value simply become nil when no one else references it. 

The original dependency mechanism used a regular Dictionary,
which usually leads to a lot of garbage being kept due to a forgotten release. 
Using a WeakDictionary may be incompatible to ST-80 but is much
more comfortable, since no manual release of dependents is needed.

copyright

COPYRIGHT (c) 1992 by Claus Gittinger All Rights Reserved This software is furnished under a license and may be used only in accordance with the terms of that license and with the inclusion of the above copyright notice. This software may not be provided or otherwise made available to, or used by, any other person. No title to or ownership of the software is hereby transferred.

Instance protocol:

accessing
o  keys
return a collection containing all valid keys of the receiver

adding & removing
o  at: key ifAbsent: exceptionBlock
redefined to block interrupts
(avoid change of the dictionary while accessing)

o  at: key ifAbsentPut: replacementBlock
redefined to block interrupts
(avoid change of the dictionary while accessing)

o  at: key put: anObject
add the argument anObject under key, aKey to the receiver.
Return anObject (sigh).
Redefined to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.

o  removeKey: aKey ifAbsent: aBlock
remove the association under aKey from the collection,
return the value previously stored there.
If it was not in the collection return the result
from evaluating aBlock.

Redefined to avoid synchronization problems, in case
of interrupts (otherwise, there could be some other operation
on the receiver done by another process, which garbles my contents).

o  safeRemoveKey: key
redefined to block interrupts
(avoid change of the dictionary while accessing)

element disposal
o  clearDeadSlots
an element (one of my keys) died - clear slots for
disposed keys and set corresponding values to nil.

o  update: anAspect with: aParameter from: changedObject
one of our keys died - clear out slots for disposed keys.

enumerating
o  keysAndValuesDo: aTwoArgBlock
evaluate aTwoArgBlock for each registered object with key and value

o  keysDo: aBlock
evaluate aBlock for each registered object

private
o  findKeyOrNil: key
Look for the key in the receiver.
If it is found, return the index,
otherwise the index of the first unused slot.
Grow the receiver, if key was not found, and no unused slots were present.

Warning: an empty slot MUST be filled by the sender - it is only to be sent
by at:put: / add: - like methods.

o  findKeyOrNilOrDeletedEntry: key
Look for the key in the receiver.
If it is found, return the index,
otherwise the index of the first unused slot.
Grow the receiver, if key was not found, and no unused slots were present.

o  grow: newSize
grow the receiver.
Redefined to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.

Usage example(s):

'grow:' printCR.

o  initializeForCapacity: minSize
reset the receiver's contents.
Redefined to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.

o  keyContainerOfSize: n
return a container for keys of size n.
use WeakArrays here.

o  rehash
grow the receiver.
Redefined to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.

Usage example(s):

'rehash' printCR.

queries
o  includes: anObject
redefined to block interrupts
(avoid change of the dictionary while accessing)

o  includesKey: key
redefined to block interrupts
(avoid change of the dictionary while accessing)

testing
o  isWeak
return true if the receiver has weak references to its elements.

o  isWeakCollection
return true, if the receiver has weak references to its elements.



ST/X 7.7.0.0; WebServer 1.702 at 20f6060372b9.unknown:8081; Wed, 24 Jul 2024 14:54:50 GMT