de.caff.generics (CAFF Viewer Class Documentation)

Interface Summary
Interface	Description
Accessor<T>	Abstraction for getting and setting a value.
ActiveListListener<T>	A listener for `active lists`.
ArrayFactory<T>	Factory for array creation.
BooleanIndexable	Class which allows readonly access of raw booleans by index.
BooleanIndexable.EntryConsumer	Consumer for index-value pairs with `int` values.
ByteIndexable	Class which allows readonly access of raw bytes by index.
CharIndexable	Class which allows readonly access of raw chars by index.
Copier<T>	Get copies of items of a given class.
Copyable<T>	Enhanced cloning support.
Countable<T>	Something containing a defined number of arbitrary elements which can be iterated over.
CountingSet<T>	A set which counts the number of additions.
Dict<K,V>	A dictionary.
DoubleIndexable	Class which allows readonly access of raw doubles by index.
ExpandableDoubleIndexable	Immutable expandable primitive double indexable.
ExpandableIndexable<T>	Immutable expandable indexable.
ExpandableIntIndexable	Immutable expandable primitive integer indexable.
ExpandableLongIndexable	Immutable expandable primitive long indexable.
Factory<T>	A factory knows how to create objects of a given type.
FloatIndexable	Class which allows readonly access of raw floats by index.
FragileLoopItemHandler<T,E extends java.lang.Exception>	A generic handler for loop items which may throw an exception.
FragileTypeConverter<T,S>	Converter which knows how to convert one type into another, but may throw an exception in certain cases..
FStack<T>	A functional stack.
HashCodeCalculator<T>	Calculator interface for generalized hash code calculation.
Indexable<T>	Class which allows readonly access by index.
IntCountable	Something containing a defined number of int values which can be iterated over.
IntIndexable	Class which allows readonly access of raw integers by index.
IntIndexable.EntryConsumer	Consumer for index-value pairs with `int` values.
LongIndexable	Class which allows readonly access of raw long integers by index.
LoopHandler	Handler for loops.
LoopItemHandler<T>	Generic handler of items during a loop..
Matcher<T1,T2>
MutableBooleanIndexable	Primitive boolean indexable with fixed length but mutable content.
MutableByteIndexable	Primitive byte indexable with fixed length but mutable content.
MutableCharIndexable	Primitive char indexable with fixed length but mutable content.
MutableDoubleIndexable	Primitive double indexable with fixed length but mutable content.
MutableFloatIndexable	Primitive float indexable with fixed length but mutable content.
MutableIndexable<T>	Indexable with fixed length but mutable content.
MutableIntIndexable	Primitive int indexable with fixed length but mutable content.
MutableLongIndexable	Primitive long indexable with fixed length but mutable content.
MutableShortIndexable	Primitive short indexable with fixed length but mutable content.
NamedNullableValue<T>	A nullable value with a name.
NamedValue<T>	A non-null value with a name.
NullableAccessor<T>	Abstractign for getting and setting a value.
PrimitiveBooleanIterable	Iterable which iterates over a primitive boolean.
PrimitiveBooleanIterator	An iterator specialized for `boolean` values.
PrimitiveByteIterable	Iterable which iterates over a primitive byte.
PrimitiveByteIterator	An iterator specialized for `short` values.
PrimitiveCharIterable	Iterable which iterates over a primitive char.
PrimitiveCharIterator	An iterator specialized for `cahr` values.
PrimitiveDoubleIterable	Iterable which iterates over a primitive double.
PrimitiveFloatIterable	Iterable which iterates over a primitive float.
PrimitiveFloatIterator	An iterator specialized for `float` values.
PrimitiveIntIterable	Iterable which iterates over a primitive int.
PrimitiveLongIterable	Iterable which iterates over a primitive long.
PrimitiveShortIterable	Iterable which iterates over a primitive short.
PrimitiveShortIterator	An iterator specialized for `short` values.
ReferenceCreator<R extends java.lang.ref.Reference<? super V>,V>	Reference creator.
ShortIndexable	Class which allows readonly access of raw short integers by index.
Sizeable	Something which has an integer size.
Subject<T>	This is mainly a marker interface for subjectivized objects.
Subjective<T>	Type-based information how to create a `Subject` from an object.
TwoWayChoice<T>	A choice between two values.
TwoWayChoiceN<T>	A choice between two values which may be `null`.
TwoWayTypeConverter<T,S>	Type converter which can convert between two types in both ways.
UniformMatcher<T>	A uniform matcher is a `Matcher` which can only compare objects of the same type.

