AbstractByteCollection (Joda primitives 1.0 API)

java.lang.Object
- org.joda.primitives.collection.impl.AbstractPrimitiveCollectable<Byte>
- - org.joda.primitives.collection.impl.AbstractByteCollection

All Implemented Interfaces:

Iterable<Byte>, Collection<Byte>, ByteCollection, PrimitiveCollection<Byte>, ByteIterable, PrimitiveCollectable<Byte>

Direct Known Subclasses:

AbstractByteList, ArrayByteCollection
```
public abstract class AbstractByteCollection
extends AbstractPrimitiveCollectable<Byte>
implements ByteCollection
```
Abstract base class for collections of primitive byte elements.
This class implements Collection allowing seamless integration with other APIs.
The iterator and size must be implemented by subclases. To make the subclass modifiable, the add(byte) and iterator remove() methods must also be implemented. Subclasses may override other methods to increase efficiency.

Since:

1.0

Version:

CODE GENERATED

Author:

Stephen Colebourne, Jason Tiscione

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractByteCollection()
Constructor.

Constructors
Modifier	Constructor and Description
`protected`	`AbstractByteCollection()` Constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(byte value)` Adds a primitive value to this collection (optional operation).
`boolean`	`add(Byte value)` Adds the `Byte` value to this collection (optional operation).
`boolean`	`addAll(byte[] values)` Adds an array of primitive values to this collection (optional operation).
`boolean`	`addAll(byte startInclusive, byte endInclusive)` Adds a range of primitive values to this collection (optional operation).
`boolean`	`addAll(ByteCollection values)` Adds a collection of primitive values to this collection (optional operation).
`boolean`	`addAll(Collection<? extends Byte> coll)` Adds a collection of `Byte` values to this collection (optional operation).
`protected void`	`arrayCopy(int fromIndex, byte[] dest, int destIndex, int size)` Copies data from this collection into the specified array.
`protected void`	`checkAddModifiable()` Check whether add is suported and throw an exception.
`protected void`	`checkRemoveModifiable()` Check whether remove is suported and throw an exception.
`void`	`clear()` Clears the collection/map of all elements (optional operation).
`boolean`	`contains(byte value)` Checks whether this collection contains a specified primitive value.
`boolean`	`contains(Object value)` Checks whether this collection contains a specified `Byte` value.
`boolean`	`containsAll(byte[] values)` Checks if this collection contains all of the values in the specified array.
`boolean`	`containsAll(byte startInclusive, byte endInclusive)` Checks if this collection contain all the values in the specified range.
`boolean`	`containsAll(ByteCollection values)` Checks if this collection contains all of the values in the specified collection.
`boolean`	`containsAll(Collection<?> coll)` Checks if the collection contains all of the primitive values.
`boolean`	`containsAny(byte[] values)` Checks if this collection contains any of the values in the specified array.
`boolean`	`containsAny(byte startInclusive, byte endInclusive)` Checks if this collection contain some of the values in the specified range.
`boolean`	`containsAny(ByteCollection values)` Checks if this collection contains any of the values in the specified collection.
`boolean`	`containsAny(Collection<?> coll)` Checks if the collection contains any of the primitive values in the array.
`protected boolean`	`isAddModifiable()` Are the add methods supported.
`boolean`	`isModifiable()` Is the collection modifiable in any way.
`protected boolean`	`isRemoveModifiable()` Are the remove methods supported.
`protected boolean`	`isToPrimitivePossible(Object value)` Checks if the object can be converted to a primitive successfully.
`boolean`	`remove(Object value)` Removes the first occurrance of the specified `Byte` value from this collection (optional operation).
`boolean`	`removeAll(byte value)` Removes all occurrences of the specified primitive value from this collection.
`boolean`	`removeAll(byte[] values)` Removes all occurrences from this collection of each primitive in the specified array.
`boolean`	`removeAll(byte startInclusive, byte endInclusive)` Removes all occurrences of a range of primitive values from this collection.
`boolean`	`removeAll(ByteCollection values)` Removes all occurrences from this collection of each primitive in the specified collection.
`boolean`	`removeAll(Collection<?> coll)` Removes each of a collection of `Byte` values from this collection (optional operation).
`boolean`	`removeFirst(byte value)` Removes the first occurrence of the specified primitive value from this collection
`boolean`	`retainAll(byte[] values)` Retains each element of this collection that is present in the specified array removing all other values.
`boolean`	`retainAll(byte startInclusive, byte endInclusive)` Retains all occurences of a range of primitive values within this collection removing all values outside the range (optional operation).
`boolean`	`retainAll(ByteCollection values)` Retains each element of this collection that is present in the specified collection removing all other values.
`boolean`	`retainAll(Collection<?> coll)` Retains each of a collection of `Byte` values, removing other values (optional operation).
`Object[]`	`toArray()` Gets the collection as an array of `Byte`.
`<T> T[]`	`toArray(T[] array)` Gets the collection as an array, using the array provided.
`byte[]`	`toByteArray()` Gets the elements of this collection as an array.
`byte[]`	`toByteArray(byte[] array, int startIndex)` Copies the elements of this collection into an array at a specified position.
`protected Byte`	`toObject(byte value)` Wraps an `byte` with an Object wrapper.
`protected byte`	`toPrimitive(Object value)` Unwraps the `Byte` to retrieve the primitive `byte`.
`protected byte[]`	`toPrimitiveArray(Collection<?> coll)` Unwraps a `Collection` to retrieve the primitive `byte`.
`String`	`toString()` Gets a string representing this collection.

Methods inherited from class org.joda.primitives.collection.impl.AbstractPrimitiveCollectable
clone, isEmpty, optimize

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.joda.primitives.collection.ByteCollection
iterator

Methods inherited from interface org.joda.primitives.PrimitiveCollectable
clone, isEmpty, optimize, size

Methods inherited from interface java.util.Collection
equals, hashCode, isEmpty, size

- Constructor Detail
  - AbstractByteCollection
```
protected AbstractByteCollection()
```
    Constructor.
- Method Detail
  - contains
```
public boolean contains(byte value)
```
    Checks whether this collection contains a specified primitive value.
    This implementation uses byteIterator().
    
    Specified by:
    
    contains in interface ByteCollection
    
    Parameters:
    value - the value to search for
    
    Returns:
    true if the value is found
  - containsAll
```
public boolean containsAll(byte[] values)
```
    Checks if this collection contains all of the values in the specified array. If the specified array is empty, true is returned.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAll in interface ByteCollection
    
    Parameters:
    values - the values to search for, null treated as empty array
    
    Returns:
    true if all of the values are found
  - containsAll
```
public boolean containsAll(ByteCollection values)
```
    Checks if this collection contains all of the values in the specified collection. If the specified collection is empty, true is returned.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAll in interface ByteCollection
    
    Parameters:
    values - the values to search for, null treated as empty collection
    
    Returns:
    true if all of the values are found
  - containsAll
```
public boolean containsAll(byte startInclusive,
                  byte endInclusive)
