Deprecated API

Contents

• Deprecated Interfaces
• Deprecated Classes
• Deprecated Fields
• Deprecated Methods
• Deprecated Constructors

Deprecated Interfaces

Interface and Description
de.caff.generics.util.Counter.Creator outdated, use Supplier<Counter> instead

Deprecated Classes

Class and Description
de.caff.generics.algorithm.FastSequentialSearch use FastIntSequenceSearch instead

Deprecated Fields

Field and Description
de.caff.generics.function.Predicate1.ALWAYS_FALSE Use Predicate1.alwaysFalse() instead as the returned predicate is smarter.
de.caff.generics.function.Predicate1.ALWAYS_TRUE Use Predicate1.alwaysTrue() instead as the returned predicate is smarter.
de.caff.generics.Types.RELEASE_DATE Use ModuleVersion.VERSION instead, or ModuleVersionService.iterator()/ModuleVersionService.collectServices() for all modules
de.caff.generics.Types.VERSION use ModuleVersion.VERSION instead

Deprecated Methods

Method and Description
de.caff.generics.Types.addEnumeration(C, Enumeration<? extends T>) Use Types.addAll(Collection, Enumeration) instead
de.caff.generics.Types.addIterable(C, Iterable<? extends T>) Use Types.addAll(Collection, Iterable) instead
de.caff.generics.Types.addIterator(C, Iterator<? extends T>) Use Types.addAll(Collection, Iterator) instead
de.caff.generics.Indexable.addToCollection(Collection<? super T>) use Countable.addAllTo(Collection) instead
de.caff.generics.function.Predicate2.apply(P1, P2) This has been renamed to BiPredicate.test(Object, Object) to be more in sync with standard Java
de.caff.generics.Indexable.compare(Indexable<? extends E>, Indexable<? extends E>, Comparator<E>) use Types.lexicalCompare(Iterable, Iterable, Comparator) instead
de.caff.generics.Indexable.equal(Indexable<? extends E>, Indexable<? extends E>, BiPredicate<E, E>) use Countable.equal(Countable, Countable, BiPredicate) instead
de.caff.generics.MutableIndexable.filled(int, IntFunction<? extends E>) inconsistently named, use MutableIndexable.initByIndex(int, IntFunction) instead
de.caff.generics.PrimitiveBooleanIterable.forEachBooleanFragile(FragileBooleanConsumer<E>) use PrimitiveBooleanIterable.forEachBoolFragile(FragileBooleanConsumer) instead
de.caff.generics.ExpandableIndexable.from(Collection<? extends E>) overlaps with other from() methods, use ExpandableIndexable.fromCollection(Collection) instead
de.caff.generics.ExpandableIndexable.from(E...) overlaps with other from() methods, use ExpandableIndexable.fromArray(Object[]) instead
de.caff.generics.ExpandableIndexable.from(E[], int, int) overlaps with other from() methods, use ExpandableIndexable.fromArray(Object[], int, int) instead
de.caff.generics.ExpandableIndexable.from(Indexable<E>) overlaps with other from() methods, use ExpandableIndexable.fromIndexable(Indexable) instead
de.caff.generics.Indexable.fromArray(E...) this was inconsistently named, use Indexable.viewArray(Object[]) instead
de.caff.generics.Indexable.fromList(List<? extends E>) this was inconsistently named, use Indexable.viewList(List) instead
de.caff.generics.Indexable.hash(Indexable<?>) use Types.hash(Iterable) instead
de.caff.generics.MutableByteIndexable.initByIndex(IntToByteFunction1) use MutableByteIndexable.fillFrom(IntToByteFunction1) instead
de.caff.generics.MutableCharIndexable.initByIndex(IntToCharFunction1) use MutableCharIndexable.fillFrom(IntToCharFunction1) instead
de.caff.generics.MutableDoubleIndexable.initByIndex(IntToDoubleFunction) use MutableDoubleIndexable.fillFrom(IntToDoubleFunction) instead
de.caff.generics.MutableFloatIndexable.initByIndex(IntToFloatFunction1) use MutableFloatIndexable.fillFrom(IntToFloatFunction1) instead
de.caff.generics.MutableIntIndexable.initByIndex(IntUnaryOperator) use MutableIntIndexable.fillFrom(IntUnaryOperator) instead
de.caff.generics.Types.mapE(C, Enumeration<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Collection, Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, Enumeration<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Collection, Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, Iterable<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Collection, Iterable, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, Iterable<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Collection, Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, Iterator<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Collection, Iterator, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, Iterator<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Collection, Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, S[], FragileTypeConverter<T, ? super S>) use Types.mapFragile(Collection, Object[], FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(C, S[], FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Collection, Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Enumeration<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Enumeration<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Iterable<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Iterable, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Iterable<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Iterator<S>, FragileTypeConverter<T, ? super S>) use Types.mapFragile(Iterator, FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(Iterator<S>, FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(S[], FragileTypeConverter<T, ? super S>) use Types.mapFragile(Object[], FragileFunction1) instead which does not require handling a TypeConverterException
de.caff.generics.Types.mapE(S[], FragileTypeConverter<T, ? super S>, T) use Types.mapFragile(Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException
de.caff.generics.Types.naturalOrder(Class<T>) use Types.naturalOrder() instead
de.caff.generics.Types.naturalOrder(Collection<T>) use Types.naturalOrder() instead
de.caff.generics.util.Counter.substract(Counter) bad English, use Counter.subtract(Counter)
de.caff.generics.util.Counter.substract(int) bad English, use Counter.subtract(int)
de.caff.generics.util.Counter.substract1() bad English, use Counter.subtract1()
de.caff.generics.Indexable.toString(Indexable<?>) use Countable.toString(Countable)

Deprecated Constructors

Constructor and Description
de.caff.generics.CountingTreeSet() use CountingTreeSet.create() instead because it handles comparability correctly
de.caff.generics.CountingTreeSet(Supplier<Counter>) use CountingTreeSet.create(Supplier) instead because it handles comparability correctly