protected WeakReferenceList(int maxChildCount) 
{
    this.maxChilds = maxChildCount;
    this.childs = new Reference[maxChildCount - 1];
}

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

Parameters:

maxChildCount - the maximum number of elements.

 public boolean add(Object rs) 
{
    if (size == 0)
    {
      master = rs;
      size = 1;
      return true;
    }
    else
    {
      if (size <  getMaxChildCount())
      {
        childs[size - 1] = createReference(rs);
        size++;
        return true;
      }
      else
      {
        // was not able to add this to this list, maximum number of entries reached.
        return false;
      }
    }
}

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

 protected Object clone() throws CloneNotSupportedException 
{
    final WeakReferenceList list = (WeakReferenceList) super.clone();
    list.childs = (Reference[]) childs.clone();
    return list;
}

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.

 public Object get(int index) 
{
    if (isMaster(index))
    {
      return master;
    }
    else
    {
      final Reference ref = childs[getChildPos(index)];
      if (ref == null)
      {
        throw new IllegalStateException("State: " + index);
      }
      Object ob = ref.get();
      if (ob == null)
      {
        ob = restoreChild(index);
        childs[getChildPos(index)] = createReference(ob);
      }
      return ob;
    }
}

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

 protected int getChildPos(int index) 
{
    return index % getMaxChildCount() - 1;
}

Returns the internal storage position for the child.

 protected Object getMaster() 
{
    return master;
}

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

 protected final int getMaxChildCount() 
{
    return maxChilds;
}

Returns the maximum number of children in this list.

 public int getSize() 
{
    return size;
}

Returns the size of the list.

 protected boolean isMaster(int index) 
{
    return index % getMaxChildCount() == 0;
}

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

 abstract protected Object restoreChild(int index)
Attempts to restore the child stored on the given index.

 public  void set(Object report,
    int index) 
{
    if (isMaster(index))
    {
      master = report;
    }
    else
    {
      childs[getChildPos(index)] = createReference(report);
    }
}

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