xapi.util

Class X_GC

java.lang.Object

xapi.util.X_GC

public class X_GC
extends Object

In order to encourage and facilitate object de-referencing, the X_GC class, combined with the OnGC annotation allow objects to destroy each other without necessarily knowing anything about them. It also allows forming "destruction chains", whereby when a root object is destroyed, we can check if it's fields are destroyable and gc them too, either by annotating with OnGC, or implementing the Destroyable interface. Not that this may NOT be what you want, in case a field is shared among multiple children. Thus, GC chaining is disabled by default. Default behavior is to null out fields without inspecting them.

Author:

"James X. Nelson (james@wetheinter.net)"

Method Summary

Modifier and Type	Method and Description
static <T> void	deepDestroy(Class<? super T> classLiteral, T inst)
static <T> void	deepDestroy(Class<? super T> classLiteral, T inst, HashSet<Object> seen)
static <T> void	destroy(Class<? super T> classLiteral, T inst) In gwt, we can use this as a magic method to compute a destroy function, but do so without bloating runtime code.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

destroy

public static <T> void destroy(Class<? super T> classLiteral,
                               T inst)

In gwt, we can use this as a magic method to compute a destroy function, but do so without bloating runtime code. This is why you must send the class. If you put OnGC on a superclass, and do not wish to repeat the annotation, you can send the superclass's class literal, and it will be applied instead (though it will not use any overridden methods; we literally use the super classes Method objects). Note that you must send a the class LITERAL and not a class reference, as that is what the gwt generator will use to define a GC strategy. In any case, the code needed to destroy the fields of the object will just be plain javascript, for (key in _)if (_.hasOwnProperty(key)) delete _[key] Sending the class along simply means we can check for the @GC annotation, and use it to call some zero-arg destroy methods for this object, and maybe even on any particular fields.

Parameters:

cls -

inst -

deepDestroy

public static <T> void deepDestroy(Class<? super T> classLiteral,
                                   T inst)

deepDestroy

public static <T> void deepDestroy(Class<? super T> classLiteral,
                                   T inst,
                                   HashSet<Object> seen)