de.caff.generics

Interface MutableByteIndexable

All Superinterfaces:

ByteIndexable, Copyable<MutableByteIndexable>, java.lang.Iterable<java.lang.Byte>, PrimitiveByteIterable, Sizeable

All Known Implementing Classes:

MutableByteIndexable.Base

public interface MutableByteIndexable
extends ByteIndexable, Copyable<MutableByteIndexable>

Primitive byte indexable with fixed length but mutable content. This may be used as a substitute for byte[] as it e.g. allows read-only views or transparent views of subsets of the array.

Since:

November 01, 2019

Author:

Rammi

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	MutableByteIndexable.Base Abstract base class which provides useful implementations for Object.equals(Object), Object.hashCode(), Object.toString().

Field Summary

Fields

Modifier and Type	Field and Description
static MutableByteIndexable.Base	EMPTY Empty mutable indexable.

Fields inherited from interface de.caff.generics.ByteIndexable

LOWERCASE_2DIGIT_HEXCODES, SINGLE_0, UPPERCASE_2DIGIT_HEXCODES

Fields inherited from interface de.caff.generics.PrimitiveByteIterable

EMPTY_BYTE_ITERATOR

Fields inherited from interface de.caff.generics.Sizeable

NULL

Method Summary

Modifier and Type	Method and Description
default java.util.List<java.lang.Byte>	asList() View this indexable as a standard list.
static MutableByteIndexable.Base	based(MutableByteIndexable indexable) View any mutable byte indexable as a base byte indexable.
static <IN> MutableByteIndexable.Base	copy(java.util.Collection<IN> collection, java.util.function.Function<IN,java.lang.Number> copier) Create a mutable indexable which is initialized from copied elements of a given collection.
default void	copyInternally(int fromIndex, int toIndex, int numElements) Copy elements inside this indexable.
static MutableByteIndexable.Base	copyOf(java.util.Collection<? extends java.lang.Number> collection) Create a mutable byte indexable which is initialized from a given collection.
static MutableByteIndexable.Base	empty()
default void	fillFrom(IntToByteFunction1 provider) Fill this indexable from a provider.
static MutableByteIndexable.Base	fromArray(byte... elements) Create a mutable indexable which is initialized from elements of the given array.
static MutableByteIndexable.Base	fromArray(byte[] elements, int startIndex, int length) Create a mutable indexable which is initialized from elements of the given array.
static MutableByteIndexable.Base	fromByteIndexable(ByteIndexable indexable) Return a mutable short indexable initialized with the content of a standard byte indexable.
static MutableByteIndexable.Base	fromDoubleIndexable(DoubleIndexable indexable) Return a mutable byte indexable initialized with the content of a standard double indexable.
static MutableByteIndexable.Base	fromFloatIndexable(FloatIndexable indexable) Return a mutable byte indexable initialized with the content of a standard float indexable.
static MutableByteIndexable.Base	fromIndexable(Indexable<? extends java.lang.Number> indexable) Create a mutable indexable which is the copy of a standard indexable.
static <B> MutableByteIndexable.Base	fromIndexable(Indexable<B> indexable, java.util.function.Function<? super B,? extends java.lang.Number> converter) Create a mutable indexable which is the copy of a standard indexable.
static MutableByteIndexable.Base	fromIntIndexable(IntIndexable indexable) Return a mutable byte indexable initialized with the content of a standard int indexable.
static MutableByteIndexable.Base	fromIterable(int size, java.lang.Iterable<? extends java.lang.Number> iter) Create a mutable indexable from an iterable or a part of it.
static MutableByteIndexable.Base	fromLongIndexable(LongIndexable indexable) Return a mutable byte indexable initialized with the content of a standard long indexable.
static MutableByteIndexable.Base	fromShortIndexable(ShortIndexable indexable) Return a mutable short indexable initialized with the content of a standard short indexable.
default MutableByteIndexable	getCopy() Get a copy of this object.
default MutableByteIndexable.Base	headSet(int toIndex) Create an indexable subset from the last elements of this indexable set.
static MutableByteIndexable.Base	init(int size, byte value) Create a mutable
static MutableByteIndexable.Base	init(int size, java.util.function.Supplier<java.lang.Number> creator) Initialize a mutable indexable to a given size.
static MutableByteIndexable.Base	initByIndex(int size, IntToByteFunction1 producer) Get a mutable byte indexable of a given size which contains elements created by index.
default void	initByIndex(IntToByteFunction1 setter) Deprecated. use fillFrom(IntToByteFunction1) instead
default void	order() Sort the elements in this indexable in their natural order.
default void	order(ByteOrdering ordering) Sort the elements in this indexable according to the given ordering.
default MutableByteIndexable.Base	reverse() Get this indexable but with inverted order.
default void	revert() Revert the elements in this indexable.
default void	revert(int from, int to) Revert the order of all elements in the given range.
void	set(int index, byte value) Set the element at the given index.
default int	setFrom(java.lang.Iterable<? extends java.lang.Number> iterable) Set the values of this mutable byte indexable one after the other from the given Number iterable until either the iterable is emptied or Sizeable.size() elements are set.
default int	setFrom(java.lang.Iterable<? extends java.lang.Number> iterable, int startIndex, int numElements) Set the values of this mutable byte indexable one after the other from the given iterable until either the iterable is emptied or numElements elements are set.
default void	setFromArray(byte[] array, int arrayIndex, int startIndex, int numElements) Set consecutive entries from an array.
default void	setMulti(int from, int len, byte value) Set multiple elements to the same value.
default void	setRange(int startIndex, int length, byte value) Set a range to the same value.
default void	shuffle(java.util.Random random) Randomize the content of this mutable indexable.
default MutableByteIndexable.Base	subSet(int fromIndex, int toIndex) Get an indexable subset.
default void	swap(int idx1, int idx2) Swap the values at two indices.
default void	swyp(int idx1, int idx2) Swap the values at two indices using Pythonesque indices.
default MutableByteIndexable.Base	sybSet(int fromIndex, int toIndex) Get an indexable subset.
default void	syt(int index, byte value) Pythonesque set.
default MutableByteIndexable.Base	tailSet(int fromIndex) Create an indexable subset from the last elements of this indexable set.
default MutableIntIndexable.Base	toMutableIntIndexable() Convert this mutable short array into an integer array.
static MutableByteIndexable.Base	viewArray(byte[] array) Mutable indexable view which operates on the given array.
static MutableByteIndexable.Base	viewArray(byte[] array, int start, int length) Mutable indexable view which operates on a part of the given array.
static <T> MutableByteIndexable.Base	viewIndexable(Indexable<T> indexable, ToByteFunction<? super T> getter, ByteSetter<? super T> setter) View a generic indexable as a mutable byte indexable by accessing a byte property of the elements of the underlying generic indexable.
static MutableByteIndexable.Base	viewList(java.util.List<java.lang.Byte> list) Mutable indexable view which operates on the given array.
static MutableByteIndexable.Base	zeroed(int size) Create a mutable byte indexable with size 0.0 elements.