Class Summary
Class	Description
AbstractBasicCopyable<T extends java.lang.Cloneable>	Basic implementation of copyable object.
AbstractBasicCountingSet<T>	Basic implementation for counting sets.
AbstractBasicUnmodifiableList<T>	Basic implementation of an unmodifiable list.
ActiveList<T>	An active lists sends events on changes.
ArrayIterator<T>	An iterator over an array.
BasicLoop<T extends BasicLoop.Item<T>>	Wrapper around a double linked list which forms a loop.
BasicLoop.Item<V extends BasicLoop.Item<V>>	Base implementation of a double linked loop item.
BooleanIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
BooleanPair	A pair of primitive boolean values.
ByteIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
BytePair	A pair of primitive byte values.
CharIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
CharPair	A pair of primitive char values.
ConcatenatedIterables<T>	Concatenated iterables.
ConcatenatedIterators<T>	Concatenated iterators.
CopierFStackImpl<T>	Implementation of a functional stack which takes care of mutable elements by copying them.
CopierFStackImpl.Empty<T>	Empty copier stack implementation.
Countable.Base<TT>	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
CountingHashSet<T>	A set which also counts how often any element was added.
CountingTreeSet<T>	A sorted set which also counts how often any element was added.
Dict.Base<KK,VV>	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
Dict.Entry<EK,EV>	Entry access.
DoubleIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
DoubleIndexable.DoubleIndexableSpliterator	Spliterator for double indexables.
DoublePair	A pair of primitive double values.
Empty	This interface just contains various constant empty items (especially arrays): These can be used as defaults in various circumstances.
EnumerationIterator<T>	Iterator wrapper for an enumeration.
Enums	Toolbox for enums.
ExpandableDoubleIndexableImpl	Default implementation used for immutable expandable double indexable.
ExpandableIndexableImpl	Default implementation used for immutable expandable indexable.
ExpandableIntIndexableImpl	Default implementation used for immutable expandable integer indexable.
ExpandableLongIndexableImpl	Default implementation used for immutable expandable long indexable.
FilteringIteratorWrapper<T>	A wrapper for a standard iterator which only iterates over selected elements.
FloatIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
FloatPair	A pair of primitive float values.
FStackImpl<T>	Implementation of a functional stack.
HashCacheWrapper<T>	Helper class which is caching a hash value.
HashCoder<T>	Helper interface for `HashCoderMap`.
HashCoderMap<K,V>	A hashmap implementation that allows to provide a dedicated hashcode implementation for its elements.
HashCoderSet<V>	A hashset implementation which allows to provide a dedicated hashcode implementation for its elements.
Indexable.Base<TT>	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
Indexable.IndexableSpliterator<TElem>	A spliterator for indexables.
Indexable.ListView<T>	Helper class for viewing a mutable indexable as a standard list.
IndexableHelper	Helper class for indexables.
IntCountable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
IntIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
IntIndexable.IntIndexableSpliterator	Spliterator for int indexables.
IntPair	A pair of primitive int values.
IterableConverter<T,S>
IteratorConverter<T,S>	Convert an iterator to another type.
IteratorEnumeration<T>	Enumeration wrapper for an iterator.
LeastRecentlyUsedCache<K,V>	A map which implements a least recently used cache.
ListIteratorConverter<T,S>	A list iterator which maps the returned value.
LongIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
LongIndexable.LongIndexableSpliterator	Spliterator for long indexables.
LongPair	A pair of primitive long values.
Loop<T>	Generic version of a loop where loop items can contain any value.
Loop.Item<T>	Generic loop item.
MatchSet<E>	A set which is using an `UniformMatcher` for checker for equality.
MutableBooleanIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableByteIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableCharIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableDoubleIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableFloatIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableIndexable.Base<TT>	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableIndexable.ListView<T>	Helper class for viewing a mutable indexable as a standard list.
MutableIntIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableLongIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
MutableShortIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
OrderedPair<S,T>	A simple ordered pair.
Pair<T>	An ordered pair with equal types for first and second.
Primitives	Primitives helper tool.
Pythonesque	Helper class for pythionesque indexing.
RecreatingLeastRecentlyUsedCache<K,V>	A least recently used cache which also allows to predefine a way to recreate lost entries.
References	Helper for reference creation.
RefValueHashMap<K,V>	A hashmap with strong keys and soft referenced values.
RefWrapperHashSet<V>	A hash st which holds its elements as references.
RefWrapperList<V>	A list which holds its elements as references.
Sequences	Equality and comparability for sequences.
ShortIndexable.Base	Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
ShortPair	A pair of primitive short values.
SingletonIterator<T>	An iterator which iterates over a single element.
SoftPropertyChangeListener	Wrapper for a property change listener which reference the original change listener softly.
SoftValueHashMap<K,V>	A hashmap with strong keys and soft referenced values.
Subject.Base<TT>
Subjectivity	A subjective view on objects.
SynchronizedCollection<T>	Synchronized collection.
SynchronizedList<T>	Synchronized list.
Types	Tool with helpful methods for type conversion.
TypesImpFilter	Partial class used by Types, defining the filter algorithms.
TypesImplFolding	Partial class used by Types, defining the folding algorithms.
TypesImplMap	Partial class used by Types, defining the map algorithms.
UnmodifiableListArrayWrapper<T>	Let an array appear as an unmodifiable list.
UnmodifiableListBooleanArrayWrapper	Let an array appear as an unmodifiable list.
UnmodifiableListByteArrayWrapper	Let an array appear as an unmodifiable list.
UnmodifiableListDoubleArrayWrapper	Let an array appear as an unmodifiable list.
UnmodifiableListFloatArrayWrapper	Let an array appear as an unmodifiable list.
UnmodifiableListIntArrayWrapper	Let an int array appear as an unmodifiable list.
UnmodifiableListLongArrayWrapper	Let an array appear as an unmodifiable list.
UnmodifiableListShortArrayWrapper	Let an array appear as an unmodifiable list.
WeakPropertyChangeListener	Wrapper for a property change listener which reference the original change listener weakly.
WeakValueHashMap<K,V>	A hashmap with strong keys and weakly referenced values.