```
    Checks if this collection contain all the values in the specified range.
    The range is defined to be inclusive of the start and end. If the start is greater than the end then the result is true as the range is equivalent to an empty collection.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAll in interface ByteCollection
    
    Parameters:
    startInclusive - the inclusive range start value
    endInclusive - the inclusive range end value
    
    Returns:
    true if the collection contains the entire range
  - containsAny
```
public boolean containsAny(byte[] values)
```
    Checks if this collection contains any of the values in the specified array. If the specified array is empty, false is returned.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAny in interface ByteCollection
    
    Parameters:
    values - the values to search for, null treated as empty array
    
    Returns:
    true if at least one of the values is found
  - containsAny
```
public boolean containsAny(ByteCollection values)
```
    Checks if this collection contains any of the values in the specified collection. If the specified collection is empty, false is returned.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAny in interface ByteCollection
    
    Parameters:
    values - the values to search for, null treated as empty collection
    
    Returns:
    true if at least one of the values is found
  - containsAny
```
public boolean containsAny(byte startInclusive,
                  byte endInclusive)
```
    Checks if this collection contain some of the values in the specified range.
    The range is defined to be inclusive of the start and end. If the start is greater than the end then the result is false as the range is equivalent to an empty collection.
    This implementation uses contains(byte).
    
    Specified by:
    
    containsAny in interface ByteCollection
    
    Parameters:
    startInclusive - the inclusive range start value
    endInclusive - the inclusive range end value
    
    Returns:
    true if the collection contains at least one of the range
  - toByteArray
```
public byte[] toByteArray()
```
    Gets the elements of this collection as an array.
    This implementation uses arrayCopy.
    
    Specified by:
    
    toByteArray in interface ByteCollection
    
    Returns:
    a new array containing a copy of the elements of this collection
  - toByteArray
```
public byte[] toByteArray(byte[] array,
                 int startIndex)
