/** * This interface provides a validation method that can be configured with a predicate. */ @Functional public static interface Key<K> { /** * Returns the validator which validates the keys. */ @Pure @Default("object -> true") public @Nonnull Predicate<? super K> getKeyValidator(); /** * Returns whether the given key is valid. */ @Pure public default boolean isValidKey(K key) { return getKeyValidator().evaluate(key); } }
/** * This interface provides a validation method that can be configured with a predicate. */ @Functional public static interface Value<V> { /** * Returns the validator which validates the values. */ @Pure @Default("object -> true") public @Nonnull Predicate<? super V> getValueValidator(); /** * Returns whether the given value is valid. */ @Pure public default boolean isValid(V value) { return getValueValidator().evaluate(value); } }
@Functional public interface Countable {
@Functional public interface CustomComparable<T extends CustomComparable<T>> extends Comparable<T> {
@Functional public interface LongNumerical<T extends LongNumerical<T>> extends CustomComparable<T> {
@Functional public interface BigIntegerNumerical<T extends BigIntegerNumerical<T>> extends CustomComparable<T> {
/** * Objects that implement this interface can be used to observe a {@link Configuration configuration}. */ @Functional public static interface Observer<@Unspecifiable PROVIDER> { /** * This method is called on {@link Configuration#register(net.digitalid.utility.configuration.Configuration.Observer) registered} observers when the provider of the given configuration has been replaced. * * @require !newProvider.equals(oldProvider) : "The new provider may not the same as the old provider."; */ public void notify(@Nonnull Configuration<PROVIDER> configuration, @Nullable PROVIDER oldProvider, @Nonnull PROVIDER newProvider); }
/** * Objects that implement this interface can be used to {@link Property#register(net.digitalid.utility.property.Observer) observe} {@link ReadOnlyVolatileValueProperty volatile value properties}. */ @Mutable @Functional public interface VolatileValueObserver<@Specifiable VALUE> extends ValueObserver<VALUE, RuntimeException, RuntimeException, VolatileValueObserver<VALUE>, ReadOnlyVolatileValueProperty<VALUE>> {}
@Functional public interface AnnotationHandler {
@Functional public interface Threading {
@Functional public interface UnaryOperator<TYPE> extends UnaryFunction<TYPE, TYPE>, FailableUnaryOperator<TYPE, RuntimeException> {
/** * Objects that implement this interface can be used to {@link Property#register(net.digitalid.utility.property.Observer) observe} {@link ReadOnlyVolatileSetProperty volatile set properties}. */ @Mutable @Functional public interface VolatileSetObserver<@Unspecifiable VALUE, @Unspecifiable READONLY_SET extends ReadOnlySet<@Nonnull @Valid VALUE>> extends SetObserver<VALUE, READONLY_SET, RuntimeException, RuntimeException, VolatileSetObserver<VALUE, READONLY_SET>, ReadOnlyVolatileSetProperty<VALUE, READONLY_SET>> {}
@Functional public interface Consumer<@Specifiable INPUT> extends FailableConsumer<INPUT, RuntimeException> {
/** * Objects that implement this interface can be used to {@link Property#register(net.digitalid.utility.property.Observer) observe} {@link ReadOnlyVolatileMapProperty volatile map properties}. */ @Mutable @Functional public interface VolatileMapObserver<@Unspecifiable KEY, @Unspecifiable VALUE, @Unspecifiable READONLY_MAP extends ReadOnlyMap<@Nonnull @Valid("key") KEY, @Nonnull @Valid VALUE>> extends MapObserver<KEY, VALUE, READONLY_MAP, RuntimeException, RuntimeException, VolatileMapObserver<KEY, VALUE, READONLY_MAP>, ReadOnlyVolatileMapProperty<KEY, VALUE, READONLY_MAP>> {}
@Functional public interface Predicate<@Specifiable INPUT> extends FailablePredicate<INPUT, RuntimeException> {
@Functional public interface BinaryOperator<@Specifiable TYPE> extends BinaryFunction<TYPE, TYPE, TYPE>, FailableBinaryOperator<TYPE, RuntimeException> {
@Functional public interface Producer<@Specifiable OUTPUT> extends FailableProducer<OUTPUT, RuntimeException> {
@Functional public interface InfiniteIterable<@Specifiable ELEMENT> extends FunctionalIterable<ELEMENT> {
@Functional public interface UnaryFunction<@Specifiable INPUT, @Specifiable OUTPUT> extends FailableUnaryFunction<INPUT, OUTPUT, RuntimeException> {
@Functional public interface FailableBinaryOperator<@Specifiable TYPE, @Unspecifiable EXCEPTION extends Exception> extends FailableBinaryFunction<TYPE, TYPE, TYPE, EXCEPTION> {