implab/gradle-common Commit - r53:07d0d84bc0a2

common: extract replayable queue

cin -

r53:07d0d84bc0a2 default

parent child

Context file:

r53:07d0d84bc0a2

Collapse all files

common/src/main/java/org/implab/gradle/common/core/lang/ReplayableQueue.java created 644 +89 0

@@ -0,0 +1,89
	1	package org.implab.gradle.common.core.lang;
	2
	3	import java.util.LinkedList;
	4	import java.util.List;
	5	import java.util.function.Consumer;
	6
	7	import org.eclipse.jdt.annotation.NonNullByDefault;
	8
	9	/**
	10	* Replayable append-only notification queue.
	11	*
	12	* <p>
	13	* The queue stores values in insertion order and supports replaying all values
	14	* that were already added when a consumer is registered. The same consumer is
	15	* also retained and invoked for every value added later.
	16	*
	17	* <p>
	18	* Values are committed before dispatch. If a consumer throws while a value is
	19	* being added, the value remains recorded in the queue and will be visible to
	20	* later consumers through {@link #forEach(Consumer)} and {@link #values()}.
	21	*
	22	* <p>
	23	* Reentrant replay is intentionally not supported. Consumers must not call
	24	* {@link #add(Object)} or {@link #forEach(Consumer)} on the same queue while
	25	* they are being invoked by that queue. Such nested calls fail fast with
	26	* {@link IllegalStateException}. This keeps ordering predictable and avoids
	27	* recursive event-loop semantics.
	28	*
	29	* @param <T> value type
	30	*/
	31	@NonNullByDefault
	32	public class ReplayableQueue<T> {
	33	private final List<Consumer<? super T>> consumers = new LinkedList<>();
	34	private final List<T> values = new LinkedList<>();
	35	private boolean replaying = false;
	36
	37	/**
	38	* Adds a value and dispatches it to all registered consumers.
	39	*
	40	* <p>
	41	* The value is recorded before consumers are invoked. If dispatch fails, the
	42	* value still belongs to the queue.
	43	*
	44	* @param value value to add
	45	*/
	46	public void add(T value) {
	47	safeInvoke(value, v -> {
	48	values.add(v);
	49	consumers.forEach(consumer -> consumer.accept(v));
	50	});
	51	}
	52
	53	/**
	54	* Returns an immutable snapshot of values recorded so far.
	55	*
	56	* @return current values in insertion order
	57	*/
	58	public List<T> values() {
	59	return List.copyOf(values);
	60	}
	61
	62	/**
	63	* Replays all recorded values to the consumer and registers it for future
	64	* values.
	65	*
	66	* <p>
	67	* The consumer is registered only after replaying existing values succeeds.
	68	*
	69	* @param consumer consumer to replay and retain
	70	*/
	71	public void forEach(Consumer<? super T> consumer) {
	72	safeInvoke(values, v -> {
	73	v.forEach(consumer);
	74	consumers.add(consumer);
	75	});
	76	}
	77
	78	private <X> void safeInvoke(X value, Consumer<? super X> consumer) {
	79	if (replaying)
	80	throw new IllegalStateException("Reentrant replay is not supported: replay is in progress");
	81	try {
	82	replaying = true;
	83	consumer.accept(value);
	84	} finally {
	85	replaying = false;
	86	}
	87	}
	88
	89	}

common/src/test/java/org/implab/gradle/common/core/lang/ReplayableQueueTest.java created 644 +59 0