Methods inherited from interface de.caff.generics.ByteIndexable

addAllTo, addToArray, addToArray, addToArray, addToArray, asBase, asCollection, asIndexable, asIntIndexable, asUnsignedIndexable, binarySearch, binarySearch, byteIterator, byteIterator, bytesFromHexString, compare, compareUnsigned, copyTo, copyTo, emptyIndexable, equal, equal, firstMatch, foldLeft, fromHexString, frozen, get, getMod, gyt, hash, indexes, intIndexes, intIterator, isEmpty, isOrdered, isOrdered, isStrictlyOrdered, isStrictlyOrdered, iterator, lastMatch, listIterator, nextMatch, ordered, previousMatch, rotated, singleton, toArray, toByteArray, toHexString, toHexString, toIntArray, toList, toString, view, viewArray, viewAsBoolean, viewAsDouble, viewAsFloat, viewAsInt, viewAsLong, viewAsShort, viewAsUnsignedInt, viewAsUnsignedLong, viewAsUnsignedShort, viewByIndex, viewIndexable, viewIndexable, viewIndexable, viewList, viewList, viewList, viewNumberArray, viewOp, withAppendedValue, withCachedHash, withExchangedValueAt, withInsertedValueAt, withRemovedValueAt, withSwappedValuesAt

