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

             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;

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

             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 {
                 }
                 /**
-                 * 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);

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

             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.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;
                             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()));
                 }
                     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