org.apache.xmlbeans.XmlSimpleList Maven / Gradle / Ivy
/* Copyright 2004 The Apache Software Foundation
*
* 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.apache.xmlbeans;
import java.util.Iterator;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
/**
* The immutable {@link List} returned for XML simple list values.
*
* XmlSimpleList implements an equals() and hashCode() that compare list
* contents, so two XmlSimpleLists are the same if they have the same
* values in the same order.
*/
public class XmlSimpleList implements List, java.io.Serializable
{
private static final long serialVersionUID = 1L;
private List underlying;
/**
* Constructs an immutable XmlSimpleList that wraps (does not copy)
* the given {@link List}. All non-mutating methods delegate to
* the underlying List instance.
*/
public XmlSimpleList(List list) { this.underlying = list; }
/** Returns the number of elements in this list. */
public int size() { return underlying.size(); }
/** True if the list is empty. */
public boolean isEmpty() { return underlying.isEmpty(); }
/** True if the list is contains an object equal to o. */
public boolean contains(Object o) { return underlying.contains(o); }
/** True if the list is contains all the objects in the given collection. */
public boolean containsAll(Collection coll) { return underlying.containsAll(coll); }
/** Copies the collection to an array. */
public Object[] toArray() { return underlying.toArray(); }
/** Copies the collection to an array of a specified type. */
public Object[] toArray(Object[] a) { return underlying.toArray(a); }
/** Unsupported because this list is immutable. */
public boolean add(Object o) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public boolean addAll(Collection coll) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public boolean remove(Object o) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public boolean removeAll(Collection coll) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public boolean retainAll(Collection coll) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public void clear() { throw new UnsupportedOperationException(); }
/** Returns the object at the specified position in this list. */
public Object get(int index) { return underlying.get(index); }
/** Unsupported because this list is immutable. */
public Object set(int index, Object element) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public void add(int index, Object element) { throw new UnsupportedOperationException(); }
/** Unsupported because this list is immutable. */
public Object remove(int index) { throw new UnsupportedOperationException(); }
/** Returns index of the first occurance of an object equal to o. */
public int indexOf(Object o) { return underlying.indexOf(o); }
/** Returns index of the last occurance of an object equal to o. */
public int lastIndexOf(Object o) { return underlying.lastIndexOf(o); }
/** Unsupported because this list is immutable. */
public boolean addAll(int index, Collection c) { throw new UnsupportedOperationException(); }
/** Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. */
public List subList(int from, int to) { return new XmlSimpleList(underlying.subList(from, to)); }
/** Returns an iterator over the elements in this list in proper sequence. */
public Iterator iterator()
{
return new Iterator()
{
Iterator i = underlying.iterator();
public boolean hasNext() { return i.hasNext(); }
public Object next() { return i.next(); }
public void remove() { throw new UnsupportedOperationException(); }
};
}
/** Returns a list iterator of the elements in this list in proper sequence. */
public ListIterator listIterator() { return listIterator(0); }
/** Returns a list iterator of the elements in this list in proper sequence, starting at the specified position in this list. */
public ListIterator listIterator(final int index)
{
return new ListIterator()
{
ListIterator i = underlying.listIterator(index);
public boolean hasNext() { return i.hasNext(); }
public Object next() { return i.next(); }
public boolean hasPrevious(){ return i.hasPrevious(); }
public Object previous() { return i.previous(); }
public int nextIndex() { return i.nextIndex(); }
public int previousIndex() { return i.previousIndex(); }
public void remove() { throw new UnsupportedOperationException(); }
public void set(Object o) { throw new UnsupportedOperationException(); }
public void add(Object o) { throw new UnsupportedOperationException(); }
};
}
private String stringValue(Object o)
{
if (o instanceof SimpleValue)
return ((SimpleValue)o).stringValue();
return o.toString();
}
/**
* Returns a space-separated list of the string representations of all
* the items in the list. For most lists, this is a valid xml lexical
* value for the list. (The notable exception is a list of QNames.)
*/
public String toString()
{
int size = underlying.size();
if (size == 0)
return "";
String first = stringValue(underlying.get(0));
if (size == 1)
return first;
StringBuffer result = new StringBuffer(first);
for (int i = 1; i < size; i++)
{
result.append(' ');
result.append(stringValue(underlying.get(i)));
}
return result.toString();
}
/**
* Two XmlSimpleLists are equal if all their items are equal.
* (They must have the same number of items, and the items must be in
* the same order.)
*/
public boolean equals(Object o)
{
if (this == o) return true;
if (!(o instanceof XmlSimpleList)) return false;
final XmlSimpleList xmlSimpleList = (XmlSimpleList)o;
List underlying2 = xmlSimpleList.underlying;
int size = underlying.size();
if (size != underlying2.size())
return false;
for (int i = 0; i < size; i++)
{
Object item = underlying.get(i);
Object item2 = underlying2.get(i);
if (item == null ? item2 != null : !item.equals(item2))
return false;
}
return true;
}
/**
* Combines the hash codes of all the list items.
*/
public int hashCode()
{
int size = underlying.size();
int hash = 0;
for (int i = 0; i < size; i++)
{
Object item = underlying.get(i);
hash *= 19;
hash += item.hashCode();
}
return hash;
}
}