eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'WeakValueDictionary':

Home

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

Class: WeakValueDictionary


Inheritance:

   Object
   |
   +--Collection
      |
      +--Set
         |
         +--Dictionary
            |
            +--WeakValueDictionary

Package:
stx:libbasic
Category:
Collections-Weak
Version:
rev: 1.28 date: 2016/07/21 15:05:32
user: stefan
file: WeakValueDictionary.st directory: libbasic
module: stx stc-classLibrary: libbasic
Author:
Stefan Vogel

Description:


WeakValueDictionaries behave like Dictionaries,
as long as the values are still referenced by some
other (non-weak) object.
However, once the last non-weak reference ceases to exist,
the Dictionary will return nil for the value at position key.
(with some delay: it will be removed after the next garbage collect).


Warning:


If you use this, be very careful since the collections size changes
'magically' - for example, testing for being nonEmpty and then
removing the first element may fail, since the element may vanish inbetween.
In general, never trust the value as returned by the size/isEmpty messages.

Related information:

    WeakArray
    WeakIdentityDictionary
    WeakIdentitySet

Instance protocol:

adding & removing
o  at: key ifAbsent: somethingRespondingToValue
Redefined to handle collected values (which are set to a SmallInteger)
snd to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.

o  at: key ifAbsentPut: replacementBlock
return the element indexed by aKey if present,
if not present, store the result of evaluating valueBlock
under aKey and return it.

Redefined to block interrupts, to avoid trouble when dependencies
are added within interrupting high prio processes.
WARNING: do not add elements while iterating over the receiver.
Iterate over a copy to do this.

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  removeIdentityValue: aValue ifAbsent: aBlock
remove the association under aValue from the collection,
return the key 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  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  removeValue: aValue ifAbsent: aBlock
remove the association under aValue from the collection,
return the key 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).

element disposal
o  update: something with: aParameter from: changedObject
an element (either key or value) died - clear out slots for
disposed keys.

enumerating
o  do: aBlock
garbage collected values will change to nil or a SmallInteger

o  keysAndValuesDo: aBlock
garbage collected values will change to a SmallInteger

private
o  clearDeadSlots
have to block here - dispose may be done at a low priority
from the background finalizer. If new items are added by a
higher prio process, the dictionary might get corrupted otherwise

o  possiblyShrink
check if the receiver has become too empty (after a remove)
and shrink if it makes sense.
Definition of 'too empty' is: 'filled less than 12.5% (i.e. 1/8th)'

o  valueContainerOfSize: n
return a container for values of size n.
use WeakArrays here.

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

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

o  includesKey: key
redefined to check for already collected values

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



ST/X 7.1.0.0; WebServer 1.663 at exept.de:8081; Sun, 18 Nov 2018 08:31:55 GMT