Implemented 'NestedFloatProperty' including the builder and tests.

Author: Nicolai Parlog

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

@@ -3,6 +3,7 @@
 import java.util.Objects;
 
 import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.FloatProperty;
 import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.Property;
 import javafx.beans.value.ObservableValue;
@@ -96,6 +97,22 @@ public IntegerPropertyNestingBuilder nestIntegerProperty(NestingStep<T, IntegerP
 		return new IntegerPropertyNestingBuilder(this, nestingStep);
 	}
 
+	/**
+	 * Returns a builder for nestings whose inner observable is a {@link FloatProperty}. 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 FloatPropertyNestingBuilder} which builds a nesting from this builder's settings and the
+	 *         specified nesting steps
+	 * @throws NullPointerException
+	 *             if the specified function is null
+	 */
+	public FloatPropertyNestingBuilder nestFloatProperty(NestingStep<T, FloatProperty> nestingStep) {
+		Objects.requireNonNull(nestingStep, "The argument 'nestingStep' must not be null.");
+		return new FloatPropertyNestingBuilder(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.

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

@@ -0,0 +1,60 @@
+package org.codefx.libfx.nesting;
+
+import javafx.beans.property.FloatProperty;
+
+import org.codefx.libfx.nesting.property.NestedFloatProperty;
+import org.codefx.libfx.nesting.property.NestedFloatPropertyBuilder;
+import org.codefx.libfx.nesting.property.NestedObjectPropertyBuilder;
+
+/**
+ * A builder for all kinds of nested functionality whose innermost value is held by a {@link FloatProperty}.
+ */
+public class FloatPropertyNestingBuilder extends AbstractNestingBuilder<Number, FloatProperty> {
+
+	// #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> FloatPropertyNestingBuilder(
+			AbstractNestingBuilder<P, ?> previousNestedBuilder,
+			NestingStep<P, FloatProperty> 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 NestedFloatProperty} instance with no owning bean and no name
+	 */
+	public NestedFloatProperty buildProperty() {
+		Nesting<FloatProperty> nesting = buildNesting();
+		return NestedFloatPropertyBuilder.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 NestedFloatPropertyBuilder buildPropertyWithBuilder() {
+		Nesting<FloatProperty> nesting = buildNesting();
+		return NestedFloatPropertyBuilder.forNesting(nesting);
+	}
+
+	//#end BUILD
+}

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

@@ -0,0 +1,64 @@
+package org.codefx.libfx.nesting.property;
+
+import java.util.Objects;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.FloatProperty;
+import javafx.beans.property.Property;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleFloatProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A {@link FloatProperty} which also implements {@link NestedProperty}.
+ */
+public class NestedFloatProperty extends SimpleFloatProperty 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
+	 */
+	NestedFloatProperty(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/NestedFloatPropertyBuilder.java

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

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

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

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

@@ -0,0 +1,51 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.FloatProperty;
+import javafx.beans.property.SimpleFloatProperty;
+
+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 NestedFloatPropertyBuilder}.
+ */
+@RunWith(Suite.class)
+@SuiteClasses({
+		NestedFloatPropertyBuilderTest.AbstractBuilderContract.class,
+		NestedFloatPropertyBuilderTest.CreatedProperties.class,
+})
+public class NestedFloatPropertyBuilderTest {
+
+	/**
+	 * Tests whether the builder fulfills the contract defined by {@link AbstractNestedPropertyBuilder}.
+	 */
+	public static class AbstractBuilderContract
+			extends AbstractNestedPropertyBuilderTest<FloatProperty, NestedFloatProperty> {
+
+		@Override
+		protected AbstractNestedPropertyBuilder<FloatProperty, NestedFloatProperty> createBuilder() {
+			FloatProperty innerObservable = new SimpleFloatProperty(0);
+			EditableNesting<FloatProperty> nesting = EditableNesting.createWithInnerObservable(innerObservable);
+			return NestedFloatPropertyBuilder.forNesting(nesting);
+		}
+
+	}
+
+	/**
+	 * Uses the builder to create properties which are then tested.
+	 */
+	public static class CreatedProperties extends AbstractNestedFloatPropertyTest {
+
+		@Override
+		protected NestedProperty<Number> createNestedPropertyFromNesting(Nesting<FloatProperty> nesting) {
+			// use the builder to create the property
+			NestedFloatPropertyBuilder builder = NestedFloatPropertyBuilder.forNesting(nesting);
+			return builder.build();
+		}
+
+	}
+
+}

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

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

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

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