```
    Copies the elements of this collection into an array at a specified position. Previous values in the array are overwritten.
    If the array specified is null a new array is created. If the array specified is large enough, it will be modified. If the array is not large enough, a new array will be created containing the values from the specified array before the startIndex plus those from this collection.
    This implementation uses arrayCopy.
    
    Specified by:
    
    toByteArray in interface ByteCollection
    
    Parameters:
    array - the array to add the elements to, null treated as empty array
    startIndex - the position in the array to start setting elements
    
    Returns:
    the array with the populated collection
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative
  - clear
```
public void clear()
```
    Clears the collection/map of all elements (optional operation).
    The collection/map will have a zero size after this method completes. This method is optional, throwing an UnsupportedOperationException if the collection/map cannot be cleared.
    This implementation uses iterator().
    
    Specified by:
    
    clear in interface Collection<Byte>
    
    Specified by:
    
    clear in interface PrimitiveCollectable<Byte>
    
    Throws:
    
    UnsupportedOperationException - if method not supported by this collection
  - add
```
public boolean add(byte value)
```
    Adds a primitive value to this collection (optional operation).
    This implementation throws UnsupportedOperationException.
    
    Specified by:
    
    add in interface ByteCollection
    
    Parameters:
    value - the value to add to this collection
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    IllegalArgumentException - if value is rejected by this collection
    
    UnsupportedOperationException - if not supported by this collection
  - addAll
```
public boolean addAll(byte[] values)
```
    Adds an array of primitive values to this collection (optional operation).
    This implementation uses add(byte).
    
    Specified by:
    
    addAll in interface ByteCollection
    
    Parameters:
    values - the values to add to this collection, null treated as empty array
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    IllegalArgumentException - if a value is rejected by this collection
    
    UnsupportedOperationException - if not supported by this collection
  - addAll
```
public boolean addAll(ByteCollection values)
```
    Adds a collection of primitive values to this collection (optional operation).
    This implementation uses add(byte).
    
    Specified by:
    
    addAll in interface ByteCollection
    
    Parameters:
    values - the values to add to this collection, null treated as empty collection
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    IllegalArgumentException - if a value is rejected by this collection
    
    UnsupportedOperationException - if not supported by this collection
  - addAll
```
public boolean addAll(byte startInclusive,
             byte endInclusive)
```
    Adds a range of primitive values to this collection (optional operation).
    The range is defined to be inclusive of the start and end. If the start is greater than the end then the range is equivalent to an empty collection.
    This implementation uses add(byte).
    
    Specified by:
    
    addAll in interface ByteCollection
    
    Parameters:
    startInclusive - the inclusive range start value
    endInclusive - the inclusive range end value
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    IllegalArgumentException - if a value is rejected by this set
    
    UnsupportedOperationException - if not supported by this set
  - removeFirst
```
public boolean removeFirst(byte value)
```
    Removes the first occurrence of the specified primitive value from this collection
    This implementation uses iterator().remove().
    
    Specified by:
    
    removeFirst in interface ByteCollection
    
    Parameters:
    value - the value to remove
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - removeAll
```
public boolean removeAll(byte value)
```
    Removes all occurrences of the specified primitive value from this collection.
    This implementation uses iterator().remove().
    
    Specified by:
    
    removeAll in interface ByteCollection
    
    Parameters:
    value - the value to remove
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - removeAll
```
public boolean removeAll(byte[] values)
```
    Removes all occurrences from this collection of each primitive in the specified array.
    This implementation uses iterator().remove().
    
    Specified by:
    
    removeAll in interface ByteCollection
    
    Parameters:
    values - the values to remove from this collection, null treated as empty array
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - removeAll
```
public boolean removeAll(ByteCollection values)
```
    Removes all occurrences from this collection of each primitive in the specified collection.
    This implementation uses iterator().remove().
    
    Specified by:
    
    removeAll in interface ByteCollection
    
    Parameters:
    values - the values to remove from this collection, null treated as empty collection
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - removeAll
```
public boolean removeAll(byte startInclusive,
                byte endInclusive)