Methods inherited from interface de.caff.generics.PrimitiveByteIterable

asIntIterable, asLongIterable, asShortIterable, asUnsignedIntIterable, asUnsignedLongIterable, containsByte, forEachByte, forEachByteFragile

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface de.caff.generics.Sizeable

size

Methods inherited from interface de.caff.generics.Copyable

copy

Field Detail

EMPTY

static final MutableByteIndexable.Base EMPTY

Empty mutable indexable. Use empty() instead.

Method Detail

set

void set(int index,
         byte value)

Set the element at the given index.

Parameters:

index - index between 0 and size() - 1

value - value to put to the given index

syt

default void syt(int index,
                 byte value)

Pythonesque set. This allows to access elements from the back by using negative indexes, e.g. -1 references the last element, -2 its predecessor, and so on.

Parameters:

index - index between -size() and size() - 1

value - value to put to the given index

setRange

default void setRange(int startIndex,
                      int length,
                      byte value)

Set a range to the same value.

Parameters:

startIndex - start index (Pythonesque)

length - length (non-negative)

value - value to set for the given range

setFrom

default int setFrom(@NotNull
                    java.lang.Iterable<? extends java.lang.Number> iterable)

Set the values of this mutable byte indexable one after the other from the given Number iterable until either the iterable is emptied or Sizeable.size() elements are set.

Parameters:

iterable - iterable from which this indexable is filled

Returns:

number of elements set

setFrom

default int setFrom(@NotNull
                    java.lang.Iterable<? extends java.lang.Number> iterable,
                    int startIndex,
                    int numElements)

Set the values of this mutable byte indexable one after the other from the given iterable until either the iterable is emptied or numElements elements are set.

Parameters:

iterable - iterable from which this indexable is filled

startIndex - start index where the setting begins

numElements - number of elements to set

Returns:

number of elements set

setFromArray

default void setFromArray(@NotNull
                          byte[] array,
                          int arrayIndex,
                          int startIndex,
                          int numElements)

Set consecutive entries from an array. This will set less elements

Parameters:

array - array with elements to set from

arrayIndex - start index in the array

startIndex - start index in this mutable indexable

numElements - number of elements to copy

Throws:

java.lang.IndexOutOfBoundsException - if this mutable indexable would overflow by this operation

java.lang.ArrayIndexOutOfBoundsException - if array overflows by this operation

setMulti

default void setMulti(int from,
                      int len,
                      byte value)

Set multiple elements to the same value.

Parameters:

from - first index to be set (Pythonesque)

len - number of elements to be set (non-negative)

value - value to be set

copyInternally

default void copyInternally(int fromIndex,
                            int toIndex,
                            int numElements)

Copy elements inside this indexable.

Parameters:

fromIndex - start index from where elements are copied (Pythonesque)

toIndex - start index to where elements are copied (Pythonesque)

numElements - number of elements to copy

fillFrom

default void fillFrom(@NotNull
                      IntToByteFunction1 provider)

Fill this indexable from a provider.

Parameters:

provider - provider which is called for each index and provides the element for that index

swap

default void swap(int idx1,
                  int idx2)

Swap the values at two indices.

Parameters:

idx1 - first index

idx2 - second index

swyp

default void swyp(int idx1,
                  int idx2)

Swap the values at two indices using Pythonesque indices.

Parameters:

idx1 - first index (Pythonesque)

idx2 - second index (Pythonesque)

subSet

@NotNull
default MutableByteIndexable.Base subSet(int fromIndex,
                                                  int toIndex)

Description copied from interface: ByteIndexable

