Show LazySet.java syntax highlighted
/*
* LazySet.java
*
* Created on November 28, 2006, 9:02 AM
*
* Description: Provides a means to lazily load a Set field.
*
* Copyright (C) 2006 Stephen L. Reed.
*
* This program is free software; you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program;
* if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
package org.texai.kb.persistence.lazy;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import org.texai.kb.ejb.session.DomainEntityLoaderLocal;
import org.texai.kb.persistence.DomainProperty;
import org.texai.util.TexaiException;
/**
*
* @author reed
*/
public final class LazySet implements Set {
/** the domain entity loader */
private final DomainEntityLoaderLocal domainEntityLoader;
/** the domain instance */
private final Object domainEntity;
/** the domain instance field */
private final Field field;
/** the domain property */
private final DomainProperty domainProperty;
/** the loaded set */
private Set loadedSet;
/** the indicator that the lazy set is currently being loaded */
private boolean isLoading = false;
/** the indicator that domain entities can be loaded from the cache */
private final boolean isLoadableFromDomainEntityCache;
/**
* Creates a new instance of LazySet.
*
* @param domainEntityLoader the domain entity loader
* @param domainInstance the domain instance
* @param field the domain instance field
* @param domainProperty the domain property
* @param isLoadableFromDomainEntityCache the indicator that domain entities can be loaded from the cache
*/
public LazySet(
final DomainEntityLoaderLocal domainEntityLoader,
final Object domainInstance,
final Field field,
final DomainProperty domainProperty,
final boolean isLoadableFromDomainEntityCache) {
super();
//Preconditions
assert domainEntityLoader != null : "domainEntityLoader must not be null";
assert domainInstance != null : "domainInstance must not be null";
assert field != null : "field must not be null";
assert domainProperty != null : "domainProperty must not be null";
this.domainEntityLoader = domainEntityLoader;
this.domainEntity = domainInstance;
this.field = field;
this.domainProperty = domainProperty;
this.isLoadableFromDomainEntityCache = isLoadableFromDomainEntityCache;
}
/** Gets the domain entity loader.
*
* @return the domain entity loader
*/
public DomainEntityLoaderLocal getDomainEntityLoader() {
return domainEntityLoader;
}
/** Gets the domain instance.
*
* @return the domain instance
*/
public Object getDomainInstance() {
return domainEntity;
}
/** Gets the domain instance field.
*
* @return the domain instance field
*/
public Field getField() {
return field;
}
/** Gets the domain property.
*
* @return the domain property
*/
public DomainProperty getDomainProperty() {
return domainProperty;
}
/** Lazily loads the set. Also replaces the lazy set with the loaded set on the domain entity so that subsequent
* field value will directly access the set.
*/
@SuppressWarnings("unchecked")
private void loadTheSet() {
if (!isLoading && loadedSet == null) {
isLoading = true;
loadedSet = (Set) domainEntityLoader.loadDomainEntityField(
domainEntity,
field,
domainProperty,
isLoadableFromDomainEntityCache);
assert loadedSet != null : "loadedSet must not be null";
isLoading = false;
}
}
/** Returns whether this lazy set is in the process of loading.
*
* @return whether this lazy set is in the process of loading
*/
public boolean isLoading() {
return isLoading();
}
/** Returns whether this lazy set is loaded.
*
* @return whether this lazy set is loaded
*/
public boolean isLoaded() {
return !isLoading && loadedSet != null;
}
/**
* Returns a string representation of this object.
*
* @return a string representation of this object
*/
@Override
public String toString() {
if (loadedSet == null) {
return "[LazySet for " + domainProperty + "]";
} else {
return loadedSet.toString();
}
}
// the Set methods
/**
* Returns the number of elements in this set (its cardinality). If this
* set contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this set (its cardinality).
*/
public int size() {
loadTheSet();
if (isLoading) {
return 0;
} else {
return loadedSet.size();
}
}
/**
* Returns <tt>true</tt> if this set contains no elements.
*
* @return <tt>true</tt> if this set contains no elements.
*/
public boolean isEmpty() {
loadTheSet();
if (isLoading) {
return true;
} else {
return loadedSet.isEmpty();
}
}
/**
* Returns <tt>true</tt> if this set contains the specified element. More
* formally, returns <tt>true</tt> if and only if this set contains an
* element <code>e</code> such that <code>(o==null ? e==null :
* o.equals(e))</code>.
*
* @param o element whose presence in this set is to be tested.
* @return <tt>true</tt> if this set contains the specified element.
* @throws ClassCastException if the type of the specified element
* is incompatible with this set (optional).
* @throws NullPointerException if the specified element is null and this
* set does not support null elements (optional).
*/
public boolean contains(final Object o) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.contains(o);
}
}
/**
* Returns an iterator over the elements in this set. The elements are
* returned in no particular order (unless this set is an instance of some
* class that provides a guarantee).
*
* @return an iterator over the elements in this set.
*/
public Iterator iterator() {
if (isLoading) {
return (new ArrayList(0)).iterator();
} else {
loadTheSet();
return loadedSet.iterator();
}
}
/**
* Returns an array containing all of the elements in this set.
* Obeys the general contract of the <tt>Collection.toArray</tt> method.
*
* @return an array containing all of the elements in this set.
*/
public Object[] toArray() {
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.toArray();
}
}
/**
* Returns an array containing all of the elements in this set; the
* runtime type of the returned array is that of the specified array.
* Obeys the general contract of the
* <tt>Collection.toArray(Object[])</tt> method.
*
* @param a the array into which the elements of this set are to
* be stored, if it is big enough; otherwise, a new array of the
* same runtime type is allocated for this purpose.
* @return an array containing the elements of this set.
* @throws ArrayStoreException the runtime type of a is not a supertype
* of the runtime type of every element in this set.
* @throws NullPointerException if the specified array is <tt>null</tt>.
*/
@SuppressWarnings("unchecked")
public Object[] toArray(Object[] a) {
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.toArray(a);
}
}
/**
* Adds the specified element to this set if it is not already present
* (optional operation). More formally, adds the specified element,
* <code>o</code>, to this set if this set contains no element
* <code>e</code> such that <code>(o==null ? e==null :
* o.equals(e))</code>. If this set already contains the specified
* element, the call leaves this set unchanged and returns <tt>false</tt>.
* In combination with the restriction on constructors, this ensures that
* sets never contain duplicate elements.<p>
*
* The stipulation above does not imply that sets must accept all
* elements; sets may refuse to add any particular element, including
* <tt>null</tt>, and throwing an exception, as described in the
* specification for <tt>Collection.add</tt>. Individual set
* implementations should clearly document any restrictions on the
* elements that they may contain.
*
* @param o element to be added to this set.
* @return <tt>true</tt> if this set did not already contain the specified
* element.
*
* @throws UnsupportedOperationException if the <tt>add</tt> method is not
* supported by this set.
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this set.
* @throws NullPointerException if the specified element is null and this
* set does not support null elements.
* @throws IllegalArgumentException if some aspect of the specified element
* prevents it from being added to this set.
*/
@SuppressWarnings("unchecked")
public boolean add(final Object o) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.add(o);
}
}
/**
* Removes the specified element from this set if it is present (optional
* operation). More formally, removes an element <code>e</code> such that
* <code>(o==null ? e==null : o.equals(e))</code>, if the set contains
* such an element. Returns <tt>true</tt> if the set contained the
* specified element (or equivalently, if the set changed as a result of
* the call). (The set will not contain the specified element once the
* call returns.)
*
* @param o object to be removed from this set, if present.
* @return true if the set contained the specified element.
* @throws ClassCastException if the type of the specified element
* is incompatible with this set (optional).
* @throws NullPointerException if the specified element is null and this
* set does not support null elements (optional).
* @throws UnsupportedOperationException if the <tt>remove</tt> method is
* not supported by this set.
*/
public boolean remove(final Object o) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.remove(o);
}
}
/**
* Returns <tt>true</tt> if this set contains all of the elements of the
* specified collection. If the specified collection is also a set, this
* method returns <tt>true</tt> if it is a <i>subset</i> of this set.
*
* @param c collection to be checked for containment in this set.
* @return <tt>true</tt> if this set contains all of the elements of the
* specified collection.
* @throws ClassCastException if the types of one or more elements
* in the specified collection are incompatible with this
* set (optional).
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not support null
* elements (optional).
* @throws NullPointerException if the specified collection is
* <tt>null</tt>.
* @see #contains(Object)
*/
@SuppressWarnings("unchecked")
public boolean containsAll(final Collection c) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.containsAll(c);
}
}
/**
* Adds all of the elements in the specified collection to this set if
* they're not already present (optional operation). If the specified
* collection is also a set, the <tt>addAll</tt> operation effectively
* modifies this set so that its value is the <i>union</i> of the two
* sets. The behavior of this operation is unspecified if the specified
* collection is modified while the operation is in progress.
*
* @param c collection whose elements are to be added to this set.
* @return <tt>true</tt> if this set changed as a result of the call.
*
* @throws UnsupportedOperationException if the <tt>addAll</tt> method is
* not supported by this set.
* @throws ClassCastException if the class of some element of the
* specified collection prevents it from being added to this
* set.
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not support null
* elements, or if the specified collection is <tt>null</tt>.
* @throws IllegalArgumentException if some aspect of some element of the
* specified collection prevents it from being added to this
* set.
* @see #add(Object)
*/
@SuppressWarnings("unchecked")
public boolean addAll(final Collection c) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.addAll(c);
}
}
/**
* Retains only the elements in this set that are contained in the
* specified collection (optional operation). In other words, removes
* from this set all of its elements that are not contained in the
* specified collection. If the specified collection is also a set, this
* operation effectively modifies this set so that its value is the
* <i>intersection</i> of the two sets.
*
* @param c collection that defines which elements this set will retain.
* @return <tt>true</tt> if this collection changed as a result of the
* call.
* @throws UnsupportedOperationException if the <tt>retainAll</tt> method
* is not supported by this Collection.
* @throws ClassCastException if the types of one or more elements in this
* set are incompatible with the specified collection
* (optional).
* @throws NullPointerException if this set contains a null element and
* the specified collection does not support null elements
* (optional).
* @throws NullPointerException if the specified collection is
* <tt>null</tt>.
* @see #remove(Object)
*/
@SuppressWarnings("unchecked")
public boolean retainAll(final Collection c) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.retainAll(c);
}
}
/**
* Removes from this set all of its elements that are contained in the
* specified collection (optional operation). If the specified
* collection is also a set, this operation effectively modifies this
* set so that its value is the <i>asymmetric set difference</i> of
* the two sets.
*
* @param c collection that defines which elements will be removed from
* this set.
* @return <tt>true</tt> if this set changed as a result of the call.
*
* @throws UnsupportedOperationException if the <tt>removeAll</tt>
* method is not supported by this Collection.
* @throws ClassCastException if the types of one or more elements in this
* set are incompatible with the specified collection
* (optional).
* @throws NullPointerException if this set contains a null element and
* the specified collection does not support null elements
* (optional).
* @throws NullPointerException if the specified collection is
* <tt>null</tt>.
* @see #remove(Object)
*/
@SuppressWarnings("unchecked")
public boolean removeAll(final Collection c) { // NOPMD
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
return loadedSet.removeAll(c);
}
}
/**
* Removes all of the elements from this set (optional operation).
* This set will be empty after this call returns (unless it throws an
* exception).
*
* @throws UnsupportedOperationException if the <tt>clear</tt> method
* is not supported by this set.
*/
public void clear() {
if (isLoading) {
throw new TexaiException("recursive call while loading lazy list");
} else {
loadTheSet();
loadedSet.clear();
}
}
/**
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the specified object is also a set, the two sets
* have the same size, and every member of the specified set is
* contained in this set (or equivalently, every member of this set is
* contained in the specified set). This definition ensures that the
* equals method works properly across different implementations of the
* set interface.
*
* @param o Object to be compared for equality with this set.
* @return <tt>true</tt> if the specified Object is equal to this set.
*/
@Override
public boolean equals(final Object o) { // NOPMD
if (isLoading) {
return this.equals(o);
} else {
loadTheSet();
return loadedSet.equals(o);
}
}
/**
*
* Returns the hash code value for this set. The hash code of a set is
* defined to be the sum of the hash codes of the elements in the set,
* where the hashcode of a <tt>null</tt> element is defined to be zero.
* This ensures that <code>s1.equals(s2)</code> implies that
* <code>s1.hashCode()==s2.hashCode()</code> for any two sets
* <code>s1</code> and <code>s2</code>, as required by the general
* contract of the <tt>Object.hashCode</tt> method.
*
* @return the hash code value for this set.
* @see Object#hashCode()
* @see Object#equals(Object)
* @see Set#equals(Object)
*/
@Override
public int hashCode() {
if (isLoading) {
return this.hashCode();
} else {
loadTheSet();
return loadedSet.hashCode();
}
}
}
See more files for this project here