Enum Summary
Enum Description

Order
Order of two values.

Enum Summary
Enum	Description
Order	Order of two values.

Exception Summary
Exception	Description
TypeConverterException	Exception thrown during type conversion.
WrappedFragileException	A runtime exception wrapper for a checked exception which occurred in places where there is no way to handle it.

Error Summary
Error Description

EmptyLoopError
Empty loop error thrown when accessing elements of an empty BasicLoop.

FactoryError
Error which the Factory.create() method may throw.

Error Summary
Error	Description
EmptyLoopError	Empty loop error thrown when accessing elements of an empty `BasicLoop`.
FactoryError	Error which the `Factory.create()` method may throw.

Package de.caff.generics Description

Generics tools package.

Package Specification

Most items in this package are no longer necessary when using Java 8 and later.

This package contains classes using generics to allow for functional programming without the overhead of streams and also have dedicated read-only collections.

Read-only Collection Interfaces

The package provides some read-only substitutes for standard collections. Basically they can be used in places where a standard collection with an unmodifiable wrapper is used, with the main advantage that using one of the classes here substitutes the implicit don't modify (or you'll get an excpetion) with a much clearer can't modify (because there are no methods for that). The classes are

Interface from this Package	Purpose
`Countable`	Read-only substitute for `java.util.Collection`
`Indexable`	Read-only subatitute for `java.util.List` and arrays
`Dict`	Read-only substitute for `java.util.Map`
`FStack`	Functional implementation similar to `java.util.Stack`, used a bit differently

As these interfaces only provide read-only methiods it's simple to view them as if they have different contents.

Similar to Indexable for objects there are also flavors for all primitive values, e.g. IntIndexable for int. In many cases these can be used instead of arrays, again with the advantage that they are not modifiable. So they can be used as public constants which would be a bad idea with an array. Also useful when an array field is returned from a method. Using arrays usually a copy is necessary when returning such a field when the receiver should not be able to modify the array's content.

Handling Standard Collections

Copying one collection into another while modifying it is possible with streams, but sometimes this is a bit over the top. In these cases many methods provided here are still useful.

