Transient Metadata
Author: | Tomas Zezula |
Version: | 1.0 |
Note: The API described in this document is not an official contract and may change
without preserving a backward compatibility. Such changes will be announced in advance on
MDR mailing lists.
Intention
To provide model elements whose end of lifecycle is controlled by the JVM garbage collector in addition
to the refDelete operation.
Motivation
The model of Java language needs to hold same temporary data which should not persist (e.g. JavaDoc, position
in the source file,...). The Java module supplies references to this model elements to its clients, so
it is hard for it to control their livecycle. The transient metadata provides elegant solution of this problem.
The developer only marks the Class as transient during creation of model, modifies model to fullfill the
requirements for transient metadata (described below) and imports the model into the MDR. The deletion of unreferenced
elements is done automatically by the MDR engine.
Limitations
The tansient model elements have several limitations in comparison to the standard model elements.
- The first limitation concerns the inherited associations. The following association usages
are forbidden.
|
1. Inheritance of nontransient class from transient class |
|
2. Inheritance of transient class from nontransient class |
In the situation 1. the transient class (ClassA) defines association to ClassC. The non transient class
(ClassB) inherits from ClassB. But adding the instances of ClassB into the association is forbidden.
Similarly in the situation 2. where the nontransient class (ClassA) defines the association to ClassC and
the transient class (ClassB) is subclass of ClassA the instances of ClassB can not be added into the association.
Instead of using the single association the association has to be split into two associations (one for non transient
class and second for transient class) as shown on the following picture.
|
Split of association into two independent associations for transient and nontransient class. |
- Change in Collection.size() and Iterator.next () behavior.
Due to the essence of the transient metadata the transient element can be freed by the garbage
collector when it is not hard referenced. So, the two consequent calls of the Collection's size
method can return different number of elements in the collection if the garbage collector is activated
between this two calls. The same holds for Iterator's hasNext and next methods. If the hasNext method
returns true the consequent call of the next method can return null if the garbage collector is activated
between this two calls and all elements in the iterator behind the current one were unreferenced.
- Lifecycle of transient element can not be controlled by the association from the nontransient element.
The transient element is deleted when it is not hard referenced from client application or is not amember of association
with both transient ends. The existence of association where one end is transient and other non transient does not
protect the transient element from being deleted by the garbage collector.
Usage
The MDR engine treats the object as transient if its class has the org.netbeans.mdr.transient tag
set to the value true. Such a class is represented by the TransientStorableClass rather than StorableClass.
The TransientStorableClass creates TransientStorableObject for instance representation. The association is treated
as transient automatically if at least one end of the association is transient (represented by transient class).