"

 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.

"

Array variableSubclass:#WeakArray

       instanceVariableNames:'watcher dependents'

       classVariableNames:'RegistrationFailedSignal AlreadyInitialized'

       poolDictionaries:''

       category:'Collections-Arrayed'

!

WeakArray comment:'

COPYRIGHT (c) 1991 by Claus Gittinger

	      All Rights Reserved

'!

!WeakArray 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.

"

!

version

"

"

!

documentation

"

    WeakArrays can be used to trace disposal of objects; in contrast to other

    Instead, whenever an object kept in a WeakArray dies, its entry is nilled,

    and the WeakArray informed by the storage manager. 

    You can use WeakArrays to track disposal of objects which keep external

    world resources. For example, FileStreams must close their underlying

    This can be done by keeping the FileStream objects in a weakArray, and

    keep a parallel array of filedescriptors. Whenever a fileStream gets

    free, search both arrays for an index where the stream is nil, but the

    filedescriptor is non-nil. Then close that file, and nil the filedescriptor

    data in that cache will not be unreclaimable due to being cached.

    (for example, the ResourcePack class uses a WeakArray to cache recently

    used resource data for a while).

    The way in which weakArrays get informed by the runtime system is via

    an interrupt (DisposeInterrupt). The reason for not sending messages

    directly from the VM is to make it possible to run the finalization

    code at lower priority or from another class. 

    Also, as a side effect, it is possible to delay finalization by blocking 

    interrupts.

    is scanned after each GC). It is uncertain, if the current mechanism works well

    with (say) ten-thousands of weakArrays.

"

! !

!WeakArray class methodsFor:'initialization'!

initialize

    "setup the private signal"

    RegistrationFailedSignal isNil ifTrue:[

	Object initialize.

	RegistrationFailedSignal := Object errorSignal newSignalMayProceed:true.

	RegistrationFailedSignal nameClass:self message:#registrationFailedSignal.

	RegistrationFailedSignal notifierString:'weakArray registration failed'.

    ]

! !

!WeakArray class methodsFor:'instance creation'!

new:size

    "return a new weakArray with size slots"

    "This is a kludge: I would like to set WEAK-flag in the classes

     initialize method, but (currently) the order in which the class-initialize

     ... therefore it could happen, that a WeakArray is used by other

     classes initialize method BEFORE this method is evaluated. 

     To avoid this, the WEAK bit in the class is set here, when the very first 

     WeakArray is created."

    AlreadyInitialized isNil ifTrue:[

	self flags:(Behavior flagWeakPointers).

	AlreadyInitialized := true

    ].

    ^ (self basicNew:size) registerAsWeakArray

! !

!WeakArray methodsFor:'GC registration'!

registerAsWeakArray

    "register the receiver in the VM - 

     i.e. tell the VM to nil disposed entries in the receiver

     and notify the disposeInterruptHandler whenever that happened."

    |ok|

%{

    OBJ __addShadowObject();

    ok = __addShadowObject(self, 0);

    if (ok == false) {

	/* 

	 * this happens when too many shadow objects are

	 * already there, collect garbage to get rid of

	 * obsolete ones, and try again.

	 * since a full collect is expensive, we try

	 * a scavenge first, doing a full collect only if 

	 * that does not help.

	 */

	nonTenuringScavenge(__context);

	ok = __addShadowObject(self, 0);

	if (ok == false) {

	    scavenge(__context);

	    ok = __addShadowObject(self, 0);

	    if (ok == false) {

		__garbageCollect(__context);

		ok = __addShadowObject(self, 0);

		if (ok == false) {

		    ok = __addShadowObject(self, 1);

		    if (ok == false) {

			/* no chance - something must be wrong */

		    }

		}

	    }

	}

    }

%}.

    ok ifFalse:[

	^ RegistrationFailedSignal raiseRequestWith:self

    ]

! !

    ]

! !

!WeakArray methodsFor:'copying'!

postCopy

    "copying alone does not really help - we have to tell

     the VM, that there is a new WeakArray around ...

     Q: who copies weakArrays ?"

    self registerAsWeakArray.

! !

!WeakArray methodsFor:'accessing'!

dependents 

    "return the dependents of the receiver"

    ^ dependents

!

dependents:aCollection

    "set the dependents of the receiver"

    dependents := aCollection

!

watcher

    "return the watcher of the receiver.

     The watcher-stuff is a leftover from an old implementation 

     and will vanish soon"

    ^ watcher

!

watcher:anObject

    "set the watcher of the receiver.

     The watcher-stuff is a leftover from an old implementation 

     and will vanish soon"

    watcher := anObject

! !