@@ -0,0 +1,59
	1	package org.implab.gradle.common.core.lang;
	2
	3	import static org.junit.jupiter.api.Assertions.assertEquals;
	4	import static org.junit.jupiter.api.Assertions.assertThrows;
	5	import static org.junit.jupiter.api.Assertions.assertTrue;
	6
	7	import java.util.ArrayList;
	8	import java.util.List;
	9
	10	import org.junit.jupiter.api.Test;
	11
	12	class ReplayableQueueTest {
	13	@Test
	14	void replaysExistingValuesAndReceivesFutureValues() {
	15	var queue = new ReplayableQueue<String>();
	16	var seen = new ArrayList<String>();
	17
	18	queue.add("one");
	19	queue.add("two");
	20	queue.forEach(seen::add);
	21	queue.add("three");
	22
	23	assertEquals(List.of("one", "two", "three"), seen);
	24	assertEquals(List.of("one", "two", "three"), queue.values());
	25	}
	26
	27	@Test
	28	void commitsValueBeforeDispatchingConsumers() {
	29	var queue = new ReplayableQueue<String>();
	30
	31	queue.forEach(value -> {
	32	throw new IllegalStateException("boom");
	33	});
	34
	35	assertThrows(IllegalStateException.class, () -> queue.add("one"));
	36	assertEquals(List.of("one"), queue.values());
	37	}
	38
	39	@Test
	40	void rejectsReentrantAdd() {
	41	var queue = new ReplayableQueue<String>();
	42
	43	queue.forEach(value -> queue.add("nested"));
	44
	45	var ex = assertThrows(IllegalStateException.class, () -> queue.add("one"));
	46	assertTrue(ex.getMessage().contains("Reentrant replay is not supported"));
	47	}
	48
	49	@Test
	50	void rejectsReentrantForEach() {
	51	var queue = new ReplayableQueue<String>();
	52	queue.add("one");
	53
	54	var ex = assertThrows(IllegalStateException.class, () -> queue.forEach(value -> queue.forEach(nested -> {
	55	})));
	56
	57	assertTrue(ex.getMessage().contains("Reentrant replay is not supported"));
	58	}
	59	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyRegistry.java +1 -1

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.function.Function;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Task;
             import org.gradle.api.file.FileSystemLocation;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.TaskProvider;
             import org.implab.gradle.common.core.lang.Deferred;
-            import org.implab.gradle.internal.ReplayableQueue;
+            import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
             import org.implab.gradle.variants.artifacts.ArtifactAssembly;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             @NonNullByDefault
             public class ArtifactAssemblyRegistry implements ArtifactAssemblies {
                 private final Map<ArtifactSlot, Deferred<ArtifactAssembly>> assembliesBySlots = new LinkedHashMap<>();
                 private final ReplayableQueue<ArtifactAssembly> assemblies = new ReplayableQueue<>();
                 public ArtifactAssemblyRegistry() {
                 }
                 public <T extends Task> ArtifactAssembly register(
                         ArtifactSlot slot,
                         TaskProvider<T> task,
                         Function<? super T, ? extends Provider<? extends FileSystemLocation>> mapOutputArtifact) {
                     var deferred = getDeferred(slot);
                     if (deferred.resolved()) {
                         throw new InvalidUserDataException("Artifact assembly '" + slot + "' is already registered");
                     }
                     var outputArtifact = task.flatMap(mapOutputArtifact::apply);
                     var assembly = new Assembly(outputArtifact, task);
                     deferred.resolve(assembly);
                     assemblies.add(assembly);
                     return assembly;
                 }
                 @Override
                 public Optional<ArtifactAssembly> find(ArtifactSlot slot) {
                     // to prevent creation of map entries on lookup use the map directly
                     var deferred = assembliesBySlots.get(slot);
                     return deferred != null && deferred.resolved()
                             ? Optional.of(deferred.value())
                             : Optional.empty();
                 }
                 @Override
                 public void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action) {
                     getDeferred(slot).whenResolved(action::execute);
                 }
                 @Override
                 public void configureEach(Action<? super ArtifactAssembly> action) {
                     assemblies.forEach(action::execute);
                 }
                 private Deferred<ArtifactAssembly> getDeferred(ArtifactSlot slot) {
                     return assembliesBySlots.computeIfAbsent(slot, k -> new Deferred<>());
                 }
                 static class Assembly implements ArtifactAssembly {
                     private final Provider<? extends FileSystemLocation> artifact;
                     private final TaskProvider<? extends Task> task;
                     Assembly(Provider<? extends FileSystemLocation> artifact, TaskProvider<? extends Task> task) {
                         this.artifact = artifact;
                         this.task = task;
                     }
                     @Override
                     public Provider<? extends FileSystemLocation> getArtifact() {
                         return artifact;
                     }
                     @Override
                     public TaskProvider<? extends Task> getAssemblyTask() {
                         return task;
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/OutgoingRegistry.java +7 -5

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.Set;
             import java.util.function.Consumer;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.artifacts.ConfigurationContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
             import org.implab.gradle.internal.IdentityContainerFactory;
-            import org.implab.gradle.internal.ReplayableQueue;
+            import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
             /**
-             * Реестр исходящих вариантов. Связывает исходящие конфигурации с вариантами
+             * Registry of variant-level outgoing models.
-             * сборки. Связь устанавливается 1:1.
+             * <p>Each declared outgoing model owns one lazy Gradle consumable configuration
+             * and one live slot identity container.
              */
             @NonNullByDefault
             public class OutgoingRegistry {
                 private final Map<Variant, OutgoingVariant> outgoingByVariant = new LinkedHashMap<>();
                 private final ReplayableQueue<OutgoingVariant> outgoingVariants = new ReplayableQueue<>();
                 private final ConfigurationContainer configurations;
                 private final ObjectFactory objects;
                 private final Set<Variant> declaredVariants;
                 public OutgoingRegistry(
                         ConfigurationContainer configurations,
                         ObjectFactory objects,
                         Set<Variant> declaredVariants) {
                     this.configurations = configurations;
                     this.objects = objects;
                     this.declaredVariants = declaredVariants;
                 }
                 public Optional<OutgoingVariant> find(Variant variant) {
                     return Optional.ofNullable(outgoingByVariant.get(variant));
                 }
                 public OutgoingVariant maybeCreate(Variant variant) {
                     return find(variant).orElseGet(() -> create(variant));
                 }
                 public OutgoingVariant create(Variant variant) {
                     if (!declaredVariants.contains(variant))
                         throw new InvalidUserDataException("Variant " + variant + " isn't declared");
                     if (outgoingByVariant.containsKey(variant))
                         throw new InvalidUserDataException("Outgoing variant " + variant + " already exists");
                     var configuration = configurations.consumable(outgoingConfigurationName(variant));
                     var outgoing = new Outgoing(variant, configuration);
                     outgoingByVariant.put(variant, outgoing);
                     outgoingVariants.add(outgoing);
                     return outgoing;
                 }
                 /**
-                 * Replayable hook which is applied when an outgoing variant is defined
+                 * Registers a replayable hook for outgoing variant declarations.
                  *
-                 * @param action
+                 * @param action outgoing variant action
                  */
                 public void configureEach(Consumer<? super OutgoingVariant> action) {
                     outgoingVariants.forEach(action);
                 }
                 private String outgoingConfigurationName(Variant variant) {
                     return variant.getName() + "Elements";
                 }
                 private class Outgoing implements OutgoingVariant {
                     private final Variant variant;
                     private final NamedDomainObjectProvider<? extends Configuration> configurationProvider;
                     private final NamedDomainObjectContainer<Slot> slots;
                     private final Property<Slot> primarySlot;
                     public Outgoing(
                             Variant variant,
                             NamedDomainObjectProvider<? extends Configuration> configurationProvider) {
                         this.variant = variant;
                         this.configurationProvider = configurationProvider;
                         this.slots = IdentityContainerFactory.create(objects, Slot.class);
                         this.primarySlot = objects.property(Slot.class);
                         primarySlot.finalizeValueOnRead();
                     }
                     @Override
                     public Property<Slot> getPrimarySlot() {
                         return primarySlot;
                     }
                     @Override
                     public Variant getVariant() {
                         return variant;
                     }
                     @Override
                     public NamedDomainObjectProvider<? extends Configuration> getConfiguration() {
                         return configurationProvider;
                     }
                     @Override
                     public NamedDomainObjectContainer<Slot> getSlots() {
                         return slots;
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/sources/internal/SourceSetConfigurationRegistry.java +2 -22

             package org.implab.gradle.variants.sources.internal;
             import java.text.MessageFormat;
             import java.util.LinkedHashMap;
-            import java.util.LinkedList;
             import java.util.List;
             import java.util.Map;
-            import java.util.function.Consumer;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.Named;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
+            import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             @NonNullByDefault
             public class SourceSetConfigurationRegistry {
                 private static final Logger logger = Logging.getLogger(SourceSetConfigurationRegistry.class);
                 private final Map<Layer, ReplayableQueue<GenericSourceSet>> sourcesByLayer = new LinkedHashMap<>();
                 private final Map<Variant, ReplayableQueue<GenericSourceSet>> sourcesByVariant = new LinkedHashMap<>();
                 private final Map<CompileUnit, ReplayableQueue<GenericSourceSet>> sourcesByUnit = new LinkedHashMap<>();
                 private final Supplier<LateConfigurationMode> lateConfigurationMode;
                 public SourceSetConfigurationRegistry(Supplier<LateConfigurationMode> lateConfigurationMode) {
                     this.lateConfigurationMode = lateConfigurationMode;
                 }
                 public void addLayerAction(Layer layer, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByLayer.computeIfAbsent(layer, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [layer={0}] layer already materialized",
                                     layer.getName()));
                 }
                 public void addVariantAction(Variant variant, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByVariant.computeIfAbsent(variant, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
                                     "Source sets for [variant={0}] variant already materialized",
                                     variant.getName()));
                 }
                 public void addCompileUnitAction(CompileUnit unit, Action<? super GenericSourceSet> action) {
                     addToActions(
                             sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()),
                             action,
                             MessageFormat.format(
-                                    "Source set for [variant={0}, layer={1}] already materialed",
+                                    "Source set for [variant={0}, layer={1}] already materialized",
                                     unit.variant().getName(),
                                     unit.layer().getName()));
                 }
                 private void addToActions(
                         ReplayableQueue<GenericSourceSet> actions,
                         Action<? super GenericSourceSet> action,
                         String assertMessage) {
                     assertLazyConfiguration(actions.values(), assertMessage);
                     actions.forEach(action::execute);
                 }
                 void assertLazyConfiguration(List<GenericSourceSet> sets, String message) {
                     if (sets.size() == 0)
                         return;
                     var names = sets.stream().map(Named::getName).collect(Collectors.joining(", "));
                     switch (lateConfigurationMode.get()) {
                         case FAIL:
                             throw new IllegalStateException(message + " [" + names + "]");
                         case WARN:
                             logger.warn(message + "\n\t" + names);
                             break;
                         default:
                             break;
                     }
                 }
                 public void applyConfiguration(CompileUnit unit, GenericSourceSet sourceSet) {
                     sourcesByVariant.computeIfAbsent(unit.variant(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByLayer.computeIfAbsent(unit.layer(), key -> new ReplayableQueue<>()).add(sourceSet);
                     sourcesByUnit.computeIfAbsent(unit, key -> new ReplayableQueue<>()).add(sourceSet);
                 }
-                class ReplayableQueue<T> {
-                    private final List<Consumer<? super T>> consumers = new LinkedList<>();
-                    private final List<T> values = new LinkedList<>();
-                    public void add(T value) {
-                        consumers.forEach(consumer -> consumer.accept(value));
-                        values.add(value);
             }
-                    List<T> values() {
-                        return List.copyOf(values);
-                    public void forEach(Consumer<? super T> consumer) {
-                        values.forEach(consumer);
-                        consumers.add(consumer);

variants/src/main/java/org/implab/gradle/internal/ReplayableQueue.java removed 0 -27

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages