hg/stx-libbasic: comparison Dictionary.st

equal deleted inserted replaced

-:4090cde0c345
+:54e93c9d0126
 documentation
 "
 a Dictionary is (conceptionally) a set of Associations storing key-value pairs.
 (The implementation uses two arrays to store the keys and values separately.)
 Searching for an element is done using a hash into the key array.
-Another way of looking at a dictionary is as a array which uses
+Another way of looking at a dictionary is as an array that uses
 arbitrary access keys (i.e. not just integers as arrays do).
 Since the keys are unordered, no internal element order is defined
 (i.e. enumerating them may return elements in any order - even changing
 over time).
 d1 := Dictionary withKeys:#(a b c) andValues:#( 1 2 3).
 d2 := Dictionary newFrom:d1.
 d2.
 [exEnd]
 "
 ! !
 !Dictionary class methodsFor:'instance creation'!
 d at:each put:(aOneArgBlock value:each).
 ].
 ^ d
 "
 Dictionary withKeys:#(10 20 30 40 50 60 70 80 90) valueBlock:[:e| e asString]
 "
 !
 withKeysAndValues:anArray
 "return a new instance where keys and values are taken from alternating
 d at:(aOneArgBlock value:each) put:each.
 ].
 ^ d
 "
 Dictionary withValues:#(10 20 30 40 50 60 70 80 90) keyBlock:[:e| e asString]
 "
 ! !
 !Dictionary class methodsFor:'Compatibility-Squeak'!
 ^ self withAssociations:aCollectionOfAssociations
 "
 Dictionary newFrom:{#foo -> #Foo. #bar -> #Bar}
 Dictionary
 newFrom:(Dictionary withKeysAndValues:#('one' 1 'two' 2 'three' 3 'four' 4))
 "
 ! !
 !Dictionary methodsFor:'Compatibility-Dolphin'!
 ( aDictionary at: key ifAbsent: [ ^false ] ) = value
 ifFalse: [ ^false ]
 ].
 ^ true
 ! !
 !Dictionary methodsFor:'accessing'!
 associationAt:aKey
 	^ valueArray basicAt:index
 ].
 ^ exceptionBlock value.
 !
 at:aKey ifAbsent:default update:aBlock
 "update the element stored under aKey with the result from
 evaluating aBlock with the previous stored value as argument, or with default,
 if there was no such key initially.
 I.e. this is the same as self at:aKey put:(aBlock value:(self at:aKey ifAbsent:default)).
 Return the new value stored.
 This is an optimized accessor, which only computes the hash value once."
 "
 |d|
 d := Dictionary new.
 d at:#foo put:'yes this is foo'.
 d at:#foo ifPresent:[:val | Transcript showCR:'the value of foo is: ',val].
 d at:#bar ifPresent:[:val | Transcript showCR:'the value of bar is: ',val].
 "
 !
 ].
 index := self findKeyOrNil:k.
 (keyArray basicAt:index) notNil ifTrue:[
 "/ key already present
 ^ aBlock value:(valueArray basicAt:index).
 ].
 "/ a new key
 keyArray basicAt:index put:k.
 valueArray basicAt:index put:anObject.
 tally := tally + 1.
 d at:'foo' put:1234 ifPresent:[:v| self error: 'duplicate: ', v printString ].
 d at:'foo' put:1234 ifPresent:[:v| self halt:'duplicate: ', v printString. 5555 ].
 "
 !
 at:aKey update:aBlock
 "update the element stored under aKey with the result from
 evaluating aBlock with the previous stored value as argument.
 Report an error if there was no such key initially.
 I.e. this is the same as self at:aKey put:(aBlock value:(self at:aKey)).
 Return the new value stored.
 This is an optimized accessor, which only computes the hash value once."
 ^ Association key:key value:(self removeKey:key)
 "Modified: 1.3.1996 / 21:21:11 / cg"
 !
 removeIdentityValue:aValue ifAbsent:aBlock
 "remove (first) the association to aValue from the collection,
 return the key under which it was stored previously.
 If it was not in the collection return result from evaluating aBlock.
 The value is searched using identity compare.
 See #saveRemoveValue: to do this."
 |next   "{ Class:SmallInteger }"
 oldKey|
 keyArray
 keysAndValuesDo:[:index :aKey |
 |idx "{Class:SmallInteger}"|
 (aKey notNil and:[ aKey ~~ DeletedEntry ]) ifTrue:[
 idx := index.
 ((valueArray at:idx) == aValue) ifTrue:[
 ! !
 !Dictionary methodsFor:'searching'!
 findFirst:aBlock ifNone:exceptionValue
 "find the index of the first element, for which evaluation of the argument, aBlock returns true;
 return its index or the value from exceptionValue if none detected.
 This is much like #detect:ifNone:, however, here an INDEX is returned,
 while #detect:ifNone: returns the element.
 Here we return the first key for which aBlock matches the value.

changeset 20228	54e93c9d0126
parent 20224	d075f60fbd7b
child 20229	b5cdb27022c8
child 20239	cc11bc01e248