Easy type conversion for iterating over collections and similar (i.e. any Iterable, Iterator and Enumeration): see
- Types.downCast(java.lang.Iterable) (safe)
- Types.downCast(java.util.Iterator) (safe)
- Types.downCast(java.util.Enumeration) (safe)
- Types.cast(java.lang.Iterable) (unsafe)
- Types.cast(java.util.Iterator) (unsafe)
- Types.cast(java.util.Enumeration) (unsafe)
Various standard type conversions, usable for converting between collections, see next point:
- Types.TO_STRING: converting to string, using the toString() method
- Types.STR_TO_DOUBLE: converting strings to Double
- Types.STR_TO_FLOAT: converting strings to Float
- Types.STR_TO_LONG: converting strings to Long
- Types.STR_TO_LONG_BASE_16: converting strings to Long
- Types.STR_TO_LONG_BASE_8: converting strings to Long
- Types.STR_TO_LONG_BASE_2: converting strings to Long
- Types.STR_TO_INT: converting strings to Integer
- Types.STR_TO_INT_BASE_16: converting strings to Integer
- Types.STR_TO_INT_BASE_8: converting strings to Integer
- Types.STR_TO_INT_BASE_2: converting strings to Integer
- Types.STR_TO_SHORT: converting strings to Short
- Types.STR_TO_SHORT_BASE_16: converting strings to Short
- Types.STR_TO_SHORT_BASE_8: converting strings to Short
- Types.STR_TO_SHORT_BASE_2: converting strings to Short
- Types.STR_TO_BYTE: converting strings to Byte
- Types.STR_TO_BYTE_BASE_16: converting strings to Byte
- Types.STR_TO_BYTE_BASE_8: converting strings to Byte
- Types.STR_TO_BYTE_BASE_2: converting strings to Byte
- Types.NUMBER_TO_DOUBLE: converting any Number based type to Double
- Types.NUMBER_TO_FLOAT: converting any Number based type to Float
- Types.NUMBER_TO_LONG: converting any Number based type to Long
- Types.NUMBER_TO_INT: converting any Number based type to Integer
- Types.NUMBER_TO_SHORT: converting any Number based type to Short
- Types.NUMBER_TO_BYTE: converting any Number based type to Byte
Mapping of a collection or array to another collection, not allowing conversion exceptions:
The same but with possible conversion exceptions:
Doing something for each item in a collection or an array: see
- Types.forEach(java.lang.Object[], de.caff.generics.LoopItemHandler) (w/o exception)
- Types.forEach(java.lang.Object[], de.caff.generics.FragileLoopItemHandler) (w/ exception)
- Types.forEach(java.lang.Iterable, de.caff.generics.LoopItemHandler) (w/o exception)
- Types.forEach(java.lang.Iterable, de.caff.generics.FragileLoopItemHandler) (w/ exception)
- Types.forEach(java.util.Iterator, de.caff.generics.LoopItemHandler) (w/o exception)
- Types.forEach(java.util.Iterator, de.caff.generics.FragileLoopItemHandler) (w/ exception)
- Types.forEach(java.util.Enumeration, de.caff.generics.LoopItemHandler) (w/o exception)
- Types.forEach(java.util.Enumeration, de.caff.generics.FragileLoopItemHandler) (w/ exception)
Pairs of values: see
- OrderedPair: pair with differently typed items
- Pair: pair with items of same type
Converting enumerations to iterations and vice versa:
- EnumerationIterator: enumeration to iterator
- IteratorEnumeration: iterator to enumeration
The possibility to extract objects of a given type from a collection or array:
- Types.extract(java.lang.Object[], java.lang.Class): default return
- Types.extract(java.util.Collection, java.lang.Object[], java.lang.Class): returning predefined collection
- Types.extract(java.lang.Iterable, java.lang.Class): default return
- Types.extract(java.util.Collection, java.lang.Iterable, java.lang.Class): returning predefined collection
- Types.extract(java.util.Iterator, java.lang.Class): default return
- Types.extract(java.util.Collection, java.util.Iterator, java.lang.Class): returning predefined collection
- Types.extract(java.util.Enumeration, java.lang.Class): default return
- Types.extract(java.util.Collection, java.util.Enumeration, java.lang.Class): returning predefined collection
Various collections and helper classes for using referenced values:
- ReferenceCreator: create references
- References: simple access to basic reference generators, see above
- RefValueHashMap: a hash map with references values
- RefWrapperHashSet: a hash set with referenced values
- RefWrapperList: a list with referenced values
- SoftValueHashMap: a hash map with softly referenced values
- WeakValueHashMap: a hash map with weakly referenced values
A wrapper to use an array as a list which does not copy the array as Arrays.asList(Object[]) is doing: UnmodifiableListArrayWrapper, but better use
Even better: these wrappers also exist for primitive arrays, e.g. arrays of ints.
A copy on demand implementation of a synchronized collection which is easier to use compared to the one returned from Collections.synchronizedCollection(java.util.Collection) (especially there's no need for explicit synchronization), and is highly performant in situations where the underlying collection is often iterated over, but rarely changed. The last is usually true for listener collections.
A property change listener which is referenced weakly or softly.
Support for matching, which is a generalization of the flawed equality concept provided by the Object.equals(java.lang.Object) method. See
- the basic interface
- a simplified interface for the most common case
- the Match class which provides some basic matchers
- various methods for checking equality (based on a matcher) for arrays, collections and similar: