imporved javadoc

src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java

@@ -46,7 +46,7 @@ import java.util.concurrent.TimeUnit;
 
 /**
  * This interface defines the meaning of configurations, common to {@link
- * net.openhft.chronicle.map.OnHeapUpdatableChronicleMapBuilder} and {@link ChronicleSetBuilder}, i.
+ * net.openhft.chronicle.map.ChronicleMapBuilder} and {@link ChronicleSetBuilder}, i.
  * e. <i>Chronicle hash container</i> configurations.
  *
  * <p>{@code ChronicleHashBuilder} is mutable. Configuration methods mutate the builder and return
@@ -131,7 +131,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
      *
      * <p>There are three major patterns of this configuration usage: <ol> <li>Key (and value, in
      * {@code ChronicleMap} case) sizes are constant. Configure them via {@link
-     * #constantKeySizeBySample(Object)} and {@link net.openhft.chronicle.map.OnHeapUpdatableChronicleMapBuilder#constantValueSizeBySample(Object)}
+     * #constantKeySizeBySample(Object)} and {@link net.openhft.chronicle.map.ChronicleMapBuilder#constantValueSizeBySample(Object)}
      * methods, and you will experience no memory waste at all.</li> <li>Key (and/or value size, in
      * {@code ChronicleMap} case) varies moderately. Specify them using corresponding methods, or
      * specify entry size directly by calling this method, by sizes somewhere between average and
@@ -184,7 +184,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
      * memory unit).</li> <li>If key (and/or value, in {@code ChronicleMap} case) size varies
      * moderately, you should pass to this method the maximum number of entries + 5-25%, depending
      * on your data properties and configured {@linkplain #keySize(int) key}/{@linkplain
-     * net.openhft.chronicle.map.OnHeapUpdatableChronicleMapBuilder#valueSize(int)
+     * net.openhft.chronicle.map.ChronicleMapBuilder#valueSize(int)
      * value}/{@linkplain #entrySize(int) entry} sizes.</li> <li>If your data size varies in a wide
      * range, pass the maximum number of entries multiplied by average data size and divided by the
      * configured "entry size" (i. e. chunk size). See an example in the documentation to {@link

src/main/java/net/openhft/chronicle/hash/FindByName.java

@@ -10,10 +10,12 @@ public interface FindByName {
 
     /**
      * @param name the name of the map or set
-     * @param <T>
+     * @param <T>  the type returned
      * @return a chronicle map or set
-     * @throws IllegalArgumentException if a map with this name can not be found
-     * @throws IOException              if it not possible to create the map or set
+     * @throws IllegalArgumentException              if a map with this name can not be found
+     * @throws IOException                           if it not possible to create the map or set
+     * @throws java.util.concurrent.TimeoutException if the call times out
+     * @throws java.util.concurrent.TimeoutException if interrupted by another thread
      */
     <T extends ChronicleHash> T from(String name) throws IllegalArgumentException,
             IOException, TimeoutException, InterruptedException;

src/main/java/net/openhft/chronicle/hash/replication/TcpTransportAndNetworkConfig.java

@@ -135,7 +135,9 @@ public final class TcpTransportAndNetworkConfig implements Serializable {
     }
 
     /**
-     * @param name the name used here is reflected in the Tcp Replicator and is typically used when debugging
+     * @param name the name used here is reflected in the Tcp Replicator and is typically used when
+     *             debugging
+     * @return self
      */
     public TcpTransportAndNetworkConfig name(String name) {
         this.name = name;
@@ -164,11 +166,13 @@ public final class TcpTransportAndNetworkConfig implements Serializable {
 
         TcpTransportAndNetworkConfig that = (TcpTransportAndNetworkConfig) o;
 
-        if (autoReconnectedUponDroppedConnection != that.autoReconnectedUponDroppedConnection) return false;
+        if (autoReconnectedUponDroppedConnection != that.autoReconnectedUponDroppedConnection)
+            return false;
         if (heartBeatInterval != that.heartBeatInterval) return false;
         if (packetSize != that.packetSize) return false;
         if (serverPort != that.serverPort) return false;
-        if (endpoints != null ? !endpoints.equals(that.endpoints) : that.endpoints != null) return false;
+        if (endpoints != null ? !endpoints.equals(that.endpoints) : that.endpoints != null)
+            return false;
         if (heartBeatIntervalUnit != that.heartBeatIntervalUnit) return false;
         if (throttlingConfig != null ? !throttlingConfig.equals(that.throttlingConfig) : that.throttlingConfig != null)
             return false;

src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java

@@ -45,12 +45,12 @@ import java.util.concurrent.TimeUnit;
  * {@code ChronicleSetBuilder} manages the whole set of {@link ChronicleSet} configurations, could
  * be used as a classic builder and/or factory.
  *
- * <p>{@code ChronicleMapOnHeapUpdatableBuilder} is mutable, see a note in {@link
+ * <p>{@code ChronicleMapBuilder} is mutable, see a note in {@link
  * ChronicleHashBuilder} interface documentation.
  *
  * @param <E> element type of the sets, created by this builder
  * @see ChronicleSet
- * @see net.openhft.chronicle.map.OnHeapUpdatableChronicleMapBuilder
+ * @see net.openhft.chronicle.map.ChronicleMapBuilder
  */
 public class ChronicleSetBuilder<E>
         implements ChronicleHashBuilder<E, ChronicleSet<E>, ChronicleSetBuilder<E>> {