From 4cffff652f0ad37321ce821e2fbd8c8a54174b77 Mon Sep 17 00:00:00 2001 From: leventov Date: Fri, 24 Jun 2016 17:49:34 +0700 Subject: [PATCH] Update to newer Core, Bytes & Wire dependency versions; make all enum marshallers ordinary classes with static INSTANCE fields, because of difficulties with Wire serialization of enums --- README.md | 38 ++++++++++++------- pom.xml | 4 +- .../chronicle/hash/impl/HashSplitting.java | 6 ++- .../serialization/impl/BooleanMarshaller.java | 6 ++- .../impl/ByteArraySizedReader.java | 6 ++- .../impl/ByteBufferSizedReader.java | 6 ++- .../impl/CharSequenceBytesReader.java | 6 ++- .../impl/CharSequenceBytesWriter.java | 6 ++- .../impl/CharSequenceSizedWriter.java | 7 +++- .../serialization/impl/DoubleMarshaller.java | 6 ++- .../serialization/impl/EnumMarshallable.java | 14 ++++++- .../serialization/impl/IntegerMarshaller.java | 6 ++- .../serialization/impl/LongMarshaller.java | 6 ++- .../impl/SerializationBuilder.java | 20 ++++++++++ .../impl/StopBitSizeMarshaller.java | 6 ++- .../impl/StringBuilderSizedReader.java | 6 ++- .../chronicle/set/DummyValueMarshaller.java | 6 ++- .../map/DeflatorStringMarshaller.java | 6 ++- .../openhft/chronicle/map/Issue43Test.java | 7 +++- .../net/openhft/chronicle/map/Issue58.java | 6 ++- .../example/PointListSerializationTest.java | 7 +++- .../CharSequenceArrayBytesMarshaller.java | 6 ++- .../fromdocs/PointListSizedMarshaller.java | 6 ++- 23 files changed, 138 insertions(+), 55 deletions(-) diff --git a/README.md b/README.md index 491e6592d..04d3dc94e 100644 --- a/README.md +++ b/README.md @@ -519,11 +519,13 @@ For example, here is the implementation of `BytesWriter` and `BytesReader` for ` value type (array of CharSequences): ```java -public enum CharSequenceArrayBytesMarshaller +public final class CharSequenceArrayBytesMarshaller implements BytesWriter, BytesReader, ReadResolvable { - INSTANCE; + static final CharSequenceArrayBytesMarshaller INSTANCE = new CharSequenceArrayBytesMarshaller(); + + private CharSequenceArrayBytesMarshaller() {} @Override public void write(Bytes out, @NotNull CharSequence[] toWrite) { @@ -603,12 +605,15 @@ Some additional notes: - If the reader or writer interface implementation is not configurable and doesn't have per-instance cache or state fields, i. e. it doesn't have instance fields at all, there is - a convention to make such implementations `enum`s with a single `INSTANCE` constant. - - For `enum` serialization interface implementations, don't forget to implement `ReadResolvable` + a convention to make such implementation classes `final`, give them a `private` constructor and + expose a single `INSTANCE` constant - a sole instance of this implementation in the JVM. + - *Don't* make marshaller class `enum`, because there are some issues with `enum` serialization/ + deserialization. + - For such no-state implementations, don't forget to implement `ReadResolvable` interface and return `INSTANCE`, otherwise you have no guarantee that `INSTANCE` constant is the only alive instance of this implementation in the JVM. - If *both* writer and reader interface implementations have no fields, it might be a good idea - to merge them into a single `enum` type, in order to keep writing and reading logic together. + to merge them into a single type, in order to keep writing and reading logic together. ###### Custom `CharSequence` encoding @@ -875,7 +880,7 @@ Some notes on this case of custom serialization: - Both `CharSequenceCustomEncodingBytesWriter` and `CharSequenceCustomEncodingBytesReader` have configurations (charset and input buffer size), hence they are implemented as normal classes rather - than enums with a single `INSTANCE` constant. + than classes with `private` constructors and a single `INSTANCE`. - Both writer and reader classes have some "cache" fields, their contents are mutated during writing and reading. That is why they have to implement `StatefulCopyable` interface. See [Understanding `StatefulCopyable`](#understanding-statefulcopyable) section for more infromation on @@ -936,11 +941,13 @@ public final class Point { Serializer implementation: ```java -public enum PointListSizedMarshaller +public final class PointListSizedMarshaller implements SizedReader>, SizedWriter>, ReadResolvable { - INSTANCE; + static final PointListSizedMarshaller INSTANCE = new PointListSizedMarshaller(); + + private PointListSizedMarshaller() {} /** A point takes 16 bytes in serialized form: 8 bytes for both x and y value */ private static final long ELEMENT_SIZE = 16; @@ -1153,10 +1160,12 @@ right in `Data` interface. Corresponding `SizedReader` for `byte[]`: ```java -public enum ByteArraySizedReader +public final class ByteArraySizedReader implements SizedReader, Marshallable, ReadResolvable { - INSTANCE; + public static final ByteArraySizedReader INSTANCE = new ByteArraySizedReader(); + + private ByteArraySizedReader() {} @NotNull @Override @@ -1274,11 +1283,12 @@ class. `SizedReader`](#sizedwriter-and-sizedreader) or [`DataAccess` and `SizedReader`](#dataaccess-and-sizedreader). Recommendations on which pair to choose are given in the linked sections, describing each pair. - 2. If implementation of the writer or reader part is configuration-less, make it a `enum` with - a single `INSTANCE` constant. Implement `ReadResolvable` and return `INSTANCE` from `readResolve()` - method. + 2. If implementation of the writer or reader part is configuration-less, give it a `private` + constructor and define a single `INSTANCE` constant -- a sole instance of this marshaller class in + the JVM. Implement `ReadResolvable` and return `INSTANCE` from `readResolve()` method. *But, don't + make implementation a Java `enum`.* 3. If both the writer and reader are configuration-less, merge them into a single `-Marshaller` - `enum` implementation. + implementation class. 4. Make best effort in reusing `using` objects on the reader side (`BytesReader` or `SizedReader`), including nesting objects. 5. Make best effort in caching intermediate serialization results on writer side while working with diff --git a/pom.xml b/pom.xml index 47f30cb86..f434fdfcb 100755 --- a/pom.xml +++ b/pom.xml @@ -39,7 +39,7 @@ net.openhft third-party-bom pom - 3.5.0 + 3.5.1 import @@ -47,7 +47,7 @@ net.openhft chronicle-bom pom - 1.12.14-SNAPSHOT + 1.12.26 import diff --git a/src/main/java/net/openhft/chronicle/hash/impl/HashSplitting.java b/src/main/java/net/openhft/chronicle/hash/impl/HashSplitting.java index 2e17a8149..b1aa948c9 100644 --- a/src/main/java/net/openhft/chronicle/hash/impl/HashSplitting.java +++ b/src/main/java/net/openhft/chronicle/hash/impl/HashSplitting.java @@ -39,8 +39,10 @@ public interface HashSplitting extends Marshallable { int segmentIndex(long hash); long segmentHash(long hash); - enum ForSingleSegment implements HashSplitting, EnumMarshallable { - INSTANCE; + final class ForSingleSegment implements HashSplitting, EnumMarshallable { + public static final ForSingleSegment INSTANCE = new ForSingleSegment(); + + private ForSingleSegment() {} @Override public int segmentIndex(long hash) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BooleanMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BooleanMarshaller.java index f87ec3441..d6705c8f9 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BooleanMarshaller.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BooleanMarshaller.java @@ -24,10 +24,12 @@ import net.openhft.chronicle.hash.serialization.SizedWriter; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public enum BooleanMarshaller +public final class BooleanMarshaller implements SizedReader, BytesReader, SizedWriter, BytesWriter, EnumMarshallable { - INSTANCE; + public static final BooleanMarshaller INSTANCE = new BooleanMarshaller(); + + private BooleanMarshaller() {} @Override public long size(@NotNull Boolean e) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArraySizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArraySizedReader.java index 7c70c5320..f152052d7 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArraySizedReader.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArraySizedReader.java @@ -22,10 +22,12 @@ import net.openhft.chronicle.hash.serialization.SizedReader; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public enum ByteArraySizedReader +public final class ByteArraySizedReader implements SizedReader, EnumMarshallable { - INSTANCE; + public static final ByteArraySizedReader INSTANCE = new ByteArraySizedReader(); + + private ByteArraySizedReader() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferSizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferSizedReader.java index fcf329fef..37aee3f4f 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferSizedReader.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferSizedReader.java @@ -23,9 +23,11 @@ import org.jetbrains.annotations.Nullable; import java.nio.ByteBuffer; -public enum ByteBufferSizedReader +public final class ByteBufferSizedReader implements SizedReader, EnumMarshallable { - INSTANCE; + public static final ByteBufferSizedReader INSTANCE = new ByteBufferSizedReader(); + + private ByteBufferSizedReader() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesReader.java index a264c2e06..f04e335f4 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesReader.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesReader.java @@ -37,9 +37,11 @@ import java.io.ObjectInputStream; * * @see CharSequenceBytesWriter */ -public enum CharSequenceBytesReader implements BytesReader, +public final class CharSequenceBytesReader implements BytesReader, StatefulCopyable, EnumMarshallable { - INSTANCE; + public static final CharSequenceBytesReader INSTANCE = new CharSequenceBytesReader(); + + private CharSequenceBytesReader() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesWriter.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesWriter.java index 6b92cf993..dbe034230 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesWriter.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceBytesWriter.java @@ -30,9 +30,11 @@ import org.jetbrains.annotations.NotNull; * * @see StringBytesReader */ -public enum CharSequenceBytesWriter +public final class CharSequenceBytesWriter implements BytesWriter, EnumMarshallable { - INSTANCE; + public static final CharSequenceBytesWriter INSTANCE = new CharSequenceBytesWriter(); + + private CharSequenceBytesWriter() {} @Override public void write(Bytes out, @NotNull CharSequence toWrite) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedWriter.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedWriter.java index 4e9cb75f4..f10d02186 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedWriter.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedWriter.java @@ -25,9 +25,12 @@ import org.jetbrains.annotations.NotNull; * @deprecated use one of {@link AbstractCharSequenceUtf8DataAccess} subclasses instead */ @Deprecated -public enum CharSequenceSizedWriter +@SuppressWarnings("deprecation") +public final class CharSequenceSizedWriter implements SizedWriter, EnumMarshallable { - INSTANCE; + public static final CharSequenceSizedWriter INSTANCE = new CharSequenceSizedWriter(); + + private CharSequenceSizedWriter() {} @Override public long size(@NotNull CharSequence toWrite) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/DoubleMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/DoubleMarshaller.java index b2b2a45e9..2690bce07 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/DoubleMarshaller.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/DoubleMarshaller.java @@ -26,10 +26,12 @@ import org.jetbrains.annotations.Nullable; * deprecated in favor of {@link DoubleDataAccess}. As reader and element writer for {@link * ListMarshaller} and similar composite marshallers, {@code DoubleMarshaller} is not deprecated. */ -public enum DoubleMarshaller +public final class DoubleMarshaller implements SizedReader, BytesReader, SizedWriter, BytesWriter, EnumMarshallable { - INSTANCE; + public static final DoubleMarshaller INSTANCE = new DoubleMarshaller(); + + private DoubleMarshaller() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/EnumMarshallable.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/EnumMarshallable.java index 25a18e8ef..8809edc82 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/EnumMarshallable.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/EnumMarshallable.java @@ -22,7 +22,19 @@ import net.openhft.chronicle.wire.WireIn; import net.openhft.chronicle.wire.WireOut; import org.jetbrains.annotations.NotNull; -public interface EnumMarshallable> extends Marshallable, ReadResolvable { +/** + * This interface safes many single-constant enum-like subclasses in the + * {@link net.openhft.chronicle.hash.serialization.impl} package from implementing empty + * {@link #readMarshallable} and {@link #writeMarshallable} methods, and forces them to implement + * {@link ReadResolvable}. The name references "Enum" because formerly it allowed only {@code enum} + * subclasses, to enforce a good practice of making enum-like classes actually Java {@code enum}s. + * But changes in Chronicle-Wire, used to serialize/deserialize marshallers in Chronicle Map + * headers, turned {@code enum}s from recommended form of marshaller implementations to impossible + * one. So now there are no subclasses of this interface which are actually {@code enum}s. + * + * @param the subclassing marshaller type + */ +public interface EnumMarshallable extends Marshallable, ReadResolvable { @Override default void readMarshallable(@NotNull WireIn wireIn) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/IntegerMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/IntegerMarshaller.java index dca93ee9a..63c3dfc83 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/IntegerMarshaller.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/IntegerMarshaller.java @@ -26,10 +26,12 @@ import org.jetbrains.annotations.Nullable; * is deprecated in favor of {@link IntegerDataAccess}. As reader and element writer for {@link * ListMarshaller} and similar composite marshallers, {@code IntegerMarshaller} is not deprecated. */ -public enum IntegerMarshaller +public final class IntegerMarshaller implements SizedReader, BytesReader, SizedWriter, BytesWriter, EnumMarshallable { - INSTANCE; + public static final IntegerMarshaller INSTANCE = new IntegerMarshaller(); + + private IntegerMarshaller() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/LongMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/LongMarshaller.java index b54da39fc..6665fd6b6 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/LongMarshaller.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/LongMarshaller.java @@ -26,10 +26,12 @@ import org.jetbrains.annotations.Nullable; * deprecated in favor of {@link LongDataAccess}. As reader and element writer for {@link * ListMarshaller} and similar composite marshallers, {@code LongMarshaller} is not deprecated. */ -public enum LongMarshaller +public final class LongMarshaller implements SizedReader, BytesReader, SizedWriter, BytesWriter, EnumMarshallable { - INSTANCE; + public static final LongMarshaller INSTANCE = new LongMarshaller(); + + private LongMarshaller() {} @Override public long size(@NotNull Long toWrite) { diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializationBuilder.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializationBuilder.java index ddd208cd9..2e99c5d5d 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializationBuilder.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializationBuilder.java @@ -19,9 +19,11 @@ package net.openhft.chronicle.hash.serialization.impl; import net.openhft.chronicle.bytes.Byteable; import net.openhft.chronicle.bytes.BytesMarshallable; import net.openhft.chronicle.core.OS; +import net.openhft.chronicle.core.util.ReadResolvable; import net.openhft.chronicle.hash.serialization.*; import net.openhft.chronicle.values.ValueModel; import net.openhft.chronicle.values.Values; +import net.openhft.chronicle.wire.Marshallable; import java.io.*; import java.lang.reflect.Modifier; @@ -36,6 +38,17 @@ public final class SerializationBuilder implements Cloneable { return !c.isInterface() && !Modifier.isAbstract(c.getModifiers()); } + private static void checkNonMarshallableEnum(Class c) { + if (Enum.class.isAssignableFrom(c) && (Marshallable.class.isAssignableFrom(c) || + ReadResolvable.class.isAssignableFrom(c))) { + throw new IllegalArgumentException(c + ": since Chronicle Map 3.9.0, enum marshaller " + + "shouldn't be a Java enum and implement " + Marshallable.class.getName() + + " or " + ReadResolvable.class.getName() + ". There are problems with " + + "serializing/deserializing them in Chronicle Map header. Emulate enums by " + + "static final fields"); + } + } + public final Class tClass; private SizeMarshaller sizeMarshaller = stopBit(); private SizedReader reader; @@ -129,10 +142,12 @@ public final class SerializationBuilder implements Cloneable { } public void reader(SizedReader reader) { + checkNonMarshallableEnum(reader.getClass()); this.reader = reader; } public void reader(BytesReader reader) { + checkNonMarshallableEnum(reader.getClass()); this.reader = new BytesAsSizedReader<>(reader); } @@ -141,6 +156,7 @@ public final class SerializationBuilder implements Cloneable { } public void dataAccess(DataAccess dataAccess) { + checkNonMarshallableEnum(dataAccess.getClass()); this.dataAccess = dataAccess; } @@ -149,14 +165,17 @@ public final class SerializationBuilder implements Cloneable { } public void writer(SizedWriter writer) { + checkNonMarshallableEnum(writer.getClass()); dataAccess(new SizedMarshallableDataAccess<>(tClass, reader, writer)); } private void notReusingWriter(SizedWriter writer) { + checkNonMarshallableEnum(writer.getClass()); dataAccess(new NotReusingSizedMarshallableDataAccess<>(tClass, reader, writer)); } public void writer(BytesWriter writer) { + checkNonMarshallableEnum(writer.getClass()); dataAccess(new ExternalBytesMarshallableDataAccess<>(tClass, reader, writer)); } @@ -212,6 +231,7 @@ public final class SerializationBuilder implements Cloneable { } public SerializationBuilder sizeMarshaller(SizeMarshaller sizeMarshaller) { + checkNonMarshallableEnum(sizeMarshaller.getClass()); this.sizeMarshaller = sizeMarshaller; return this; } diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StopBitSizeMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StopBitSizeMarshaller.java index 97292cf3f..6b2c0dce7 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StopBitSizeMarshaller.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StopBitSizeMarshaller.java @@ -23,9 +23,11 @@ import net.openhft.chronicle.hash.serialization.SizeMarshaller; import static java.lang.Math.max; import static java.lang.Math.min; -public enum StopBitSizeMarshaller +public final class StopBitSizeMarshaller implements SizeMarshaller, EnumMarshallable { - INSTANCE; + public static final StopBitSizeMarshaller INSTANCE = new StopBitSizeMarshaller(); + + private StopBitSizeMarshaller() {} private static final long MIN_ENCODABLE_SIZE = Long.MIN_VALUE; private static final long MAX_ENCODABLE_SIZE = Long.MAX_VALUE; diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBuilderSizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBuilderSizedReader.java index 61bb401fd..4929075cb 100644 --- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBuilderSizedReader.java +++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBuilderSizedReader.java @@ -22,9 +22,11 @@ import net.openhft.chronicle.hash.serialization.SizedReader; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public enum StringBuilderSizedReader +public final class StringBuilderSizedReader implements SizedReader, EnumMarshallable { - INSTANCE; + public static final StringBuilderSizedReader INSTANCE = new StringBuilderSizedReader(); + + private StringBuilderSizedReader() {} @NotNull @Override diff --git a/src/main/java/net/openhft/chronicle/set/DummyValueMarshaller.java b/src/main/java/net/openhft/chronicle/set/DummyValueMarshaller.java index 4ef3f9294..a7c213afc 100644 --- a/src/main/java/net/openhft/chronicle/set/DummyValueMarshaller.java +++ b/src/main/java/net/openhft/chronicle/set/DummyValueMarshaller.java @@ -24,9 +24,11 @@ import net.openhft.chronicle.hash.serialization.impl.EnumMarshallable; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -enum DummyValueMarshaller implements DataAccess, SizedReader, +final class DummyValueMarshaller implements DataAccess, SizedReader, EnumMarshallable { - INSTANCE; + public static final DummyValueMarshaller INSTANCE = new DummyValueMarshaller(); + + private DummyValueMarshaller() {} @Override public Data getData(@NotNull DummyValue instance) { diff --git a/src/test/java/net/openhft/chronicle/map/DeflatorStringMarshaller.java b/src/test/java/net/openhft/chronicle/map/DeflatorStringMarshaller.java index a298ca204..43a6e68fc 100644 --- a/src/test/java/net/openhft/chronicle/map/DeflatorStringMarshaller.java +++ b/src/test/java/net/openhft/chronicle/map/DeflatorStringMarshaller.java @@ -32,9 +32,11 @@ import java.util.zip.InflaterInputStream; /** * Created by peter on 24/10/14. */ -public enum DeflatorStringMarshaller implements BytesReader, +public final class DeflatorStringMarshaller implements BytesReader, BytesWriter, EnumMarshallable { - INSTANCE; + public static final DeflatorStringMarshaller INSTANCE = new DeflatorStringMarshaller(); + + private DeflatorStringMarshaller() {} private static final StringFactory STRING_FACTORY = getStringFactory(); diff --git a/src/test/java/net/openhft/chronicle/map/Issue43Test.java b/src/test/java/net/openhft/chronicle/map/Issue43Test.java index de3039537..61f8edc96 100644 --- a/src/test/java/net/openhft/chronicle/map/Issue43Test.java +++ b/src/test/java/net/openhft/chronicle/map/Issue43Test.java @@ -54,9 +54,12 @@ public class Issue43Test { } } - private enum ArrayMarshaller implements BytesReader, BytesWriter, + private static final class ArrayMarshaller + implements BytesReader, BytesWriter, EnumMarshallable { - INSTANCE; + public static final ArrayMarshaller INSTANCE = new ArrayMarshaller(); + + private ArrayMarshaller() {} @Override public void write(Bytes bytes, @NotNull ValueWrapper vw) { diff --git a/src/test/java/net/openhft/chronicle/map/Issue58.java b/src/test/java/net/openhft/chronicle/map/Issue58.java index f7e18640f..a1ea962f4 100644 --- a/src/test/java/net/openhft/chronicle/map/Issue58.java +++ b/src/test/java/net/openhft/chronicle/map/Issue58.java @@ -129,9 +129,11 @@ public class Issue58 { } - enum UuidMarshaller + static final class UuidMarshaller implements BytesReader, BytesWriter, EnumMarshallable { - INSTANCE; + public static final UuidMarshaller INSTANCE = new UuidMarshaller(); + + private UuidMarshaller() {} @Override public void write(Bytes bytes, @NotNull UUID uuid) { diff --git a/src/test/java/net/openhft/chronicle/map/example/PointListSerializationTest.java b/src/test/java/net/openhft/chronicle/map/example/PointListSerializationTest.java index 417d40018..c640dc115 100644 --- a/src/test/java/net/openhft/chronicle/map/example/PointListSerializationTest.java +++ b/src/test/java/net/openhft/chronicle/map/example/PointListSerializationTest.java @@ -53,8 +53,11 @@ public class PointListSerializationTest { } } - enum AMarshaller implements BytesReader, BytesWriter, EnumMarshallable { - INSTANCE; + static final class AMarshaller implements BytesReader, BytesWriter, + EnumMarshallable { + public static final AMarshaller INSTANCE = new AMarshaller(); + + private AMarshaller() {} @Override public void write(Bytes out, @NotNull A toWrite) { diff --git a/src/test/java/net/openhft/chronicle/map/fromdocs/CharSequenceArrayBytesMarshaller.java b/src/test/java/net/openhft/chronicle/map/fromdocs/CharSequenceArrayBytesMarshaller.java index 000d6176f..77e2a594f 100644 --- a/src/test/java/net/openhft/chronicle/map/fromdocs/CharSequenceArrayBytesMarshaller.java +++ b/src/test/java/net/openhft/chronicle/map/fromdocs/CharSequenceArrayBytesMarshaller.java @@ -28,11 +28,13 @@ import org.jetbrains.annotations.Nullable; import java.util.Arrays; -public enum CharSequenceArrayBytesMarshaller +public final class CharSequenceArrayBytesMarshaller implements BytesWriter, BytesReader, ReadResolvable { - INSTANCE; + static final CharSequenceArrayBytesMarshaller INSTANCE = new CharSequenceArrayBytesMarshaller(); + + private CharSequenceArrayBytesMarshaller() {} @Override public void write(Bytes out, @NotNull CharSequence[] toWrite) { diff --git a/src/test/java/net/openhft/chronicle/map/fromdocs/PointListSizedMarshaller.java b/src/test/java/net/openhft/chronicle/map/fromdocs/PointListSizedMarshaller.java index dd2a2553f..1c9f9040b 100644 --- a/src/test/java/net/openhft/chronicle/map/fromdocs/PointListSizedMarshaller.java +++ b/src/test/java/net/openhft/chronicle/map/fromdocs/PointListSizedMarshaller.java @@ -28,11 +28,13 @@ import org.jetbrains.annotations.NotNull; import java.util.ArrayList; import java.util.List; -public enum PointListSizedMarshaller +public final class PointListSizedMarshaller implements SizedReader>, SizedWriter>, ReadResolvable { - INSTANCE; + static final PointListSizedMarshaller INSTANCE = new PointListSizedMarshaller(); + + private PointListSizedMarshaller() {} /** A point takes 16 bytes in serialized form: 8 bytes for both x and y value */ private static final long ELEMENT_SIZE = 16;