```
    Removes all occurrences of a range of primitive values from this collection.
    The range is defined to be inclusive of the start and end. The elements removed are greater than or equal to the start and less than or equal to the end. Thus if the start is greater than the end then no elements are removed.
    This method is optional, throwing an UnsupportedOperationException if the set cannot be changed.
    This implementation uses iterator().remove().
    
    Specified by:
    
    removeAll in interface ByteCollection
    
    Parameters:
    startInclusive - the inclusive range start value
    endInclusive - the inclusive range end value
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - retainAll
```
public boolean retainAll(byte[] values)
```
    Retains each element of this collection that is present in the specified array removing all other values.
    This implementation uses iterator().remove().
    
    Specified by:
    
    retainAll in interface ByteCollection
    
    Parameters:
    values - the values to remove from this collection, null treated as empty array
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - retainAll
```
public boolean retainAll(ByteCollection values)
```
    Retains each element of this collection that is present in the specified collection removing all other values.
    This implementation uses iterator().remove().
    
    Specified by:
    
    retainAll in interface ByteCollection
    
    Parameters:
    values - the values to retain in this collection, null treated as empty collection
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - retainAll
```
public boolean retainAll(byte startInclusive,
                byte endInclusive)
```
    Retains all occurences of a range of primitive values within this collection removing all values outside the range (optional operation).
    The range is defined to be inclusive of the start and end. If the start is greater than the end then the range is equivalent to an empty collection.
    This method is optional, throwing an UnsupportedOperationException if the set cannot be changed.
    
    Specified by:
    
    retainAll in interface ByteCollection
    
    Parameters:
    startInclusive - the inclusive range start value
    endInclusive - the inclusive range end value
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - contains
```
public boolean contains(Object value)
```
    Checks whether this collection contains a specified Byte value.
    This implementation uses contains(byte).
    
    Specified by:
    
    contains in interface Collection<Byte>
    
    Parameters:
    value - the value to search for
    
    Returns:
    true if the value is found
  - containsAll
```
public boolean containsAll(Collection<?> coll)
```
    Checks if the collection contains all of the primitive values.
    This implementation uses containsAll(byte[]).
    
    Specified by:
    
    containsAll in interface Collection<Byte>
    
    Parameters:
    coll - the collection of values to search for
    
    Returns:
    true if all the values are found
  - containsAny
```
public boolean containsAny(Collection<?> coll)
```
    Checks if the collection contains any of the primitive values in the array. If the specified collection is empty, false is returned.
    This implementation uses containsAny(byte[]).
    
    Specified by:
    
    containsAny in interface PrimitiveCollection<Byte>
    
    Parameters:
    coll - the collection of values to search for
    
    Returns:
    true if at least one of the values is found
  - toArray
```
public Object[] toArray()
```
    Gets the collection as an array of Byte.
    
    Specified by:
    
    toArray in interface Collection<Byte>
    
    Returns:
    an array of Byte
  - toArray
```
public <T> T[] toArray(T[] array)
```
    Gets the collection as an array, using the array provided.
    
    Specified by:
    
    toArray in interface Collection<Byte>
    
    Parameters:
    array - the array to populate
    
    Returns:
    an array of Byte
  - add
```
public boolean add(Byte value)
```
    Adds the Byte value to this collection (optional operation).
    This method is optional, throwing an UnsupportedOperationException if the collection cannot be added to.
    This implementation uses add(byte).
    
    Specified by:
    
    add in interface Collection<Byte>
    
    Parameters:
    value - the value to add to this collection
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    IllegalArgumentException - if value is rejected by this collection
    
    UnsupportedOperationException - if not supported by this collection
  - addAll
```
public boolean addAll(Collection<? extends Byte> coll)
```
    Adds a collection of Byte values to this collection (optional operation).
    This method is optional, throwing an UnsupportedOperationException if the collection cannot be added to.
    This implementation uses addAll(byte[]).
    
    Specified by:
    
    addAll in interface Collection<Byte>
    
    Parameters:
    coll - the values to add to this collection
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    IndexOutOfBoundsException - if the index is invalid
    
    ClassCastException - if any object is not Byte
    
    IllegalArgumentException - if value is rejected by this collection
    
    UnsupportedOperationException - if not supported by this collection
  - remove
```
public boolean remove(Object value)
```
    Removes the first occurrance of the specified Byte value from this collection (optional operation).
    This method is optional, throwing an UnsupportedOperationException if the collection cannot be removed from.
    This implementation uses removeFirst(byte).
    
    Specified by:
    
    remove in interface Collection<Byte>
    
    Parameters:
    value - the value to remove
    
    Returns:
    true if this collection was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - removeAll
```
public boolean removeAll(Collection<?> coll)
```
    Removes each of a collection of Byte values from this collection (optional operation).
    This method is optional, throwing an UnsupportedOperationException if the collection cannot be added to.
    This implementation uses removeAll(byte[]).
    
    Specified by:
    
    removeAll in interface Collection<Byte>
    
    Parameters:
    coll - the values to remove from this collection
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - retainAll
```
public boolean retainAll(Collection<?> coll)
```
    Retains each of a collection of Byte values, removing other values (optional operation).
    This method is optional, throwing an UnsupportedOperationException if the collection cannot be added to.
    This implementation uses retainAll(byte[]).
    
    Specified by:
    
    retainAll in interface Collection<Byte>
    
    Parameters:
    coll - the values to retain in this collection
    
    Returns:
    true if this list was modified by this method call
    
    Throws:
    
    UnsupportedOperationException - if not supported by this collection
  - toString
```
public String toString()
```
    Gets a string representing this collection.
    The format used is as per Collection.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    collection as a String
  - arrayCopy
```
protected void arrayCopy(int fromIndex,
             byte[] dest,
             int destIndex,
             int size)
