"

 COPYRIGHT (c) 1991 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.

"

Collection subclass:#Set

	instanceVariableNames:'tally keyArray'

	classVariableNames:'DeletedEntry'

	poolDictionaries:''

	category:'Collections-Unordered'

!

Object subclass:#EmptySlot

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:Set

!

!Set class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1991 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.

"

!

documentation

"

    a Set is a collection where each element occurs at most once.

    The inclusion test is done using = for comparison; 

    see IdentitySet for sets using identity compare.

    Sets use hashing for fast access, this access is considerably faster,

    if a good hash-number is returned by the elements.

    Notice that the default hash (Object>>hash) is not perfect; due to

    the implementation of hash-keys in ST/X, increased hash collisions

    are to be expected for large sets (say: > 20000 element). 

    If your objects are heavyly used in sets or dictionaries, and you need

    big collections, your instances may provide a better hash values.

    Performance hints: 

      If only symbols or smallIntegers are used as keys, 

      use an instance of IdentitySet for slightly better performance, 

      since both hashing and comparison is faster.

      If you have a rough idea how big the set is going to grow,

      create it using #new: instead of #new. Even if the size given is a

      poor guess (say half of the real size), there is some 20-30% performance

      win to expect, since many resizing operations of the set are avoided.

    Examples:

        |s|

        s := Set new.

        s add:'hello'.

        s add:'world'.

        s add:#foo.

        s add:1.2345678.

        s add:'hello'.

        s printNL.

        's size -> ' print. s size printNL.

        '(s includes:''hello'') -> ' print. (s includes:'hello') printNL.

        '(s includes:#foo)    -> ' print. (s includes:#foo) printNL.

        '(s includes:''foo'')   -> ' print. (s includes:'foo') printNL.

        '(s includes:#bar)    -> ' print. (s includes:#bar) printNL.

    [author:]

        Claus Gittinger

"

! !

!Set class methodsFor:'initialization'!

initialize

    "initialize the Set class"

    DeletedEntry isNil ifTrue:[

        DeletedEntry := EmptySlot new

    ].

    "Set initialize"

    "Modified: 24.1.1997 / 21:09:00 / cg"

! !

!Set class methodsFor:'instance creation'!

new

    "return a new empty Set"

    ^ self new:7

!

new:anInteger

    "return a new empty Set with space for anInteger elements"

    "

     make it somewhat bigger; hashing works better if fill grade is

     below 10% (make it 75% here ..)

    "

    ^ self basicNew setTally:(anInteger * 4 // 3)

! !

!Set class methodsFor:'queries'!

goodSizeFrom:arg 

    "return a good array size for the given argument.

     Returns the next prime after arg, since prime sizes are good for hashing."

    |n|

    "

     mhmh - this returns good numbers for collections with up-to about

     500k elements; if you have bigger ones, add some more primes here ...

    "

    n <= 524288 ifTrue:[

    ].

    "

     make it odd - at least

    "

    ^ n bitOr:1

! !

!Set methodsFor:'accessing'!

at:index

    "report an error: at: is not allowed for Sets"

    ^ self errorNotKeyed

!

at:index put:anObject

    "report an error: at:put: is not allowed for Sets"

    ^ self errorNotKeyed

! !

!Set methodsFor:'adding & removing'!

add:anObject

    "add the argument, anObject to the receiver.

     WARNING: do not add elements while iterating over the receiver.

              Iterate over a copy to do this."

    |index "{ Class: SmallInteger }"|

    anObject notNil ifTrue:[

        index := self findKeyOrNil:anObject.

        (keyArray basicAt:index) isNil ifTrue:[

            "/ not already there

            keyArray basicAt:index put:anObject.

            tally := tally + 1.

            self fullCheck.

        ]

    ].

    ^ anObject

    "Modified: 30.1.1997 / 14:58:08 / cg"

!

remove:oldObject ifAbsent:exceptionBlock

    "remove oldObject from the collection and return it.

     If it was not in the collection return the value of exceptionBlock.

     WARNING: do not remove elements while iterating over the receiver.

              See #saveRemove: to do this."

    |index next|

    index := self find:oldObject ifAbsent:0.

    index == 0 ifTrue:[^ exceptionBlock value].

    keyArray basicAt:index put:nil.

    tally := tally - 1.

    tally == 0 ifTrue:[

        keyArray := self keyContainerOfSize:(self class goodSizeFrom:0). 

    ] ifFalse:[

        index == keyArray basicSize ifTrue:[

            next := 1

        ] ifFalse:[

            next := index + 1.

        ].

        (keyArray basicAt:next) notNil ifTrue:[

            keyArray basicAt:index put:DeletedEntry.

        ].

        self emptyCheck

    ].

    ^ oldObject

    "Modified: 29.1.1997 / 21:34:33 / cg"

!

removeAll

    "remove all elements from the receiver. Returns the receiver."

    self setTally:7.

    "Modified: 12.4.1996 / 13:35:06 / cg"

!

saveRemove:oldObject 

    "remove the element, oldObject from the collection.

     Return the element.

     If it was not in the collection return nil.

     In contrast to #remove:, this does not resize the underlying collection

     and therefore does NOT rehash & change the elements order.

     Therefor this can be used while enumerating the receiver,

     which is not possible if #remove: is used.

     WARNING: since no resizing is done, the physical amount of memory used

              by the container remains the same, although the logical size shrinks.

              You may want to manually resize the receiver using #emptyCheck.

              (after the loop)"

    |index "{ Class:SmallInteger }"

     next  "{ Class:SmallInteger }"|

    oldObject isNil ifTrue:[^ nil].

    index := self find:oldObject ifAbsent:0.

    index == 0 ifTrue:[^ nil].

    keyArray basicAt:index put:nil.

    tally := tally - 1.

    tally ~~ 0 ifTrue:[

        index == keyArray basicSize ifTrue:[

            next := 1

        ] ifFalse:[

            next := index + 1.

        ].

        (keyArray basicAt:next) notNil ifTrue:[

            keyArray basicAt:index put:DeletedEntry

        ].

    ].

    ^ oldObject

    "does NOT work:

        |s|

        s := Set new.

        s add:1.

        s add:2.

        s add:3.

        s add:4.

        s add:5.

        s add:6.

        s add:7.

        s add:8.

        s add:9.

        s do:[:v |

            v odd ifTrue:[

                s remove:v 

            ]

        ].

        s inspect

    "

    "DOES work:

        |s|

        s := Set new.

        s add:1.

        s add:2.

        s add:3.

        s add:4.

        s add:5.

        s add:6.

        s add:7.

        s add:8.

        s add:9.

        s do:[:v |

            v odd ifTrue:[

                s saveRemove:v 

            ]

        ].

        s inspect

    "

    "Created: 1.3.1996 / 21:14:26 / cg"

    "Modified: 29.1.1997 / 21:35:55 / cg"

! !

!Set methodsFor:'binary storage'!

readBinaryContentsFrom: stream manager: manager

    "must rehash after reload"

    super readBinaryContentsFrom: stream manager: manager.

    self rehash

! !

!Set methodsFor:'copying'!

postCopy

    "have to copy the keyArray too"

    keyArray := keyArray shallowCopy

! !

!Set methodsFor:'enumerating'!

do:aBlock

    "perform the block for all members in the collection.

     WARNING: do not add/remove elements while iterating over the receiver.

	      Iterate over a copy to do this."

    |sz "{ Class: SmallInteger }"

     element|

    sz := keyArray size.

    1 to:sz do:[:index |

	element := keyArray at:index.

	(element notNil and:[element ~~ DeletedEntry]) ifTrue:[

	    aBlock value:element

	]

    ]

    "Modified: 1.3.1996 / 21:41:13 / cg"

! !

!Set methodsFor:'inspecting'!

inspectorClass

    "redefined to use SetInspector

     (instead of the default Inspector)."

    ^ SetInspectorView

! !

!Set methodsFor:'private'!

emptyCheck

    "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)'"

    |sz      "{Class: SmallInteger}"

     newSize "{Class: SmallInteger}" |

    sz := keyArray basicSize.

    sz > 56 ifTrue:[

        "

         shrink if too empty

        "

        tally < (sz // 8) ifTrue:[

            self grow:newSize

        ]

    ]

!

find:key ifAbsent:aBlock

    "Look for the key in the receiver.  If it is found, return

     the index of the slot containing the key, otherwise

     return the value of evaluating aBlock."

    |index  "{ Class:SmallInteger }"

     length "{ Class:SmallInteger }"

     startIndex probe|

    length := keyArray basicSize.

"/

"/  length < 10 ifTrue:[

"/      "assuming, that for small collections the overhead of hashing

"/       is larger ... maybe that proves wrong 

"/       (if overhead of comparing is higher)"

"/      ^ keyArray indexOf:key ifAbsent:aBlock

"/  ].

    index := key hash.

    index < 16r1FFFFFFF ifTrue:[

        index := index * 2

    ].

    index := index \\ length + 1.

    startIndex := index.

    [true] whileTrue:[

	probe := (keyArray basicAt:index).

	probe isNil ifTrue:[^ aBlock value].

	key = probe ifTrue:[^ index].

	index == length ifTrue:[

	    index := 1

	] ifFalse:[

	    index := index + 1

	].

	index == startIndex ifTrue:[^ aBlock value].

    ]

!

findKeyOrNil:key

    "Look for the key in the receiver.  

     If it is found, return return the index of the first unused slot. 

     Grow the receiver, if key was not found, and no unused slots were present"

    |index  "{ Class:SmallInteger }"

     length "{ Class:SmallInteger }"

     startIndex probe 

     delIndex "{ Class:SmallInteger }" |

    delIndex := 0.

    length := keyArray basicSize.

    index := key hash.

    index < 16r1FFFFFFF ifTrue:[

        index := index * 2

    ].

    index := index \\ length + 1.

    startIndex := index.

    [true] whileTrue:[

        probe := keyArray basicAt:index.

        probe isNil ifTrue:[

            delIndex == 0 ifTrue:[^ index].

            keyArray basicAt:delIndex put:nil.

            ^ delIndex

        ].

        key = probe ifTrue:[^ index].

        probe == DeletedEntry ifTrue:[

            delIndex == 0 ifTrue:[

                delIndex := index

            ]

        ].

        index == length ifTrue:[

            index := 1

        ] ifFalse:[

            index := index + 1

        ].

        index == startIndex ifTrue:[

            delIndex ~~ 0 ifTrue:[

                keyArray basicAt:delIndex put:nil.

                ^ delIndex

            ].

            ^ self grow findKeyOrNil:key

        ].

    ]

    "Modified: 4.6.1996 / 11:15:16 / cg"

!

findNil:key

    "Look for the next slot usable for key.  This method assumes that

     key is not already in the receiver and that keyArray does not have

     previously removed entries.

     To be used only while growing/rehashing to enter elements into a fresh

     collection."

    |startIndex

     index  "{ Class:SmallInteger }"