Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

initial commit. 

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/collections/trunk@130704 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Arron Claude Bates 2002-05-29 02:57:41 +00:00
parent 1e22afa5b0
commit 2dd5130b2c
3 changed files with 852 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
src/java/org/apache/commons/collections/FactoryUtils.java Normal file
View File

@ -0,0 +1,177 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/FactoryUtils.java,v 1.1 2002/05/29 02:57:41 arron Exp $
* $Revision: 1.1 $
* $Date: 2002/05/29 02:57:41 $
* ====================================================================
*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999-2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Struts", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
*/
package org.apache.commons.collections;
import java.util.*;
import java.lang.reflect.*;
/**
* A Factory for the creation of Factories. This is more of the factory
* "pattern" by definition, but what it creates, is objects which subscribe to
* a factory interface which other systems can rely on them to manufacture
* objects.
*
* @author Arron Bates
* @version $Revision: 1.1 $
*/
public class FactoryUtils {
/** Creates a SimpleObjectFactory whith a class definition, which will be
* used to create a new object from an empty constructor.
*
* @param inClass class definition which will be ued to create the new object
* @return the simple object factory.
*/
public static SimpleObjectFactory createStandardFactory(Class inClass) {
return new StandardFactory(inClass);
}
/** Creates a SimpleObjectFactory whith the class definition and argument
* details, which can create a new object from a constructor which requires
* arguments.
*
* @param inClass class definition which will be ued to create the new object
* @param argTypes argument class types for the constructor
* @param argObjects the objects for the arguments themselves
* @return the simple object factory.
*/
public static SimpleObjectFactory createStandardFactory(Class inClass,
Class[] argTypes,
Object[] argObjects) {
return new StandardFactory(inClass, argTypes, argObjects);
}
/* A simple factory, which takes the bare bones of object creation to do just
* that, create new objects.
*/
private static class StandardFactory implements SimpleObjectFactory {
/* builds the object factory. The class definition can creat objects which
* have no-argument constructors.
*/
public StandardFactory(Class inClass) {
this.classDefinition = inClass;
}
/* builds the object factory taking all the options needed to provide
* arguments to a constructor.
*/
public StandardFactory(Class inClass, Class[] argTypes, Object[] argObjects) {
this(inClass);
this.argTypes = argTypes;
this.argObjects = argObjects;
}
/* This method is the beast that creates the new objects. Problem faced is that
* the Exceptions thrown are all RuntimeExceptions, meaning that for this class
* to be used as a java.util.Map implementation itself, it has to guide the
* exceptions as the runtime excpetions commonly thrown by these objects.
*
* Thinly disguising the error as a null pointer, with a modified message for
* debugging.
*/
public Object createObject() {
Object obj = null;
/* for catching error specifics */
String fubar = null;
try {
if ((argTypes == null) || (argObjects == null)) {
/* no arguments, make object with empty constructor */
obj = this.classDefinition.newInstance();
} else {
/* construct object with argument details */
Constructor constructor = this.classDefinition.getConstructor(argTypes);
obj = constructor.newInstance(argObjects);
}
} catch (InstantiationException ex) {
fubar = ex.getMessage();
} catch (IllegalAccessException ex) {
fubar = ex.getMessage();
} catch (IllegalArgumentException ex) {
fubar = ex.getMessage();
} catch (NoSuchMethodException ex) {
fubar = ex.getMessage();
} catch (InvocationTargetException ex) {
fubar = ex.getMessage();
}
/* fake our Exception if required */
if (fubar != null) {
/* guise the error as a more typical error */
throw new NullPointerException("Failed object creation :: "+ fubar +"\n");
}
return obj;
}
/* class definition for new object creation */
private Class classDefinition;
/* construcor details, optional */
private Class[] argTypes;
private Object[] argObjects;
}
}

594
src/java/org/apache/commons/collections/LazyCollections.java Normal file
View File

