From be7e71bd8c19686417ef99336bb227a1551c2e8d Mon Sep 17 00:00:00 2001 From: Rob Austin Date: Fri, 13 Mar 2015 15:53:05 +0000 Subject: [PATCH] fixed some java doc issues with where cause the javadoc build to fail --- .../chronicle/hash/hashing/LongHashFunction.java | 14 +++++++++++++- .../openhft/chronicle/map/ChronicleMapBuilder.java | 2 +- .../map/ChronicleMapStatelessClientBuilder.java | 3 ++- .../java/net/openhft/chronicle/map/Replica.java | 6 +++--- 4 files changed, 19 insertions(+), 6 deletions(-) diff --git a/src/main/java/net/openhft/chronicle/hash/hashing/LongHashFunction.java b/src/main/java/net/openhft/chronicle/hash/hashing/LongHashFunction.java index 864145ba6..4f57a6b72 100644 --- a/src/main/java/net/openhft/chronicle/hash/hashing/LongHashFunction.java +++ b/src/main/java/net/openhft/chronicle/hash/hashing/LongHashFunction.java @@ -63,6 +63,7 @@ public abstract class LongHashFunction implements Serializable { * CityHash64 algorithm, version 1.1 without seed values. This implementation produce * equal results for equal input on platforms with different {@link ByteOrder}, but is slower * on big-endian platforms than on little-endian. + * @return an instance of LongHashFunction * * @see #city_1_1(long) * @see #city_1_1(long, long) @@ -91,7 +92,7 @@ public abstract class LongHashFunction implements Serializable { * CityHash64 algorithm, version 1.1 using the two given seed values. This implementation * produce equal results for equal input on platforms with different {@link ByteOrder}, but * is slower on big-endian platforms than on little-endian. - * + * @return an instance of LongHashFunction * @see #city_1_1() * @see #city_1_1(long) */ @@ -136,6 +137,8 @@ public abstract class LongHashFunction implements Serializable { * value is interpreted in {@linkplain ByteOrder#nativeOrder() native} byte order. For example, * the result of {@code hashLong(v)} call is identical to the result of * {@code hashLongs(new long[] {v})} call for any {@code long} value. + * @param input the input + * @return a hashLong */ public abstract long hashLong(long input); @@ -145,6 +148,8 @@ public abstract class LongHashFunction implements Serializable { * value is interpreted in {@linkplain ByteOrder#nativeOrder() native} byte order. For example, * the result of {@code hashInt(v)} call is identical to the result of * {@code hashInts(new int[] {v})} call for any {@code int} value. + * @param input the input + * @return a hashLong */ public abstract long hashInt(int input); @@ -156,6 +161,9 @@ public abstract class LongHashFunction implements Serializable { * {@code hashShorts(new short[] {v})} call for any {@code short} value. * As a consequence, {@code hashShort(v)} call produce always the same result as {@code * hashChar((char) v)}. + * + * @param input the input + * @return a hashShort */ public abstract long hashShort(short input); @@ -175,12 +183,16 @@ public abstract class LongHashFunction implements Serializable { * {@code LongHashFunction} methods that accept sequences of bytes. For example, the result of * {@code hashByte(v)} call is identical to the result of * {@code hashBytes(new byte[] {v})} call for any {@code byte} value. + * + * @param input the input + * @return a hashByte */ public abstract long hashByte(byte input); /** * Returns the hash code for the empty (zero-length) bytes sequence, * for example {@code hashBytes(new byte[0])}. + * @return a hash */ public abstract long hashVoid(); diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java index b5a1b8816..2798b6000 100755 --- a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java +++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java @@ -256,7 +256,7 @@ public final class ChronicleMapBuilder implements * encoded (and each character takes 2 bytes on-heap), because default off-heap {@link String} * encoding is UTF-8 in {@code ChronicleMap}.) * - * @param averageKeySize + * @param averageKeySize the average size of the key * @throws IllegalStateException {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} * @see #constantKeySizeBySample(Object) diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapStatelessClientBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapStatelessClientBuilder.java index 376ce0a5b..9c08e0c29 100644 --- a/src/main/java/net/openhft/chronicle/map/ChronicleMapStatelessClientBuilder.java +++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapStatelessClientBuilder.java @@ -48,12 +48,13 @@ public final class ChronicleMapStatelessClientBuilder implements // -- the second is really shorter. /** - * Equivalent of {@code ChronicleMapStatelessClientBuilder.of(serverAddress).create()}. + * Equivalent of {@code ChronicleMapStatelessClientBuilder.of(serverAddress).create()}. * * @param serverAddress address of the server map * @param key type of the map * @param value type of the map * @return stateless client of the ChronicleMap of server + * @throws IOException if it not possible to connect to the {@code serverAddress} */ public static ChronicleMap createClientOf(InetSocketAddress serverAddress) throws IOException { diff --git a/src/main/java/net/openhft/chronicle/map/Replica.java b/src/main/java/net/openhft/chronicle/map/Replica.java index c0b973ec9..107a45d24 100644 --- a/src/main/java/net/openhft/chronicle/map/Replica.java +++ b/src/main/java/net/openhft/chronicle/map/Replica.java @@ -210,7 +210,7 @@ public interface Replica extends Closeable { /** * Called whenever a put() or remove() has occurred to a replicating map. * - * @param context the entry you will receive, this does not have to be locked, as + * @param entry the entry you will receive, this does not have to be locked, as * locking is already provided from the caller. * @param chronicleId only assigned when clustering * @return {@code false} if this entry should be ignored because the identifier of the @@ -220,13 +220,13 @@ public interface Replica extends Closeable { public abstract boolean onEntry(final Bytes entry, final int chronicleId); /** - * Called just after {@link #onEntry(VanillaContext, int)}. No-op by default. + * Called just after {@link #onEntry(net.openhft.lang.io.Bytes, int)}. No-op by default. */ public void onAfterEntry() { } /** - * Called just before {@link #onEntry(VanillaContext, int)}. No-op by default. + * Called just before {@link #onEntry(net.openhft.lang.io.Bytes, int)}. No-op by default. */ public void onBeforeEntry() { }