Get an indexable subset. The subset includes indices fromIndex to toIndex - 1.

Specified by:

subSet in interface ByteIndexable

Parameters:

fromIndex - start index of sub set

toIndex - index after last index

Returns:

indxable subset view of this indexable

sybSet

@NotNull
default MutableByteIndexable.Base sybSet(int fromIndex,
                                                  int toIndex)

Description copied from interface: ByteIndexable

Get an indexable subset. This is the Pythonesque version which allows negative indexes.

Specified by:

sybSet in interface ByteIndexable

Parameters:

fromIndex - start index of sub set

toIndex - end index of sub set

Returns:

indexable subset view of this indexable set

tailSet

@NotNull
default MutableByteIndexable.Base tailSet(int fromIndex)

Description copied from interface: ByteIndexable

Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.

Specified by:

tailSet in interface ByteIndexable

Parameters:

fromIndex - index to start with, negative counts from the back

Returns:

indexable subset view of this indexable set

headSet

@NotNull
default MutableByteIndexable.Base headSet(int toIndex)

Description copied from interface: ByteIndexable

Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.

Specified by:

headSet in interface ByteIndexable

Parameters:

toIndex - index one after the end (equal to the length of the returned set), negative counts from the back

Returns:

indexable subset view of this indexable set

reverse

@NotNull
default MutableByteIndexable.Base reverse()

Description copied from interface: ByteIndexable

Get this indexable but with inverted order.

Specified by:

reverse in interface ByteIndexable

Returns:

a view to this indexable which accesses the elements in reverse order

revert

default void revert(int from,
                    int to)

Revert the order of all elements in the given range. Attention: the to element is also included in the reversion to allow easy reversion at the end by using -1.

Parameters:

from - start element of reversion (Pythonesque), included

to - end element of reversion (Pythonesque), included

revert

default void revert()

Revert the elements in this indexable. This reverts the order of all elements.

order

default void order()

Sort the elements in this indexable in their natural order.

order

default void order(@NotNull
                   ByteOrdering ordering)

Sort the elements in this indexable according to the given ordering.

Parameters:

ordering - sort order

shuffle

default void shuffle(@NotNull
                     java.util.Random random)

Randomize the content of this mutable indexable. This will reorder the elements randomly.

Parameters:

random - random number generator

toMutableIntIndexable

@NotNull
default MutableIntIndexable.Base toMutableIntIndexable()

Convert this mutable short array into an integer array.

It is recommended to do this when this indexable is heavily used.

Returns:

mutable int indexable copy of this short indexable

initByIndex

@Deprecated
default void initByIndex(@NotNull
                                     IntToByteFunction1 setter)

Deprecated. use fillFrom(IntToByteFunction1) instead

Set all values of this byte indexable by index.

Parameters:

setter - setter which provides the value to be set for a given index

asList

@NotNull
default java.util.List<java.lang.Byte> asList()

View this indexable as a standard list. Overwritten to allow for modifications. The returned list will allow usage of the List.set(int, Object) method, but neither any adding nor deleting methods. Standard sorting algorithms will work on the returned list as a sorting algorithm is expected to neither move nor add elements.

Specified by:

asList in interface ByteIndexable

Returns:

list allowing setting elements

See Also:

ByteIndexable.toList()

getCopy

@NotNull
default MutableByteIndexable getCopy()

Description copied from interface: Copyable

Get a copy of this object. Immutable objects are allowed to return themselves. The copy needs not to be of the same class, it just has to fulfill the type restriction.

Specified by:

getCopy in interface Copyable<MutableByteIndexable>

Returns:

independent copy of this object

based

@NotNull
static MutableByteIndexable.Base based(@NotNull
                                                MutableByteIndexable indexable)

View any mutable byte indexable as a base byte indexable. The latter provides various standard methods for comparison, output and hanshing.

Parameters:

indexable - mutqable byte indexable to view as a MutableByteIndexable.Base mutable byte indexable

Returns:

base view of given indexable, or the indexable itself if it is already a Base