@ -0,0 +1,594 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/Attic/LazyCollections.java,v 1.1 2002/05/29 02:57:41 arron Exp $
* $Revision: 1.1 $
* $Date: 2002/05/29 02:57:41 $
* ====================================================================
*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999-2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Struts", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
*/
package org.apache.commons.collections;
import java.util.*;
import java.lang.reflect.*;
/**
* This is the factory manager for the lazy object creation collections. The
* collections are within package scope only, so factory creation can be
* standardised for these collections, and to provide a more convenient single
* point entry for their use.
*
* Use the static factory methods to wrap your various collections in the Lazy
* implementations so they can creat objects for incomming requestes.
*
* This class also holds the standard object factory, which has the means to
* create simply the objects for the incomming requests. If all you need is a
* new class built from an empty constructor, then all you need to provide is
* the class definition.
*
* @see org.apache.commons.collections.LazyList
* @see org.apache.commons.collections.LazyMap
* @see org.apache.commons.collections.LazySortedMap
*
* @author Arron Bates
* @version $Revision: 1.1 $
*/
public class LazyCollections {
/** Creates a LazyMap whith the provided object factory.
*
* @param inMap the java.util.Map implementation we have to wrap.
* @param factory SimpleObjectFactory for new object creation
* @return the wrapped Map reference
*/
public static Map lazyMap(Map inMap, SimpleObjectFactory factory) {
/* creates a new lazy map with the provided factory */
return new LazyMap(inMap, factory);
}
/** Creates a LazyMap whith the class definition, which will be used to create
* a SimpleObjectFactory which will create a new object from an empty
* constructor.
*
* @param inMap the java.util.Map implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @return the wrapped Map reference
*/
public static Map lazyMap(Map inMap, Class inClass) {
/* creates a new lazy map with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass);
return new LazyMap(inMap, f);
}
/** Creates a LazyMap whith the class definition and argument details, which
* will be used to create a SimpleObjectFactory which will create a new object
* from a constructor which requires arguments.
*
* @param inMap the java.util.Map implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @param argTypes argument class types for the constructor
* @param argObjects the objects for the arguments themselves
* @return the wrapped Map reference
*/
public static Map lazyMap(Map inMap, Class inClass, Class[] argTypes,
Object[] argObjects) {
/* creates a new lazy map with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass, argTypes, argObjects);
return new LazyMap(inMap, f);
}
/** Creates a LazySortedMap whith the provided object factory.
*
* @param inMap the java.util.SortedMap implementation we have to wrap.
* @param factory SimpleObjectFactory for new object creation
* @return the wrapped SortedMap reference
*/
public static SortedMap lazySortedMap(SortedMap inMap,
SimpleObjectFactory factory) {
/* creates a new lazy sorted map with the provided factory */
return new LazySortedMap(inMap, factory);
}
/** Creates a LazySortedMap whith the class definition, which will be used to
* create a SimpleObjectFactory which will create a new object from an empty
* constructor.
*
* @param inMap the java.util.SortedMap implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @return the wrapped SortedMap reference
*/
public static SortedMap lazySortedMap(SortedMap inMap, Class inClass) {
/* creates a new lazy sorted map with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass);
return new LazySortedMap(inMap, f);
}
/** Creates a LazySortedMap whith the class definition and argument details,
* which will be used to create a SimpleObjectFactory which will create a new
* object from a constructor which requires arguments.
*
* @param inMap the java.util.SortedMap implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @param argTypes argument class types for the constructor
* @param argObjects the objects for the arguments themselves
* @return the wrapped SortedMap reference
*/
public static SortedMap lazySortedMap(SortedMap inMap, Class inClass,
Class[] argTypes, Object[] argObjects) {
/* creates a new lazy sorted map with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass, argTypes, argObjects);
return new LazySortedMap(inMap, f);
}
/** Creates a LazyList whith the provided object factory.
*
* @param inMap the java.util.List implementation we have to wrap.
* @param factory SimpleObjectFactory for new object creation
* @return the wrapped List reference
*/
public static List lazyList(List inList, SimpleObjectFactory factory) {
/* creates a new lazy list with the provided factory */
return new LazyList(inList, factory);
}
/** Creates a LazyList whith the class definition, which will be used to
* create a SimpleObjectFactory which will create a new object from an empty
* constructor.
*
* @param inMap the java.util.List implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @return the wrapped List reference
*/
public static List lazyList(List inList, Class inClass) {
/* creates a new lazy list with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass);
return new LazyList(inList, f);
}
/** Creates a LazyList whith the class definition and argument details,
* which will be used to create a SimpleObjectFactory which will create a new
* object from a constructor which requires arguments.
*
* @param inMap the java.util.List implementation we have to wrap.
* @param inClass class definition which will be ued to create the new object
* @param argTypes argument class types for the constructor
* @param argObjects the objects for the arguments themselves
* @return the wrapped List reference
*/
public static List lazyList(List inList, Class inClass, Class[] argTypes,
Object[] argObjects) {
/* creates a new lazy list with a new object factory */
SimpleObjectFactory f = FactoryUtils.createStandardFactory(inClass, argTypes, argObjects);
return new LazyList(inList, f);
}
/** Cleans a List implementation from nulls. Because a rampant index up the
* line can create many nulls. At some point, the collection has to become
* useful outside of reliable index use. clean() does this.
*
* @param inList Lsit to rip the nulls out of
*/
public static void clean(List inList) {
/* loop through backwards, removing out any nulls found */
for (int i = (inList.size()-1); i >= 0; i--) {
if (inList.get(i) == null) {
inList.remove(i);
}
}
}
/* This is a java.util.List implementation which provides the means of objects
* when requested. When a system expects an object to be provided when accessed
* via an index, this collection has been provided the rules (factory reference)
* to create an object, add it to the list and return it to the request.
*
* For example, when a request comes into the Struts controller for a bean, it
* will created the bean. These request references can be indexed or mapped.
* Problem for many reasons is that there is not an object waiting within the
* session object. To recieve these updates, objects have to be created from the
* collections that hold them.
*
* Only issue for lists, is that indexes will most often ben requested outside
* the boulds of the list. This implementation will pack the spaces with null
* objects. To make the list useful to business logic, a call to
* <code>clean()</code> will clear the list of these null references.
*/
private static class LazyList implements List {
/* Builds a LazyList with the provided SimpleObjectFactory as the means of
* creating the objects.
*/
public LazyList(List inList, SimpleObjectFactory factory) {
this.listImpl = inList;
this.factory = factory;
}
/* Proxy method to the impl's get method. With the exception that if it's out
* of bounds, then the collection will grow, leaving place-holders in its
* wake, so that an item can be set at any given index. Later the
* place-holders are removed to return to a pure collection.
*
* If there's a place-holder at the index, then it's replaced with a proper
* object to be used.
*/
public Object get(int index) {
Object obj;
int size = listImpl.size();
if (index < this.listImpl.size()) {
/* within bounds, get the object */
obj = this.listImpl.get(index);
if (obj == null) {
/* item is a place holder, create new one, set and return */
obj = this.factory.createObject();
this.listImpl.set(index, obj);
return obj;
} else {
/* good and ready to go */
return obj;
}
} else {
/* we have to grow the list */
for (int i = this.listImpl.size(); i < (this.listImpl.size()-1); i++) {
this.listImpl.add(null);
}
/* create our last object, set and return */
obj = this.factory.createObject();
this.listImpl.add(obj);
return obj;
}
}
/* proxy the call to the provided list implementation. */
public List subList(int fromIndex, int toIndex) {
/* wrap the returned sublist so it can continue the functionality */
return new LazyList(this.listImpl.subList(fromIndex, toIndex), factory);
}
/* proxy the call to the provided list implementation.*/
public int size() {
return this.listImpl.size();
}
/* proxy the call to the provided list implementation. */
public boolean isEmpty() {
return this.listImpl.isEmpty();
}
/* proxy the call to the provided list implementation. */
public boolean contains(Object o) {
return this.listImpl.contains(o);
}
/* proxy the call to the provided list implementation. */
public Iterator iterator() {
return this.listImpl.iterator();
}
/* proxy the call to the provided list implementation. */
public Object[] toArray() {
return this.listImpl.toArray();
}
/* proxy the call to the provided list implementation. */
public Object[] toArray(Object[] a) {
return this.listImpl.toArray(a);
}
/* proxy the call to the provided list implementation. */
public boolean add(Object o) {
return this.listImpl.add(o);
}
/* proxy the call to the provided list implementation. */
public boolean remove(Object o) {
return this.listImpl.remove(o);
}
/* proxy the call to the provided list implementation. */
public boolean containsAll(Collection c) {
return this.listImpl.containsAll(c);
}
/* proxy the call to the provided list implementation. */
public boolean addAll(Collection c) {
return this.listImpl.addAll(c);
}
/* proxy the call to the provided list implementation. */
public boolean addAll(int index, Collection c) {
return this.listImpl.addAll(index, c);
}
/* proxy the call to the provided list implementation. */
public boolean removeAll(Collection c) {
return this.listImpl.removeAll(c);
}
/* proxy the call to the provided list implementation. */
public boolean retainAll(Collection c) {
return this.listImpl.retainAll(c);
}
/* proxy the call to the provided list implementation. */
public void clear() {
this.listImpl.clear();
}
/* proxy the call to the provided list implementation. */
public Object set(int index, Object element) {
return this.listImpl.set(index, element);
}
/* proxy the call to the provided list implementation. */
public void add(int index, Object element) {
this.listImpl.add(index, element);
}
/* proxy the call to the provided list implementation. */
public Object remove(int index) {
return this.listImpl.remove(index);
}
/* proxy the call to the provided list implementation. */
public int indexOf(Object o) {
return this.listImpl.indexOf(o);
}
/* proxy the call to the provided list implementation. */
public int lastIndexOf(Object o) {
return this.listImpl.lastIndexOf(o);
}
/* proxy the call to the provided list implementation. */
public ListIterator listIterator() {
return this.listImpl.listIterator();
}
/* proxy the call to the provided list implementation. */
public ListIterator listIterator(int index) {
return this.listImpl.listIterator(index);
}
/* java.util.List implementation to proxy against */
private List listImpl;
/* optional object factory */
private SimpleObjectFactory factory;
}
/* This is a java.util.Map implementation which provides the means of objects
* when requested. When a system expects an object to be provided when accessed
* via a key, this collection has been provided the rules (factory reference)
* to create an object, add it to the map and return it to the request.
*
* For example, when a request comes into the Struts controller for a bean, it
* will created the bean. These request references can be indexed or mapped.
* Problem for many reasons is that there is not an object waiting within the
* session object. To recieve these updates, objects have to be created from the
* collections that hold them.
*/
private static class LazyMap implements Map {
/* Builds a LazyMap with the provided SimpleObjectFactory as the means of
* creating the objects.
*/
public LazyMap(Map inMap, SimpleObjectFactory factory) {
this.mapImpl = inMap;
this.factory = factory;
}
/* Proxy method to the impl's get method. With the exception that if there
* is no keyed object waiting for it, an object will be created, set and
* returned.
*/
public Object get(Object key) {
Object obj = this.mapImpl.get(key);
if (obj == null) {
/* create our last object, set and return */
obj = this.factory.createObject();
this.mapImpl.put(key, obj);
}
return obj;
}
/* proxy the call to the provided Map implementation. */
public int size() {
return this.mapImpl.size();
}
/* proxy the call to the provided Map implementation. */
public boolean isEmpty() {
return this.mapImpl.isEmpty();
}
/* proxy the call to the provided Map implementation. */
public boolean containsKey(Object key) {
return this.mapImpl.containsKey(key);
}
/* proxy the call to the provided Map implementation. */
public boolean containsValue(Object value) {
return this.mapImpl.containsValue(value);
}
/* proxy the call to the provided Map implementation. */
public Object put(Object key, Object value) {
return this.mapImpl.put(key, value);
}
/* proxy the call to the provided Map implementation. */
public Object remove(Object key) {
return this.mapImpl.remove(key);
}
/* proxy the call to the provided Map implementation. */
public void putAll(Map t) {
this.mapImpl.putAll(t);
}
/* proxy the call to the provided Map implementation. */
public void clear() {
this.mapImpl.clear();
}
/* proxy the call to the provided Map implementation. */
public Set keySet() {
return this.mapImpl.keySet();
}
/* proxy the call to the provided Map implementation. */
public Collection values() {
return this.mapImpl.values();
}
/* proxy the call to the provided Map implementation. */
public Set entrySet() {
return this.mapImpl.entrySet();
}
/* proxy the call to the provided Map implementation. */
public boolean equals(Object o) {
return this.mapImpl.equals(o);
}
/* proxy the call to the provided Map implementation. */
public int hashCode() {
return this.mapImpl.hashCode();
}
/* java.util.Map implementation to proxy against */
protected Map mapImpl;
/* optional object factory */
protected SimpleObjectFactory factory;
}
/* This is a java.util.SortedMap implementation which provides the means of objects
* when requested. When a system expects an object to be provided when accessed
* via a key, this collection has been provided the rules (factory reference)
* to create an object, add it to the map and return it to the request.
*
* For example, when a request comes into the Struts controller for a bean, it
* will created the bean. These request references can be indexed or mapped.
* Problem for many reasons is that there is not an object waiting within the
* session object. To recieve these updates, objects have to be created from the
* collections that hold them.
*/
private static class LazySortedMap extends LazyMap implements SortedMap {
/* Builds a LazySortedMap with the provided SimpleObjectFactory as the means of
* creating the objects.
*/
public LazySortedMap(SortedMap inMap, SimpleObjectFactory factory) {
super(inMap, factory);
}
/* proxy the call to the provided LazySortedMap implementation. */
public Comparator comparator() {
return ((SortedMap)super.mapImpl).comparator();
}
/* proxy the call to the provided LazySortedMap implementation. */
public SortedMap subMap(Object fromKey, Object toKey) {
SortedMap subby = ((SortedMap)super.mapImpl).subMap(fromKey, toKey);
return new LazySortedMap(subby, super.factory);
}
/* proxy the call to the provided LazySortedMap implementation. */
public SortedMap headMap(Object toKey) {
SortedMap heady = ((SortedMap)super.mapImpl).headMap(toKey);
return new LazySortedMap(heady, super.factory);
}
/* proxy the call to the provided LazySortedMap implementation. */
public SortedMap tailMap(Object fromKey) {
SortedMap tailer = ((SortedMap)super.mapImpl).tailMap(fromKey);
return new LazySortedMap(tailer, super.factory);
}
/* proxy the call to the provided LazySortedMap implementation. */
public Object firstKey() {
return ((SortedMap)super.mapImpl).firstKey();
}
/* proxy the call to the provided LazySortedMap implementation. */
public Object lastKey() {
return ((SortedMap)super.mapImpl).lastKey();
}
}
}

81
src/java/org/apache/commons/collections/SimpleObjectFactory.java Normal file
View File

@ -0,0 +1,81 @@
/*
* $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/java/org/apache/commons/collections/Attic/SimpleObjectFactory.java,v 1.1 2002/05/29 02:57:41 arron Exp $
* $Revision: 1.1 $
* $Date: 2002/05/29 02:57:41 $
* ====================================================================
*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999-2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Struts", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
*/
package org.apache.commons.collections;
import java.util.*;
import java.lang.reflect.*;
/**
* SimpleObjectFactory
* A simple interface that describes the most basic means of having the ability
* to create an object.
*
* @author Arron Bates
* @version $Revision: 1.1 $
*/
public interface SimpleObjectFactory {
/** Simple method from which will come the new object from the factory.
*
* @return Object reference to the new object.
*/
public Object createObject();
}