Implemented 'NestedDoubleProperty' including the builder and tests.

Author: Nicolai Parlog

demo/org/codefx/libfx/nesting/NestingDemo.java

@@ -49,9 +49,8 @@ public static void main(String[] args) {
 	 * Demonstrates the use of {@link NestedProperty}.
 	 */
 	private void demoNestedProperties() {
-		// TODO change this to DoubleProperty as soon as that is implemented
-		Property<Number> currentEmployeesSalary = Nestings.on(currentEmployee)
-				.nest(employee -> employee.salaryProperty())
+		DoubleProperty currentEmployeesSalary = Nestings.on(currentEmployee)
+				.nestDoubleProperty(employee -> employee.salaryProperty())
 				.buildProperty();
 
 		System.out

src/org/codefx/libfx/nesting/AbstractNestingNestingBuilder.java

@@ -2,6 +2,7 @@
 
 import java.util.Objects;
 
+import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.Property;
 import javafx.beans.value.ObservableValue;
@@ -95,6 +96,22 @@ public IntegerPropertyNestingBuilder nestIntegerProperty(NestingStep<T, IntegerP
 		return new IntegerPropertyNestingBuilder(this, nestingStep);
 	}
 
+	/**
+	 * Returns a builder for nestings whose inner observable is a {@link DoubleProperty}. The created nestings depend on
+	 * this builder's outer observable and nesting steps and adds the specified step as the next one.
+	 *
+	 * @param nestingStep
+	 *            the function which performs the nesting step from one observable to the next
+	 * @return an {@link ObservableValueNestingBuilder} which builds a nesting from this builder's settings and the
+	 *         specified nesting steps
+	 * @throws NullPointerException
+	 *             if the specified function is null
+	 */
+	public DoublePropertyNestingBuilder nestDoubleProperty(NestingStep<T, DoubleProperty> nestingStep) {
+		Objects.requireNonNull(nestingStep, "The argument 'nestingStep' must not be null.");
+		return new DoublePropertyNestingBuilder(this, nestingStep);
+	}
+
 	//#end NEST
 
 }

src/org/codefx/libfx/nesting/DoublePropertyNestingBuilder.java

@@ -0,0 +1,59 @@
+package org.codefx.libfx.nesting;
+
+import javafx.beans.property.DoubleProperty;
+
+import org.codefx.libfx.nesting.property.NestedDoublePropertyBuilder;
+import org.codefx.libfx.nesting.property.NestedObjectPropertyBuilder;
+
+/**
+ * A builder for all kinds of nested functionality whose innermost value is held by a {@link DoubleProperty}.
+ */
+public class DoublePropertyNestingBuilder extends AbstractNestingBuilder<Number, DoubleProperty> {
+
+	// #region CONSTRUCTION
+
+	/**
+	 * Creates a new nesting builder which acts as a nested builder.
+	 *
+	 * @param <P>
+	 *            the type the previous builder wraps
+	 * @param previousNestedBuilder
+	 *            the previous builder
+	 * @param nestingStep
+	 *            the function which performs the nesting step from one observable to the next
+	 */
+	<P> DoublePropertyNestingBuilder(
+			AbstractNestingBuilder<P, ?> previousNestedBuilder,
+			NestingStep<P, DoubleProperty> nestingStep) {
+
+		super(previousNestedBuilder, nestingStep);
+	}
+
+	//#end CONSTRUCTION
+
+	// #region BUILD
+
+	/**
+	 * Creates a nested property from this builder's settings. This method can be called arbitrarily often and each call
+	 * returns a new instance.
+	 *
+	 * @return a new {@link DoubleProperty} instance with no owning bean and no name
+	 */
+	public DoubleProperty buildProperty() {
+		Nesting<DoubleProperty> nesting = buildNesting();
+		return NestedDoublePropertyBuilder.forNesting(nesting).build();
+	}
+
+	/**
+	 * Returns a nested object property builder which can be used to define the new property's attributes before
+	 * building it.
+	 *
+	 * @return a new instance of {@link NestedObjectPropertyBuilder}
+	 */
+	public NestedDoublePropertyBuilder buildPropertyWithBuilder() {
+		Nesting<DoubleProperty> nesting = buildNesting();
+		return NestedDoublePropertyBuilder.forNesting(nesting);
+	}
+
+	//#end BUILD
+}

src/org/codefx/libfx/nesting/property/NestedDoubleProperty.java

@@ -0,0 +1,64 @@
+package org.codefx.libfx.nesting.property;
+
+import java.util.Objects;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.Property;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A {@link DoubleProperty} which also implements {@link NestedProperty}.
+ */
+public class NestedDoubleProperty extends SimpleDoubleProperty implements NestedProperty<Number> {
+
+	// #region PROPERTIES
+
+	/**
+	 * The property indicating whether the nesting's inner observable is currently null.
+	 */
+	private final BooleanProperty innerObservableNull;
+
+	//#end PROPERTIES
+
+	// #region CONSTUCTION
+
+	/**
+	 * Creates a new property. Except {@code nesting} all arguments can be null.
+	 *
+	 * @param nesting
+	 *            the nesting this property is based on
+	 * @param bean
+	 *            the bean which owns this property; can be null
+	 * @param name
+	 *            this property's name; can be null
+	 */
+	NestedDoubleProperty(Nesting<? extends Property<Number>> nesting, Object bean, String name) {
+		super(bean, name);
+		Objects.requireNonNull(nesting, "The argument 'nesting' must not be null.");
+		this.innerObservableNull = new SimpleBooleanProperty(this, "innerObservableNull");
+
+		PropertyToNestingBinding.bind(this, isNull -> innerObservableNull.set(isNull), nesting);
+	}
+
+	//#end CONSTUCTION
+
+	// #region IMPLEMENTATION OF 'NestedProperty'
+
+	@Override
+	public ReadOnlyBooleanProperty innerObservableNull() {
+		return innerObservableNull;
+	}
+
+	@Override
+	public boolean isInnerObservableNull() {
+		return innerObservableNull.get();
+	}
+
+	//#end IMPLEMENTATION OF 'NestedProperty'
+
+}

src/org/codefx/libfx/nesting/property/NestedDoublePropertyBuilder.java

@@ -0,0 +1,47 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.DoubleProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A builder for a {@link NestedDoubleProperty} which is bound to the {@link Nesting#innerObservable() innerObservable}
+ * of a {@link Nesting}.
+ */
+public class NestedDoublePropertyBuilder extends AbstractNestedPropertyBuilder<DoubleProperty, NestedDoubleProperty> {
+
+	// #region CONSTRUCTION
+
+	/**
+	 * Creates a new builder which uses the specified nesting.
+	 *
+	 * @param nesting
+	 *            the nesting which will be used for all nested properties
+	 */
+	private NestedDoublePropertyBuilder(Nesting<DoubleProperty> nesting) {
+		super(nesting);
+	}
+
+	/**
+	 * Creates a new builder which uses the specified nesting.
+	 *
+	 * @param nesting
+	 *            the nesting which will be used for all nested properties
+	 * @return a new instance of {@link NestedObjectPropertyBuilder}
+	 */
+	public static NestedDoublePropertyBuilder forNesting(Nesting<DoubleProperty> nesting) {
+		return new NestedDoublePropertyBuilder(nesting);
+	}
+
+	//#end CONSTRUCTION
+
+	// #region METHODS
+
+	@Override
+	public NestedDoubleProperty build() {
+		return new NestedDoubleProperty(getNesting(), getBean(), getName());
+	}
+
+	//#end METHODS
+
+}

test/org/codefx/libfx/nesting/property/AbstractNestedDoublePropertyTest.java

@@ -0,0 +1,40 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * Abstract superclass to tests for {@link NestedDoubleProperty NestedDoubleProperty} which only leaves the creation of
+ * the tested properties (by {@link #createNestedPropertyFromNesting(Nesting)}) to the subclasses.
+ */
+public abstract class AbstractNestedDoublePropertyTest extends AbstractNestedPropertyTest<Number, DoubleProperty> {
+
+	/**
+	 * The next value returned by {@link #createNewValue()}.
+	 */
+	private double lastValue = 1.5;
+
+	@Override
+	protected boolean allowsNullValues() {
+		return false;
+	}
+
+	@Override
+	protected Number createNewValue() {
+		lastValue += 1;
+		return lastValue;
+	}
+
+	@Override
+	protected DoubleProperty createNewObservableWithValue(Number value) {
+		return new SimpleDoubleProperty(value.doubleValue());
+	}
+
+	@Override
+	protected DoubleProperty createNewObservableWithSomeValue() {
+		return createNewObservableWithValue(0.0);
+	}
+
+}

test/org/codefx/libfx/nesting/property/NestedDoublePropertyBuilderTest.java

@@ -0,0 +1,51 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+import org.codefx.libfx.nesting.testhelper.NestingAccess.EditableNesting;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * Tests the class {@link NestedDoublePropertyBuilder}.
+ */
+@RunWith(Suite.class)
+@SuiteClasses({
+		NestedDoublePropertyBuilderTest.AbstractBuilderContract.class,
+		NestedDoublePropertyBuilderTest.CreatedProperties.class,
+})
+public class NestedDoublePropertyBuilderTest {
+
+	/**
+	 * Tests whether the builder fulfills the contract defined by {@link AbstractNestedPropertyBuilder}.
+	 */
+	public static class AbstractBuilderContract
+			extends AbstractNestedPropertyBuilderTest<DoubleProperty, NestedDoubleProperty> {
+
+		@Override
+		protected AbstractNestedPropertyBuilder<DoubleProperty, NestedDoubleProperty> createBuilder() {
+			DoubleProperty innerObservable = new SimpleDoubleProperty(0);
+			EditableNesting<DoubleProperty> nesting = EditableNesting.createWithInnerObservable(innerObservable);
+			return NestedDoublePropertyBuilder.forNesting(nesting);
+		}
+
+	}
+
+	/**
+	 * Uses the builder to create properties which are then tested.
+	 */
+	public static class CreatedProperties extends AbstractNestedDoublePropertyTest {
+
+		@Override
+		protected NestedProperty<Number> createNestedPropertyFromNesting(Nesting<DoubleProperty> nesting) {
+			// use the builder to create the property
+			NestedDoublePropertyBuilder builder = NestedDoublePropertyBuilder.forNesting(nesting);
+			return builder.build();
+		}
+
+	}
+
+}

test/org/codefx/libfx/nesting/property/NestedDoublePropertyTest.java

@@ -0,0 +1,17 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.DoubleProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * Tests the class {@link NestedDoubleProperty}.
+ */
+public class NestedDoublePropertyTest extends AbstractNestedDoublePropertyTest {
+
+	@Override
+	protected NestedProperty<Number> createNestedPropertyFromNesting(Nesting<DoubleProperty> nesting) {
+		return new NestedDoubleProperty(nesting, null, null);
+	}
+
+}

test/org/codefx/libfx/nesting/property/_AllNestedPropertyTests.java

@@ -9,10 +9,12 @@
  */
 @RunWith(Suite.class)
 @SuiteClasses({
-		NestedIntegerPropertyTest.class,
-		NestedIntegerPropertyBuilderTest.class,
-		NestedObjectPropertyTest.class,
-		NestedObjectPropertyBuilderTest.class,
+	NestedDoublePropertyTest.class,
+	NestedDoublePropertyBuilderTest.class,
+	NestedIntegerPropertyTest.class,
+	NestedIntegerPropertyBuilderTest.class,
+	NestedObjectPropertyTest.class,
+	NestedObjectPropertyBuilderTest.class,
 })
 public class _AllNestedPropertyTests {
 	// no body needed