Spring Framework example source code file (AutoPopulatingList.java)

This example Spring Framework source code file (AutoPopulatingList.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Spring Framework tags/keywords

arraylist, autopopulatinglist, autopopulatinglist, element, elementfactory, elementfactory, elementinstantiationexception, elementinstantiationexception, io, list, listiterator, object, object, reflection, reflectiveelementfactory, serializable, util

The Spring Framework AutoPopulatingList.java source code

/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.util;

import java.io.Serializable;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * Simple {@link List} wrapper class that allows for elements to be
 * automatically populated as they are requested. This is particularly
 * useful for data binding to {@link List Lists}, allowing for elements
 * to be created and added to the {@link List} in a "just in time" fashion.
 *
 * <p>Note: This class is not thread-safe. To create a thread-safe version,
 * use the {@link java.util.Collections#synchronizedList} utility methods.
 *
 * <p>Inspired by LazyList from Commons Collections.
 *
 * @author Rob Harrop
 * @author Juergen Hoeller
 * @since 2.0
 */
public class AutoPopulatingList implements List, Serializable {

	/**
	 * The {@link List} that all operations are eventually delegated to.
	 */
	private final List backingList;

	/**
	 * The {@link ElementFactory} to use to create new {@link List} elements
	 * on demand.
	 */
	private final ElementFactory elementFactory;


	/**
	 * Creates a new <code>AutoPopulatingList that is backed by a standard
	 * {@link ArrayList} and adds new instances of the supplied {@link Class element Class}
	 * to the backing {@link List} on demand.
	 */
	public AutoPopulatingList(Class elementClass) {
		this(new ArrayList(), elementClass);
	}

	/**
	 * Creates a new <code>AutoPopulatingList that is backed by the supplied {@link List}
	 * and adds new instances of the supplied {@link Class element Class} to the backing
	 * {@link List} on demand.
	 */
	public AutoPopulatingList(List backingList, Class elementClass) {
		this(backingList, new ReflectiveElementFactory(elementClass));
	}

	/**
	 * Creates a new <code>AutoPopulatingList that is backed by a standard
	 * {@link ArrayList} and creates new elements on demand using the supplied {@link ElementFactory}.
	 */
	public AutoPopulatingList(ElementFactory elementFactory) {
		this(new ArrayList(), elementFactory);
	}

	/**
	 * Creates a new <code>AutoPopulatingList that is backed by the supplied {@link List}
	 * and creates new elements on demand using the supplied {@link ElementFactory}.
	 */
	public AutoPopulatingList(List backingList, ElementFactory elementFactory) {
		Assert.notNull(backingList, "Backing List must not be null");
		Assert.notNull(elementFactory, "Element factory must not be null");
		this.backingList = backingList;
		this.elementFactory = elementFactory;
	}


	public void add(int index, Object element) {
		this.backingList.add(index, element);
	}

	public boolean add(Object o) {
		return this.backingList.add(o);
	}

	public boolean addAll(Collection c) {
		return this.backingList.addAll(c);
	}

	public boolean addAll(int index, Collection c) {
		return this.backingList.addAll(index, c);
	}

	public void clear() {
		this.backingList.clear();
	}

	public boolean contains(Object o) {
		return this.backingList.contains(o);
	}

	public boolean containsAll(Collection c) {
		return this.backingList.containsAll(c);
	}

	public boolean equals(Object o) {
		return this.backingList.equals(o);
	}

	/**
	 * Get the element at the supplied index, creating it if there is
	 * no element at that index.
	 */
	public Object get(int index) {
		int backingListSize = this.backingList.size();

		Object element = null;
		if (index < backingListSize) {
			element = this.backingList.get(index);
			if (element == null) {
				element = this.elementFactory.createElement(index);
				this.backingList.set(index, element);
			}
		}
		else {
			for (int x = backingListSize; x < index; x++) {
				this.backingList.add(null);
			}
			element = this.elementFactory.createElement(index);
			this.backingList.add(element);
		}
		return element;
	}

	public int hashCode() {
		return this.backingList.hashCode();
	}

	public int indexOf(Object o) {
		return this.backingList.indexOf(o);
	}

	public boolean isEmpty() {
		return this.backingList.isEmpty();
	}

	public Iterator iterator() {
		return this.backingList.iterator();
	}

	public int lastIndexOf(Object o) {
		return this.backingList.lastIndexOf(o);
	}

	public ListIterator listIterator() {
		return this.backingList.listIterator();
	}

	public ListIterator listIterator(int index) {
		return this.backingList.listIterator(index);
	}

	public Object remove(int index) {
		return this.backingList.remove(index);
	}

	public boolean remove(Object o) {
		return this.backingList.remove(o);
	}

	public boolean removeAll(Collection c) {
		return this.backingList.removeAll(c);
	}

	public boolean retainAll(Collection c) {
		return this.backingList.retainAll(c);
	}

	public Object set(int index, Object element) {
		return this.backingList.set(index, element);
	}

	public int size() {
		return this.backingList.size();
	}

	public List subList(int fromIndex, int toIndex) {
		return this.backingList.subList(fromIndex, toIndex);
	}

	public Object[] toArray() {
		return this.backingList.toArray();
	}

	public Object[] toArray(Object[] a) {
		return this.backingList.toArray(a);
	}


	/**
	 * Factory interface for creating elements for an index-based access
	 * data structure such as a {@link java.util.List}.
	 */
	public interface ElementFactory {

		/**
		 * Create the element for the supplied index.
		 * @return the element object
		 * @throws ElementInstantiationException if the instantiation process failed
		 * (any exception thrown by a target constructor should be propagated as-is)
		 */
		Object createElement(int index) throws ElementInstantiationException;
	}


	/**
	 * Exception to be thrown from ElementFactory.
	 */
	public static class ElementInstantiationException extends RuntimeException {

		public ElementInstantiationException(String msg) {
			super(msg);
		}
	}


	/**
	 * Reflective implementation of the ElementFactory interface,
	 * using <code>Class.newInstance() on a given element class.
	 * @see java.lang.Class#newInstance()
	 */
	private static class ReflectiveElementFactory implements ElementFactory, Serializable {

		private final Class elementClass;

		public ReflectiveElementFactory(Class elementClass) {
			Assert.notNull(elementClass, "Element clas must not be null");
			Assert.isTrue(!elementClass.isInterface(), "Element class must not be an interface type");
			Assert.isTrue(!Modifier.isAbstract(elementClass.getModifiers()), "Element class cannot be an abstract class");
			this.elementClass = elementClass;
		}

		public Object createElement(int index) {
			try {
				return this.elementClass.newInstance();
			}
			catch (InstantiationException ex) {
				throw new ElementInstantiationException("Unable to instantiate element class [" +
						this.elementClass.getName() + "]. Root cause is " + ex);
			}
			catch (IllegalAccessException ex) {
				throw new ElementInstantiationException("Cannot access element class [" +
						this.elementClass.getName() + "]. Root cause is " + ex);
			}
		}
	}

}