@GenerateSubclass public abstract class FreezableIterator<E> implements Iterator<E> {
/** * Generates a subclass of the given type. */ protected SubclassGenerator(@Nonnull TypeInformation typeInformation) { super(typeInformation.getQualifiedNameOfGeneratedSubclass(), typeInformation.getElement()); this.typeInformation = typeInformation; Require.that(typeInformation.getAnnotation(GenerateSubclass.class) != null).orThrow("The SubclassGenerator should not have been called if the annotation @GenerateSubclass is missing."); @Nonnull String modifier = ""; if (typeInformation.getAnnotation(GenerateSubclass.class).makePublic()) { modifier = "public "; } beginClass(modifier + "class " + typeInformation.getSimpleNameOfGeneratedSubclass() + importWithBounds(typeInformation.getTypeArguments()) + (typeInformation.getElement().getKind() == ElementKind.CLASS ? " extends " : " implements ") + importIfPossible(typeInformation.getType())); generateFields(); generateConstructors(); overrideMethods(); implementMethods(); generateMethods(); endClass(); }
if (typeInformation.getAnnotation(GenerateSubclass.class).makePublic()) { modifier = "public ";
@GenerateSubclass @Freezable(ReadOnlySet.class) public abstract class BackedFreezableSet<E> extends BackedFreezableCollection<E> implements FreezableSet<E> {
/** * This exception is thrown when the user escapes an {@link Option option}. */ @Immutable @GenerateBuilder @GenerateSubclass public abstract class EscapeException extends ExternalException { /* -------------------------------------------------- Message -------------------------------------------------- */ @Pure @Override public @Nonnull String getMessage() { return "The user escaped an action."; } /* -------------------------------------------------- Cause -------------------------------------------------- */ @Pure @Override public @Nullable Throwable getCause() { return null; } }
@GenerateSubclass @Freezable(ReadOnlyList.class) public abstract class BackedFreezableList<E> extends BackedFreezableCollection<E> implements FreezableList<E> {
@GenerateSubclass @Freezable(ReadOnlyArray.class) public abstract class FreezableArray<E> extends RootClass implements ReadOnlyArray<E>, FreezableIterable<E> {
@GenerateSubclass @Freezable(ReadOnlyList.class) public abstract class FreezableArrayList<E> extends ArrayList<E> implements FreezableList<E> {
/** * This class simplifies the creation and declaration of {@link WritableVolatileSetProperty}. */ @ThreadSafe @GenerateBuilder @GenerateSubclass @Mutable(ReadOnlyVolatileSimpleSetProperty.class) public abstract class WritableVolatileSimpleSetProperty<@Unspecifiable VALUE> extends WritableVolatileSetProperty<VALUE, ReadOnlySet<@Nonnull @Valid VALUE>, FreezableSet<@Nonnull @Valid VALUE>> implements ReadOnlyVolatileSimpleSetProperty<VALUE> { @Pure @Override @Default("net.digitalid.utility.collections.set.FreezableLinkedHashSetBuilder.build()") protected abstract @Nonnull @NonFrozen FreezableSet<@Nonnull @Valid VALUE> getSet(); }
/** * This class simplifies the creation and declaration of {@link WritableVolatileMapProperty}. */ @ThreadSafe @GenerateBuilder @GenerateSubclass @Mutable(ReadOnlyVolatileSimpleMapProperty.class) public abstract class WritableVolatileSimpleMapProperty<@Unspecifiable KEY, @Unspecifiable VALUE> extends WritableVolatileMapProperty<KEY, VALUE, ReadOnlyMap<@Nonnull @Valid("key") KEY, @Nonnull @Valid VALUE>, FreezableMap<@Nonnull @Valid("key") KEY, @Nonnull @Valid VALUE>> implements ReadOnlyVolatileSimpleMapProperty<KEY, VALUE> { @Pure @Override @Default("net.digitalid.utility.collections.map.FreezableLinkedHashMapBuilder.build()") protected abstract @Nonnull @NonFrozen FreezableMap<@Nonnull @Valid("key") KEY, @Nonnull @Valid VALUE> getMap(); }
@GenerateSubclass @Freezable(ReadOnlyList.class) public abstract class FreezableLinkedList<E> extends LinkedList<E> implements FreezableList<E> {
@GenerateSubclass public abstract class ConcurrentHashMap<K, V> extends java.util.concurrent.ConcurrentHashMap<K, V> implements ConcurrentMap<K, V> {
@GenerateSubclass public abstract class ConcurrentHashSet<E> extends AbstractSet<E> implements ConcurrentSet<E> {
@GenerateSubclass @Freezable(ReadOnlyCollection.class) public abstract class BackedFreezableCollection<E> extends RootClass implements FreezableCollection<E> {
@GenerateSubclass @GenerateConverter public abstract class Time extends RootClass implements LongNumerical<Time> {
@GenerateSubclass @Freezable(ReadOnlyMap.class) public abstract class FreezableHashMap<K, V> extends HashMap<K, V> implements FreezableMap<K, V> {
@GenerateSubclass @Freezable(ReadOnlyMap.class) public abstract class FreezableLinkedHashMap<K, V> extends LinkedHashMap<K, V> implements FreezableMap<K, V> {
@ThreadSafe @GenerateBuilder @GenerateSubclass public abstract class ThreadLocalIterable<@Specifiable ELEMENT> implements FiniteIterable<ELEMENT> {
@GenerateSubclass @Freezable(ReadOnlySet.class) public abstract class FreezableLinkedHashSet<E> extends LinkedHashSet<E> implements FreezableSet<E> {
@GenerateSubclass @Freezable(ReadOnlySet.class) public abstract class FreezableHashSet<E> extends HashSet<E> implements FreezableSet<E> {