A variable of type T with listeners of type L.

Author: tpietzsch

src/main/java/org/scijava/listeners/ListenableVar.java

@@ -0,0 +1,73 @@
+package org.scijava.listeners;
+
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+/**
+ * A variable of type {@code T}. Accessible via {@link #get()} /
+ * {@link #set(Object)}. Listeners of type {@code L} are notified when the
+ * variable is changed (or is set, alternatively).
+ *
+ * @author Tobias Pietzsch
+ */
+public class ListenableVar< T, L >
+{
+	private final AtomicReference< T > ref;
+
+	private final Listeners.List< L > listeners;
+
+	private final BiConsumer< L, T > notify;
+
+	private final boolean notifyWhenSet;
+
+	public ListenableVar( final T value, final Consumer< L > notify )
+	{
+		this( value, notify, false );
+	}
+
+	public ListenableVar( final T value, final BiConsumer< L, T > notify )
+	{
+		this( value, notify, false );
+	}
+
+	public ListenableVar( final T value, final Consumer< L > notify, final boolean notifyWhenSet )
+	{
+		this( value, ( l, t ) -> notify.accept( l ), notifyWhenSet );
+	}
+
+	public ListenableVar( final T value, final BiConsumer< L, T > notify, final boolean notifyWhenSet )
+	{
+		this.ref = new AtomicReference<>( value );
+		this.notify = notify;
+		this.notifyWhenSet = notifyWhenSet;
+		this.listeners = new Listeners.SynchronizedList<>();
+	}
+
+	public void set( final T value )
+	{
+		final T previous = this.ref.getAndSet( value );
+		if ( notifyWhenSet || !previous.equals( value ) )
+			listeners.list.forEach( l -> notify.accept( l, value ) );
+	}
+
+	public T get()
+	{
+		return ref.get();
+	}
+
+	public Listeners< L > listeners()
+	{
+		return listeners;
+	}
+
+	public static < T > ListenableVar< T, Runnable > simple( final T value )
+	{
+		return new ListenableVar<>( value, Runnable::run );
+	}
+
+	public static < T > ListenableVar< T, Runnable > simple( final T value, final boolean notifyWhenSet )
+	{
+		return new ListenableVar<>( value, Runnable::run, notifyWhenSet );
+	}
+}

src/test/java/org/scijava/listeners/ListenableVarTest.java

@@ -0,0 +1,70 @@
+package org.scijava.listeners;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ListenableVarTest
+{
+	@Test
+	public void testSet()
+	{
+		ListenableVar< Long, Runnable > var = ListenableVar.simple( 0L );
+		Assert.assertEquals( ( long ) var.get(), 0L );
+		var.set( 10L );
+		Assert.assertEquals( ( long ) var.get(), 10L );
+	}
+
+	interface ChangeListener
+	{
+		void changed();
+	}
+
+	@Test
+	public void testWithConsumer()
+	{
+		ListenableVar< Long, ChangeListener > var = new ListenableVar<>( 0L, ChangeListener::changed );
+		final AtomicBoolean notified = new AtomicBoolean( false );
+		var.listeners().add( () -> notified.set( true ) );
+		var.set( 10l );
+
+		Assert.assertTrue( notified.get() );
+		Assert.assertEquals( ( long ) var.get(), 10L );
+	}
+
+	@Test
+	public void testNoNotificationForUnchangedValue()
+	{
+		ListenableVar< Long, ChangeListener > var = new ListenableVar<>( 10L, ChangeListener::changed );
+		final AtomicBoolean notified = new AtomicBoolean( false );
+		var.listeners().add( () -> notified.set( true ) );
+		var.set( 10L );
+		Assert.assertFalse( notified.get() );
+	}
+
+	interface ValueListener< T >
+	{
+		void valueChanged( T value );
+	}
+
+	@Test
+	public void testWithBiConsumer()
+	{
+		ListenableVar< Long, ValueListener< Long > > var = new ListenableVar<>( 1L, ValueListener::valueChanged );
+		final AtomicLong notified = new AtomicLong();
+		var.listeners().add( notified::set );
+		var.set( 10L );
+		Assert.assertEquals( notified.get(), 10L );
+	}
+
+	@Test
+	public void testWithRunnable()
+	{
+		ListenableVar< Long, Runnable > var = ListenableVar.simple( 0L );
+		final AtomicBoolean notified = new AtomicBoolean( false );
+		var.listeners().add( () -> notified.set( true ) );
+		var.set( 10L );
+		Assert.assertTrue( notified.get() );
+	}
+}