init

@NotNull
static MutableByteIndexable.Base init(int size,
                                               @NotNull
                                               java.util.function.Supplier<java.lang.Number> creator)

Initialize a mutable indexable to a given size.

Parameters:

size - size of indexable

creator - creator for the initial elements

Returns:

mutable indexable with the given size

See Also:

zeroed(int), init(int, byte)

copyOf

@NotNull
static MutableByteIndexable.Base copyOf(@NotNull
                                                 java.util.Collection<? extends java.lang.Number> collection)

Create a mutable byte indexable which is initialized from a given collection.

Parameters:

collection - collection

Returns:

mutable indexable

copy

@NotNull
static <IN> MutableByteIndexable.Base copy(@NotNull
                                                    java.util.Collection<IN> collection,
                                                    @NotNull
                                                    java.util.function.Function<IN,java.lang.Number> copier)

Create a mutable indexable which is initialized from copied elements of a given collection.

Type Parameters:

IN - incoming element type

Parameters:

collection - collection

copier - element copier

Returns:

mutable indexable

empty

@NotNull
static MutableByteIndexable.Base empty()

fromArray

@NotNull
static MutableByteIndexable.Base fromArray(@NotNull
                                                    byte... elements)

Create a mutable indexable which is initialized from elements of the given array.

Parameters:

elements - elements

Returns:

mutable indexable independent of elements

fromArray

@NotNull
static MutableByteIndexable.Base fromArray(@NotNull
                                                    byte[] elements,
                                                    int startIndex,
                                                    int length)

Create a mutable indexable which is initialized from elements of the given array.

Parameters:

elements - array of elements

startIndex - index of first element used in the returned indxable

length - length number of elements used in the returned indexable

Returns:

mutable indexable independent from elements

viewArray

@NotNull
static MutableByteIndexable.Base viewArray(@NotNull
                                                    byte[] array)

Mutable indexable view which operates on the given array. Any changes done by the returned indexable will be forwarded to the array.

Specified by:

viewArray in interface ByteIndexable

Parameters:

array - array

Returns:

mutable indexable view of the given array

viewArray

@NotNull
static MutableByteIndexable.Base viewArray(@NotNull
                                                    byte[] array,
                                                    int start,
                                                    int length)

Mutable indexable view which operates on a part of the given array.

Specified by:

viewArray in interface ByteIndexable

Parameters:

array - array

start - start position in array

length - length of returned indexable

Returns:

mutable byte indexable view of the given part of the array

viewList

@NotNull
static MutableByteIndexable.Base viewList(@NotNull
                                                   java.util.List<java.lang.Byte> list)

Mutable indexable view which operates on the given array. Any changes done by the returned indexable will be forwarded to the list.

Parameters:

list - list

Returns:

mutable indexable view of the given list

fromIndexable

@NotNull
static MutableByteIndexable.Base fromIndexable(@NotNull
                                                        Indexable<? extends java.lang.Number> indexable)

Create a mutable indexable which is the copy of a standard indexable.

Parameters:

indexable - standard indexable

Returns:

mutable indexable initialize from the standard indexable

fromIndexable

@NotNull
static <B> MutableByteIndexable.Base fromIndexable(@NotNull
                                                            Indexable<B> indexable,
                                                            @NotNull
                                                            java.util.function.Function<? super B,? extends java.lang.Number> converter)

Create a mutable indexable which is the copy of a standard indexable. This especieally allows to copy each element during the initialization.

Type Parameters:

B - element type of incoming idexable

Parameters:

indexable - base indexable

converter - converter from base indexable type to result element type,

Returns:

mutable indexable

viewIndexable

@NotNull
static <T> MutableByteIndexable.Base viewIndexable(@NotNull
                                                            Indexable<T> indexable,
                                                            @NotNull
                                                            ToByteFunction<? super T> getter,
                                                            @NotNull
                                                            ByteSetter<? super T> setter)

View a generic indexable as a mutable byte indexable by accessing a byte property of the elements of the underlying generic indexable.

