org.apache.xmlbeans.XmlSimpleList Maven / Gradle / Ivy
Show all versions of aem-sdk-api Show documentation
/* 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.*;
/**
* 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 final 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(new Object[0]);
}
/**
* Copies the collection to an array of a specified type.
*/
@SuppressWarnings("SuspiciousToArrayCall")
public X[] toArray(X[] 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 T get(int index) {
return underlying.get(index);
}
/**
* Unsupported because this list is immutable.
*/
public T set(int index, T 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 T 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() {
final Iterator i = underlying.iterator();
public boolean hasNext() {
return i.hasNext();
}
public T 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() {
final ListIterator i = underlying.listIterator(index);
public boolean hasNext() {
return i.hasNext();
}
public T next() {
return i.next();
}
public boolean hasPrevious() {
return i.hasPrevious();
}
public T 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).getStringValue();
}
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;
}
StringBuilder result = new StringBuilder(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++) {
if (!Objects.equals(underlying.get(i), underlying2.get(i))) {
return false;
}
}
return true;
}
/**
* Combines the hash codes of all the list items.
*/
public int hashCode() {
int hash = 0;
for (Object item : underlying) {
hash *= 19;
hash += item.hashCode();
}
return hash;
}
}