## org.jfree.report.util
Class WeakReferenceList

    java.lang.Object
      org.jfree.report.util.WeakReferenceList

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable

    public abstract class WeakReferenceList

extends java.lang.Object
implements java.io.Serializable, java.lang.Cloneable

The WeakReference list uses `java.lang.ref.WeakReference`s to store its contents. In contrast to the WeakHashtable, this list knows how to restore missing content, so that garbage collected elements can be restored when they are accessed.

By default this list can contain 25 elements, where the first element is stored using a strong reference, which is not garbage collected.

Restoring the elements is not implemented, concrete implementations will have to override the `restoreChild(int)` method. The `getMaxChildCount` method defines the maxmimum number of children in the list. When more than `maxChildCount` elements are contained in this list, add will always return false to indicate that adding the element failed.

To customize the list, override createReference to create a different kind of reference.

This list is able to add or clearFromParent elements, but inserting or removing of elements is not possible.

Author:
  Thomas Morgner
See Also:
  Serialized Form

Constructor Summary
`protected` `WeakReferenceList(int maxChildCount)` Creates a new weak reference list.

Method Summary
`boolean` `add(java.lang.Object rs)` Adds the element to the list.
`protected java.lang.Object` `clone()` Creates and returns a copy of this object.
`java.lang.Object` `get(int index)` Returns the child stored at the given index.
`protected int` `getChildPos(int index)` Returns the internal storage position for the child.
`protected java.lang.Object` `getMaster()` Returns the master element of this list.
`protected int` `getMaxChildCount()` Returns the maximum number of children in this list.
`int` `getSize()` Returns the size of the list.
`protected boolean` `isMaster(int index)` Returns true, if the given index denotes a master index of this list.
`protected abstract java.lang.Object` `restoreChild(int index)` Attempts to restore the child stored on the given index.
`void` `set(java.lang.Object report, int index)` Replaces the child stored at the given index with the new child which can be null.

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### WeakReferenceList

    protected WeakReferenceList(int maxChildCount)

  Creates a new weak reference list. The storage of the list is limited to getMaxChildCount() elements.

  Parameters:
    `maxChildCount` - the maximum number of elements.

Method Detail

### getMaxChildCount

    protected final int getMaxChildCount()

  Returns the maximum number of children in this list.

  Returns:
    the maximum number of elements in this list.

### getMaster

    protected java.lang.Object getMaster()

  Returns the master element of this list. The master element is the element stored by a strong reference and cannot be garbage collected.

  Returns:
    the master element

### restoreChild

    protected abstract java.lang.Object restoreChild(int index)

  Attempts to restore the child stored on the given index.

  Parameters:
    `index` - the index.
  Returns:
    null if the child could not be restored or the restored child.

### get

    public java.lang.Object get(int index)

  Returns the child stored at the given index. If the child has been garbage collected, it gets restored using the restoreChild function.

  Parameters:
    `index` - the index.
  Returns:
    the object.

### set

    public void set(java.lang.Object report,
                    int index)

  Replaces the child stored at the given index with the new child which can be null.

  Parameters:
    `report` - the object.
    `index` - the index.

### add

    public boolean add(java.lang.Object rs)

  Adds the element to the list. If the maximum size of the list is exceeded, this function returns false to indicate that adding failed.

  Parameters:
    `rs` - the object.
  Returns:
    true, if the object was successfully added to the list, false otherwise

### isMaster

    protected boolean isMaster(int index)

  Returns true, if the given index denotes a master index of this list.

  Parameters:
    `index` - the index.
  Returns:
    true if the index is a master index.

### getChildPos

    protected int getChildPos(int index)

  Returns the internal storage position for the child.

  Parameters:
    `index` - the index.
  Returns:
    the internal storage index.

### getSize

    public int getSize()

  Returns the size of the list.

  Returns:
    the size.

### clone

    protected java.lang.Object clone()
                              throws java.lang.CloneNotSupportedException

  Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object. The general intent is that, for any object `x`, the expression:

  >      x.clone() != x

  will be true, and that the expression:

  >      x.clone().getClass() == x.getClass()

  will be `true`, but these are not absolute requirements. While it is typically the case that:

  >      x.clone().equals(x)

  will be `true`, this is not an absolute requirement.

  By convention, the returned object should be obtained by calling `super.clone`. If a class and all of its superclasses (except `Object`) obey this convention, it will be the case that `x.clone().getClass() == x.getClass()`.

  By convention, the object returned by this method should be independent of this object (which is being cloned). To achieve this independence, it may be necessary to modify one or more fields of the object returned by `super.clone` before returning it. Typically, this means copying any mutable objects that comprise the internal "deep structure" of the object being cloned and replacing the references to these objects with references to the copies. If a class contains only primitive fields or references to immutable objects, then it is usually the case that no fields in the object returned by `super.clone` need to be modified.

  The method `clone` for class `Object` performs a specific cloning operation. First, if the class of this object does not implement the interface `Cloneable`, then a `CloneNotSupportedException` is thrown. Note that all arrays are considered to implement the interface `Cloneable`. Otherwise, this method creates a new instance of the class of this object and initializes all its fields with exactly the contents of the corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation.

  The class `Object` does not itself implement the interface `Cloneable`, so calling the `clone` method on an object whose class is `Object` will result in throwing an exception at run time.

  Overrides:
    `clone` in class `java.lang.Object`
  Returns:
    a clone of this instance.
  Throws:
    `java.lang.CloneNotSupportedException` - if the object's class does not support the `Cloneable` interface. Subclasses that override the `clone` method can also throw this exception to indicate that an instance cannot be cloned.
  See Also:
    `Cloneable`