This is useful if you have complex items, but are interested into only one (byte) property of each item.

Type Parameters:

T - element type of the underlying indexable

Parameters:

indexable - underlying generic indexable

getter - function used to extract the property of interest

setter - procedure used to set the property of interest

Returns:

mutable byte indexable view of the underlying indexable

fromDoubleIndexable

@NotNull
static MutableByteIndexable.Base fromDoubleIndexable(@NotNull
                                                              DoubleIndexable indexable)

Return a mutable byte indexable initialized with the content of a standard double indexable. This will cast the incoming double values and result in a loss of accuracy.

Parameters:

indexable - double indexable

Returns:

mutable indexable initialized with the values of the given double indexable

fromFloatIndexable

@NotNull
static MutableByteIndexable.Base fromFloatIndexable(@NotNull
                                                             FloatIndexable indexable)

Return a mutable byte indexable initialized with the content of a standard float indexable. This will cast the incoming float values and result in a loss of accuracy.

Parameters:

indexable - float indexable

Returns:

mutable indexable initialized with the values of the given float indexable

fromLongIndexable

@NotNull
static MutableByteIndexable.Base fromLongIndexable(@NotNull
                                                            LongIndexable indexable)

Return a mutable byte indexable initialized with the content of a standard long indexable. This will cast long values to byte.

Parameters:

indexable - long indexable

Returns:

mutable indexable initialized with the values of the given long indexable

fromIntIndexable

@NotNull
static MutableByteIndexable.Base fromIntIndexable(@NotNull
                                                           IntIndexable indexable)

Return a mutable byte indexable initialized with the content of a standard int indexable. This will result in a loss of accuracy for various values.

Parameters:

indexable - int indexable

Returns:

mutable indexable initialized with the values of the given int indexable

fromShortIndexable

@NotNull
static MutableByteIndexable.Base fromShortIndexable(@NotNull
                                                             ShortIndexable indexable)

Return a mutable short indexable initialized with the content of a standard short indexable. This will cast short values to byte.

Parameters:

indexable - short indexable

Returns:

mutable indexable initialized with the values of the given short indexable

fromByteIndexable

@NotNull
static MutableByteIndexable.Base fromByteIndexable(@NotNull
                                                            ByteIndexable indexable)

Return a mutable short indexable initialized with the content of a standard byte indexable.

Parameters:

indexable - long indexable

Returns:

mutable indexable initialized with the values of the given byte indexable

fromIterable

@NotNull
static MutableByteIndexable.Base fromIterable(int size,
                                                       @NotNull
                                                       java.lang.Iterable<? extends java.lang.Number> iter)

Create a mutable indexable from an iterable or a part of it.

Parameters:

size - maximum size of returned indexable

iter - iterable used for initializing the indexable

Returns:

mutable indexable

zeroed

@NotNull
static MutableByteIndexable.Base zeroed(int size)

Create a mutable byte indexable with size 0.0 elements.

Parameters:

size - required size of returned mutable byte indexable

Returns:

mutable byte indexable of the given size initialized with 0.0

See Also:

init(int, byte), init(int, Supplier)

init

@NotNull
static MutableByteIndexable.Base init(int size,
                                               byte value)

Create a mutable

Specified by:

init in interface ByteIndexable

Parameters:

size - required size of returned mutable byte indexable

value - initial value of all elements

Returns:

mutable byte indexable of the given size initialized with value

See Also:

init(int, Supplier), zeroed(int)

initByIndex

@NotNull
static MutableByteIndexable.Base initByIndex(int size,
                                                      @NotNull
                                                      IntToByteFunction1 producer)

Get a mutable byte indexable of a given size which contains elements created by index.

Specified by:

initByIndex in interface ByteIndexable

Parameters:

size - size of the returned indexable

producer - producer which is called with an index and expected to return the associated value

Returns:

a mutable byte indexable with the given size with elements initialized by calling the producer

See Also:

ByteIndexable.viewByIndex(int, IntToByteFunction1)