Make ListenableVar<T,L> an interface with static create() methods

Author: tpietzsch

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

@@ -0,0 +1,6 @@
+package org.scijava.listeners;
+
+public interface ChangeListener
+{
+	void valueChanged();
+}

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

@@ -0,0 +1,71 @@
+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).
+ *
+ * @param <T>
+ *            value type
+ * @param <L>
+ *            listener type
+ *
+ * @author Tobias Pietzsch
+ */
+public class DefaultListenableVar< T, L > implements 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 DefaultListenableVar( final T value, final Consumer< L > notify )
+	{
+		this( value, notify, false );
+	}
+
+	public DefaultListenableVar( final T value, final BiConsumer< L, T > notify )
+	{
+		this( value, notify, false );
+	}
+
+	public DefaultListenableVar( final T value, final Consumer< L > notify, final boolean notifyWhenSet )
+	{
+		this( value, ( l, t ) -> notify.accept( l ), notifyWhenSet );
+	}
+
+	public DefaultListenableVar( 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<>();
+	}
+
+	@Override
+	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 ) );
+	}
+
+	@Override
+	public T get()
+	{
+		return ref.get();
+	}
+
+	@Override
+	public Listeners< L > listeners()
+	{
+		return listeners;
+	}
+}

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

@@ -1,6 +1,5 @@
 package org.scijava.listeners;
 
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
@@ -9,65 +8,48 @@
  * {@link #set(Object)}. Listeners of type {@code L} are notified when the
  * variable is changed (or is set, alternatively).
  *
+ * @param <T>
+ *            value type
+ * @param <L>
+ *            listener type
+ *
  * @author Tobias Pietzsch
  */
-public class ListenableVar< T, L >
+public interface ListenableVar< T, L >
 {
-	private final AtomicReference< T > ref;
-
-	private final Listeners.List< L > listeners;
-
-	private final BiConsumer< L, T > notify;
+	T get();
 
-	private final boolean notifyWhenSet;
-
-	public ListenableVar( final T value, final Consumer< L > notify )
-	{
-		this( value, notify, false );
-	}
+	void set( T value );
 
-	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 );
-	}
+	Listeners< L > listeners();
 
-	public ListenableVar( final T value, final BiConsumer< L, T > notify, final boolean notifyWhenSet )
+	public static < T > ListenableVar< T, ChangeListener > create( final T value )
 	{
-		this.ref = new AtomicReference<>( value );
-		this.notify = notify;
-		this.notifyWhenSet = notifyWhenSet;
-		this.listeners = new Listeners.SynchronizedList<>();
+		return new DefaultListenableVar<>( value, ChangeListener::valueChanged );
 	}
 
-	public void set( final T value )
+	public static < T > ListenableVar< T, ChangeListener > create( final T value, final boolean notifyWhenSet )
 	{
-		final T previous = this.ref.getAndSet( value );
-		if ( notifyWhenSet || !previous.equals( value ) )
-			listeners.list.forEach( l -> notify.accept( l, value ) );
+		return new DefaultListenableVar<>( value, ChangeListener::valueChanged, notifyWhenSet );
 	}
 
-	public T get()
+	public static < T, L > ListenableVar< T, L > create( final T value, final Consumer< L > notify )
 	{
-		return ref.get();
+		return new DefaultListenableVar<>( value, notify );
 	}
 
-	public Listeners< L > listeners()
+	public static < T, L > ListenableVar< T, L > create( final T value, final BiConsumer< L, T > notify )
 	{
-		return listeners;
+		return new DefaultListenableVar<>( value, notify, false );
 	}
 
-	public static < T > ListenableVar< T, Runnable > simple( final T value )
+	public static < T, L > ListenableVar< T, L > create( final T value, final Consumer< L > notify, final boolean notifyWhenSet )
 	{
-		return new ListenableVar<>( value, Runnable::run );
+		return new DefaultListenableVar<>( value, notify, notifyWhenSet );
 	}
 
-	public static < T > ListenableVar< T, Runnable > simple( final T value, final boolean notifyWhenSet )
+	public static < T, L > ListenableVar< T, L > create( final T value, final BiConsumer< L, T > notify, final boolean notifyWhenSet )
 	{
-		return new ListenableVar<>( value, Runnable::run, notifyWhenSet );
+		return new DefaultListenableVar<>( value, notify, notifyWhenSet );
 	}
 }

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

@@ -2,6 +2,7 @@
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
+
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -10,21 +11,21 @@ public class ListenableVarTest
 	@Test
 	public void testSet()
 	{
-		ListenableVar< Long, Runnable > var = ListenableVar.simple( 0L );
+		final ListenableVar< Long, ChangeListener > var = ListenableVar.create( 0L );
 		Assert.assertEquals( ( long ) var.get(), 0L );
 		var.set( 10L );
 		Assert.assertEquals( ( long ) var.get(), 10L );
 	}
 
-	interface ChangeListener
+	interface MyChangeListener
 	{
 		void changed();
 	}
 
 	@Test
 	public void testWithConsumer()
 	{
-		ListenableVar< Long, ChangeListener > var = new ListenableVar<>( 0L, ChangeListener::changed );
+		final ListenableVar< Long, MyChangeListener > var = ListenableVar.create( 0L, MyChangeListener::changed );
 		final AtomicBoolean notified = new AtomicBoolean( false );
 		var.listeners().add( () -> notified.set( true ) );
 		var.set( 10l );
@@ -36,7 +37,7 @@ public void testWithConsumer()
 	@Test
 	public void testNoNotificationForUnchangedValue()
 	{
-		ListenableVar< Long, ChangeListener > var = new ListenableVar<>( 10L, ChangeListener::changed );
+		final ListenableVar< Long, MyChangeListener > var = ListenableVar.create( 10L, MyChangeListener::changed );
 		final AtomicBoolean notified = new AtomicBoolean( false );
 		var.listeners().add( () -> notified.set( true ) );
 		var.set( 10L );
@@ -51,7 +52,7 @@ interface ValueListener< T >
 	@Test
 	public void testWithBiConsumer()
 	{
-		ListenableVar< Long, ValueListener< Long > > var = new ListenableVar<>( 1L, ValueListener::valueChanged );
+		final ListenableVar< Long, ValueListener< Long > > var = ListenableVar.create( 1L, ValueListener::valueChanged );
 		final AtomicLong notified = new AtomicLong();
 		var.listeners().add( notified::set );
 		var.set( 10L );
@@ -61,7 +62,7 @@ public void testWithBiConsumer()
 	@Test
 	public void testWithRunnable()
 	{
-		ListenableVar< Long, Runnable > var = ListenableVar.simple( 0L );
+		final ListenableVar< Long, ChangeListener > var = ListenableVar.create( 0L );
 		final AtomicBoolean notified = new AtomicBoolean( false );
 		var.listeners().add( () -> notified.set( true ) );
 		var.set( 10L );