Removed empty paragraphs from javadocs.

Author: nicolaiparlog

src/main/java/org/codefx/libfx/nesting/DeepNesting.java

@@ -231,7 +231,8 @@ public void initialize() {
 	 * The updater loops through the levels {@code [startLevel; innerLevel - 1]}, updates {@code observables} and
 	 * {@code values} and moves the {@link DeepNesting#changeListeners} from the old to the new observables. It stops
 	 * when a level is found where the stored value equals the current one. In that case all higher levels must be
-	 * identical and nothing more needs to be updated. <br>
+	 * identical and nothing more needs to be updated.
+	 * <p>
 	 * Note that the loop will not stop on null observables and null values. Instead it continues and replaces all
 	 * stored observables and values with null. This is the desired behavior as the hierarchy is in now an incomplete
 	 * state and the old observables and values are obsolete and have to be replaced.

src/main/java/org/codefx/libfx/nesting/Nesting.java

@@ -7,11 +7,11 @@
 import javafx.beans.value.ObservableValue;
 
 /**
+ * <p>
  * A nesting encapsulates a hierarchy of nested {@link ObservableValue ObservableValues} and its
  * {@link #innerObservableProperty() innerObservable} property always contains the current innermost {@code Observable}
  * in that hierarchy as an {@link Optional}. A {@code Nesting} can be used as a basic building block for other nested
  * functionality.
- * <p>
  * <h2>Nesting Hierarchy</h2> A nesting hierarchy is composed of some {@code ObservableValues}, often simply called
  * <b>observables</b>, and <b>nesting steps</b> which lead from one observable to the next.
  * <p>
@@ -23,25 +23,21 @@
  * As nesting steps require a value to be accessible, all observables on which a step is used must provide a value.
  * Hence they must all implement {@link ObservableValue} (of {@code T}, where {@code T} is no primitive type wrapper or
  * {@code String}). No step is used on the inner observable so it suffices that it implements {@link Observable}.
- * <p>
  * <h3>Example</h3> Consider a class {@code Employee} which has an {@code Property<Address> address}, where
  * {@code Address} has a {@code StringProperty streetName}. There might be a {@code Property<Emplyee> currentEmployee},
  * which always holds the current employee.
  * <p>
  * In this case the hierarchy would be {@code currentEmployee -> address -> streetName} where {@code currentEmployee} is
  * the outer observable and {@code address} and {@code streetName} are nested observables. Additionally,
  * {@code streetName} is the inner observable.
- * <p>
  * <h2>Present or Missing Inner Observable</h2> If all steps return non-null observables and none of them contains null,
  * the inner observable can be computed and will be contained in the {@link #innerObservableProperty() innerObservable}
  * property. In this case it is said to be <b>present</b>. The same is true if only the inner observable contains null.
  * <p>
  * If any nesting step returns null or any observable except the inner contains null as a value, the nesting hierarchy
  * can not be completely computed. The inner observable is said to be <b>missing</b> and the {@code innerObservable}
  * property contains {@link Optional#empty()}.
- * <p>
  * <h2>Evaluation</h2> Nestings will usually be implemented such that they eagerly evaluate the nested observables.
- * <p>
  * <h2>Build</h2> Instances of {@code Nesting} can be created with dedicated builders. These can be obtained by starting
  * with one of the methods in {@link Nestings}. More details can be found there.
  *

src/main/java/org/codefx/libfx/nesting/Nestings.java

@@ -12,14 +12,13 @@
 import org.codefx.libfx.nesting.property.NestedProperty;
 
 /**
+ * <p>
  * This class provides static functions to obtain builders for nested classes like {@link Nesting} or
  * {@link NestedProperty}.
- * <p>
  * <h2>Builders</h2> Calling {@code on} will return a builder whose type depends on the type of the specified
  * observable. Similarly a call to one of the builders' {@code nest...}-methods returns a (new) builder whose type
  * depends on the type of observable the nesting step will return. Each type of builder allows only those functions
  * which are supported by that observable.
- * <p>
  * <h3>Examples on Builder Types</h3> If the last nesting step provides a {@link javafx.beans.property.DoubleProperty
  * DoubleProperty}, a {@link DoublePropertyNestingBuilder} will be returned. Because a {@code Double} cannot contain
  * another observable no further nesting is possible and hence no {@code nest...}-methods are available. But it can be

src/main/java/org/codefx/libfx/nesting/listener/NestedChangeListener.java

@@ -14,13 +14,12 @@
 import org.codefx.libfx.nesting.property.NestedProperty;
 
 /**
+ * <p>
  * Contains a {@link ChangeListener} which is connected to a {@link Nesting}. Simply put, the listener is always added
  * to the nesting's inner observable (more precisely, it is added to the {@link ObservableValue} instance contained in
  * the optional value held by the nesting's {@link Nesting#innerObservableProperty() innerObservable} property).
- * <p>
  * <h2>Inner Observable's Value Changes</h2> The listener is added to the nesting's inner observable. So when that
  * observable's value changes, the listener is called as usual.
- * <p>
  * <h2>Inner Observable Is Replaced</h2> When the nesting's inner observable is replaced by another, the listener is
  * removed from the old and added to the new observable. If one of them is missing, the affected removal or add is not
  * performed, which means the listener might not be added to any observable.
@@ -61,12 +60,12 @@ public class NestedChangeListener<T> implements Nested {
 		this.innerObservablePresent = new SimpleBooleanProperty(this, "innerObservablePresent");
 
 		NestingObserver
-		.forNesting(nesting)
-		.withOldInnerObservable(oldInnerObservable -> oldInnerObservable.removeListener(listener))
-		.withNewInnerObservable(newInnerObservable -> newInnerObservable.addListener(listener))
-		.whenInnerObservableChanges(
-				(Boolean any, Boolean newInnerObservablePresent)
-				-> innerObservablePresent.set(newInnerObservablePresent))
+				.forNesting(nesting)
+				.withOldInnerObservable(oldInnerObservable -> oldInnerObservable.removeListener(listener))
+				.withNewInnerObservable(newInnerObservable -> newInnerObservable.addListener(listener))
+				.whenInnerObservableChanges(
+						(Boolean any, Boolean newInnerObservablePresent)
+						-> innerObservablePresent.set(newInnerObservablePresent))
 				.observe();
 	}
 

src/main/java/org/codefx/libfx/nesting/listener/NestedInvalidationListener.java

@@ -14,13 +14,12 @@
 import org.codefx.libfx.nesting.property.NestedProperty;
 
 /**
+ * <p>
  * Contains an {@link InvalidationListener} which is connected to a {@link Nesting}. Simply put, the listener is always
  * added to the nesting's inner observable (more precisely, it is added to the {@link Observable} instance contained in
  * the optional value held by the nesting's {@link Nesting#innerObservableProperty() innerObservable} property).
- * <p>
  * <h2>Inner Observable's Value is Invalidated</h2> The listener is added to the nesting's inner observable. So when
  * that observable's value is invalidated, the listener is called as usual.
- * <p>
  * <h2>Inner Observable Is Replaced</h2> When the nesting's inner observable is replaced by another, the listener is
  * removed from the old and added to the new observable. If one of them is missing, the affected removal or add is not
  * performed, which means the listener might not be added to any observable.

src/main/java/org/codefx/libfx/nesting/package-info.java

@@ -1,25 +1,22 @@
 /**
+ * <p>
  * This package provides functionality around nesting hierarchies - a term which is explained in all detail in the
  * comment on {@link org.codefx.libfx.nesting.Nesting Nesting}.
- * <p>
  * <h2>Nesting</h2> A {@code Nesting} encapsulates a hierarchy of nested {@code ObservableValues} and collapses them
  * into a property which always contains the current innermost {@code Observable} in that hierarchy. A {@code Nesting}
  * can be used as a basic building block for other nested functionality (see below).
  * <p>
  * See the comment on {@link org.codefx.libfx.nesting.Nesting Nesting} for details.
- * <p>
  * <h2>Nested Property</h2> A {@code NestedProperty} uses a {@code Nesting} to bind its value to the inner
  * {@code Property} in a nesting hierarchy, updating the binding as the inner observable changes its value or is
  * replaced. It can thus be used to collapse a nesting hierarchy into a single property.
  * <p>
  * See the comment on {@link org.codefx.libfx.nesting.property.NestedProperty NestedProperty} for details.
- * <p>
  * <h2>Nested Listeners</h2> A {@code Nesting} can also be used to add listeners to its inner observable. These
  * listeners are moved from one observable to the next as they are replaced.
  * <p>
  * See the comments on {@link org.codefx.libfx.nesting.listener.NestedChangeListener NestedChangeListener} and
  * {@link org.codefx.libfx.nesting.listener.NestedInvalidationListener NestedInvalidationListener} for details.
- * <p>
  * <h2>Builders</h2> Instances of the classes described above can be build by starting with the methods in
  * {@link org.codefx.libfx.nesting.Nestings Nestings}.
  *

src/main/java/org/codefx/libfx/nesting/property/NestedProperty.java

@@ -5,19 +5,17 @@
 import org.codefx.libfx.nesting.Nesting;
 
 /**
+ * <p>
  * A {@link Property} which is based on a {@link Nesting}. Simply put, this property is always bound to the nesting's
  * inner observable (more precisely, it is bound to the {@link Property} instance contained in the optional value held
  * by the nesting's {@link Nesting#innerObservableProperty() innerObservable} property).
- * <p>
  * <h2>Inner Observable's Value Changes</h2> This property is bound to the nesting's inner observable. So when that
  * observable's value changes, so does this property.
- * <p>
  * <h2>Inner Observable Is Replaced</h2> When the nesting's inner observable is replaced by a present observable, this
  * nested property's value changes to the new observable's value. Like all other value changes this one also results in
  * calling invalidation and change listeners.
  * <p>
  * If the new observable is missing, this property stays unbound and keeps its value (and hence no listener is called).
- * <p>
  * <h2>Inner Observable is Missing</h2> It is possible that a nesting's inner observable is missing (see comment on
  * {@link Nesting}). In that case the {@link NestedProperty#innerObservablePresentProperty() innerObservablePresent}
  * property is false and changes made to this property's value can not be propagated to another property.