com.xenoamess.commons.primitive.collections.lists.AbstractByteSequentialList Maven / Gradle / Ivy
Show all versions of commonx Show documentation
/*
* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.xenoamess.commons.primitive.collections.lists;
import com.xenoamess.commons.primitive.Primitive;
import com.xenoamess.commons.primitive.collections.ByteCollection;
import com.xenoamess.commons.primitive.iterators.ByteIterator;
import com.xenoamess.commons.primitive.iterators.ByteListIterator;
import java.util.*;
/**
* This class provides a skeletal implementation of the {@code List}
* interface to minimize the effort required to implement this interface
* backed by a "sequential access" data store (such as a linked list). For
* random access data (such as an array), {@code AbstractList} should be used
* in preference to this class.
*
* This class is the opposite of the {@code AbstractList} class in the sense
* that it implements the "random access" methods ({@code get(int index)},
* {@code set(int index, E element)}, {@code add(int index, E element)} and
* {@code remove(int index)}) on top of the list's list iterator, instead of
* the other way around.
*
* To implement a list the programmer needs only to extend this class and
* provide implementations for the {@code listIterator} and {@code size}
* methods. For an unmodifiable list, the programmer need only implement the
* list iterator's {@code hasNext}, {@code next}, {@code hasPrevious},
* {@code previous} and {@code index} methods.
*
* For a modifiable list the programmer should additionally implement the list
* iterator's {@code set} method. For a variable-size list the programmer
* should additionally implement the list iterator's {@code remove} and
* {@code add} methods.
*
* The programmer should generally provide a void (no argument) and collection
* constructor, as per the recommendation in the {@code Collection} interface
* specification.
*
* This class is a member of the
*
* Java Collections Framework.
*
* @author Josh Bloch
* @author Neal Gafter
* @see Collection
* @see List
* @see AbstractList
* @see AbstractCollection
* @since 1.2
*/
public abstract class AbstractByteSequentialList extends AbstractByteList implements Primitive {
/**
* Sole constructor. (For invocation by subclass constructors, typically
* implicit.)
*/
protected AbstractByteSequentialList() {
}
/**
* Returns the element at the specified position in this list.
*
*
This implementation first gets a list iterator pointing to the
* indexed element (with {@code listIterator(index)}). Then, it gets
* the element using {@code ListIterator.next} and returns it.
*
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
@Override
public byte getPrimitive(int index) {
try {
return this.listIterator(index).nextPrimitive();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: " + index);
}
}
/**
* Replaces the element at the specified position in this list with the
* specified element (optional operation).
*
*
This implementation first gets a list iterator pointing to the
* indexed element (with {@code listIterator(index)}). Then, it gets
* the current element using {@code ListIterator.next} and replaces it
* with {@code ListIterator.set}.
*
*
Note that this implementation will throw an
* {@code UnsupportedOperationException} if the list iterator does not
* implement the {@code set} operation.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
@Override
public byte setPrimitive(int index, byte element) {
try {
ByteListIterator e = listIterator(index);
byte oldVal = e.nextPrimitive();
e.set(element);
return oldVal;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: " + index);
}
}
/**
* Inserts the specified element at the specified position in this list
* (optional operation). Shifts the element currently at that position
* (if any) and any subsequent elements to the right (adds one to their
* indices).
*
*
This implementation first gets a list iterator pointing to the
* indexed element (with {@code listIterator(index)}). Then, it
* inserts the specified element with {@code ListIterator.add}.
*
*
Note that this implementation will throw an
* {@code UnsupportedOperationException} if the list iterator does not
* implement the {@code add} operation.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
@Override
public void addPrimitive(int index, byte element) {
try {
listIterator(index).addPrimitive(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: " + index);
}
}
/**
* Removes the element at the specified position in this list (optional
* operation). Shifts any subsequent elements to the left (subtracts one
* from their indices). Returns the element that was removed from the
* list.
*
*
This implementation first gets a list iterator pointing to the
* indexed element (with {@code listIterator(index)}). Then, it removes
* the element with {@code ListIterator.remove}.
*
*
Note that this implementation will throw an
* {@code UnsupportedOperationException} if the list iterator does not
* implement the {@code remove} operation.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public byte removePrimitive(int index) {
try {
ByteListIterator e = listIterator(index);
byte outCast = e.nextPrimitive();
e.remove();
return outCast;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: " + index);
}
}
// Bulk Operations
/**
* Inserts all of the elements in the specified collection into this
* list at the specified position (optional operation). Shifts the
* element currently at that position (if any) and any subsequent
* elements to the right (increases their indices). The new elements
* will appear in this list in the order that they are returned by the
* specified collection's iterator. The behavior of this operation is
* undefined if the specified collection is modified while the
* operation is in progress. (Note that this will occur if the specified
* collection is this list, and it's nonempty.)
*
*
This implementation gets an iterator over the specified collection and
* a list iterator over this list pointing to the indexed element (with
* {@code listIterator(index)}). Then, it iterates over the specified
* collection, inserting the elements obtained from the iterator into this
* list, one at a time, using {@code ListIterator.add} followed by
* {@code ListIterator.next} (to skip over the added element).
*
*
Note that this implementation will throw an
* {@code UnsupportedOperationException} if the list iterator returned by
* the {@code listIterator} method does not implement the {@code add}
* operation.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
@Override
public boolean addAll(int index, Collection c) {
try {
boolean modified = false;
ByteListIterator e1 = listIterator(index);
if (c instanceof ByteCollection) {
ByteCollection cByteCollection = (ByteCollection) c;
ByteIterator cByteCollectionIterator = cByteCollection.iterator();
while (cByteCollectionIterator.hasNext()) {
e1.addPrimitive(cByteCollectionIterator.nextPrimitive());
modified = true;
}
} else {
for (Byte e : c) {
e1.add(e);
modified = true;
}
}
return modified;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: " + index);
}
}
// Iterators
/**
* Returns an iterator over the elements in this list (in proper
* sequence).
*
* This implementation merely returns a list iterator over the list.
*
* @return an iterator over the elements in this list (in proper sequence)
*/
@Override
public ByteIterator iterator() {
return listIterator();
}
/**
* Returns a list iterator over the elements in this list (in proper
* sequence).
*
* @param index index of first element to be returned from the list
* iterator (by a call to the {@code next} method)
* @return a list iterator over the elements in this list (in proper
* sequence)
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
@Override
public abstract ByteListIterator listIterator(int index);
}