```
    Copies data from this collection into the specified array. This method is pre-validated.
    
    Parameters:
    fromIndex - the index to start from
    dest - the destination array
    destIndex - the destination start index
    size - the number of items to copy
  - isAddModifiable
```
protected boolean isAddModifiable()
```
    Are the add methods supported.
    This implementation returns false.
    
    Returns:
    true if supported
  - isRemoveModifiable
```
protected boolean isRemoveModifiable()
```
    Are the remove methods supported.
    This implementation returns false.
    
    Returns:
    true if supported
  - isModifiable
```
public boolean isModifiable()
```
    Is the collection modifiable in any way.
    
    Specified by:
    
    isModifiable in interface PrimitiveCollectable<Byte>
    
    Overrides:
    
    isModifiable in class AbstractPrimitiveCollectable<Byte>
    
    Returns:
    true if supported
  - checkAddModifiable
```
protected void checkAddModifiable()
```
    Check whether add is suported and throw an exception.
  - checkRemoveModifiable
```
protected void checkRemoveModifiable()
```
    Check whether remove is suported and throw an exception.
  - toObject
```
protected Byte toObject(byte value)
```
    Wraps an byte with an Object wrapper.
    
    Parameters:
    value - the primitive value
    
    Returns:
    the Object wrapper
  - isToPrimitivePossible
```
protected boolean isToPrimitivePossible(Object value)
```
    Checks if the object can be converted to a primitive successfully.
    This implementation only allows non-null Byte objects.
    
    Parameters:
    value - the Object wrapper
    
    Returns:
    true if a primitive value can be successfully extracted
  - toPrimitive
```
protected byte toPrimitive(Object value)
```
    Unwraps the Byte to retrieve the primitive byte.
    This implementation only allows non-null Byte objects.
    
    Parameters:
    value - the Object to convert to a primitive
    
    Returns:
    the primitive value
    
    Throws:
    
    NullPointerException - if the value is null and this is unacceptable
    
    ClassCastException - if the object is of an unsuitable type
  - toPrimitiveArray
```
protected byte[] toPrimitiveArray(Collection<?> coll)
```
    Unwraps a Collection to retrieve the primitive byte.
    This implementation only allows non-null Byte objects.
    
    Parameters:
    coll - the Collection to convert to primitives
    
    Returns:
    the primitive value
    
    Throws:
    
    NullPointerException - if the value is null and this is unacceptable
    
    ClassCastException - if any object is of an unsuitable type

Class AbstractByteCollection

Constructor Summary

Method Summary

Methods inherited from class org.joda.primitives.collection.impl.AbstractPrimitiveCollectable

Methods inherited from class java.lang.Object

Methods inherited from interface org.joda.primitives.collection.ByteCollection

Methods inherited from interface org.joda.primitives.PrimitiveCollectable

Methods inherited from interface java.util.Collection

Constructor Detail

AbstractByteCollection

Method Detail

contains

containsAll

containsAll

containsAll

containsAny

containsAny

containsAny

toByteArray

toByteArray

clear

add

addAll

addAll

addAll

removeFirst

removeAll

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

contains

containsAll

containsAny

toArray

toArray

add

addAll

remove

removeAll

retainAll

toString

arrayCopy

isAddModifiable

isRemoveModifiable

isModifiable

checkAddModifiable

checkRemoveModifiable

toObject

isToPrimitivePossible

toPrimitive

toPrimitiveArray