From bce834d2dc032a708547547c49fc99b8d35be3ba Mon Sep 17 00:00:00 2001
From: leventov <leventov@ya.ru>
Date: Mon, 23 Nov 2015 14:23:51 +0300
Subject: [PATCH] Correctly initialize transient fields in marshallers

---
 .../hash/serialization/ListMarshaller.java    |  1 +
 .../hash/serialization/MapMarshaller.java     | 20 ++++++++++++--
 .../hash/serialization/SetMarshaller.java     | 17 +++++++++++-
 .../impl/ByteArrayDataAccess.java             | 21 ++++++++++++++-
 .../impl/ByteBufferDataAccess.java            | 26 ++++++++++++++++---
 .../impl/ByteableDataAccess.java              |  1 +
 .../impl/BytesAsSizedReader.java              |  1 +
 .../impl/BytesMarshallableDataAccess.java     | 20 ++++++++++++--
 .../impl/CharSequenceSizedReader.java         | 19 +++++++++++++-
 .../impl/ConstantSizeMarshaller.java          |  2 ++
 .../ExternalBytesMarshallableDataAccess.java  | 20 +++++++++++++-
 .../impl/ExternalizableDataAccess.java        |  1 +
 ...NotReusingSizedMarshallableDataAccess.java |  1 +
 .../impl/SerializableDataAccess.java          | 24 ++++++++++++++---
 .../impl/SizedMarshallableDataAccess.java     | 20 +++++++++++++-
 .../serialization/impl/StringBytesReader.java | 19 +++++++++++++-
 .../serialization/impl/StringSizedReader.java | 18 ++++++++++++-
 .../serialization/impl/ValueDataAccess.java   | 19 +++++++++-----
 .../hash/serialization/impl/ValueReader.java  | 15 ++++++-----
 19 files changed, 235 insertions(+), 30 deletions(-)

diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/ListMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/ListMarshaller.java
index 15d703245..81afc233c 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/ListMarshaller.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/ListMarshaller.java
@@ -57,6 +57,7 @@ import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNe
 public class ListMarshaller<T>
         implements BytesReader<List<T>>, BytesWriter<List<T>>, StatefulCopyable<ListMarshaller<T>> {
 
+    // Config fields
     private final BytesReader<T> elementReader;
     private final BytesWriter<? super T> elementWriter;
 
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/MapMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/MapMarshaller.java
index af9491ffc..6dc698128 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/MapMarshaller.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/MapMarshaller.java
@@ -20,6 +20,8 @@ import net.openhft.chronicle.bytes.Bytes;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.HashMap;
@@ -49,12 +51,15 @@ public class MapMarshaller<K, V>
         implements BytesReader<Map<K, V>>, BytesWriter<Map<K, V>>,
         StatefulCopyable<MapMarshaller<K, V>> {
 
+    // Config fields
     private final BytesReader<K> keyReader;
     private final BytesWriter<? super K> keyWriter;
     private final BytesReader<V> valueReader;
     private final BytesWriter<? super V> valueWriter;
-    private final transient Deque<K> orderedKeys = new ArrayDeque<>();
-    private final transient Deque<V> orderedValues = new ArrayDeque<>();
+
+    // Cache fields
+    private transient Deque<K> orderedKeys;
+    private transient Deque<V> orderedValues;
 
     public MapMarshaller(
             BytesReader<K> keyReader, BytesWriter<? super K> keyWriter,
@@ -63,6 +68,17 @@ public class MapMarshaller<K, V>
         this.keyWriter = keyWriter;
         this.valueReader = valueReader;
         this.valueWriter = valueWriter;
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        orderedKeys = new ArrayDeque<>();
+        orderedValues = new ArrayDeque<>();
     }
 
     @NotNull
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/SetMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/SetMarshaller.java
index 05e2b8563..b452b7a20 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/SetMarshaller.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/SetMarshaller.java
@@ -20,6 +20,8 @@ import net.openhft.chronicle.bytes.Bytes;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.util.*;
 
 import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNeeded;
@@ -56,13 +58,26 @@ import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNe
 public class SetMarshaller<T>
         implements BytesReader<Set<T>>, BytesWriter<Set<T>>, StatefulCopyable<SetMarshaller<T>> {
 
+    // Config fields
     private final BytesReader<T> elementReader;
     private final BytesWriter<? super T> elementWriter;
-    private final transient Deque<T> orderedElements = new ArrayDeque<>();
+
+    /** Cache field */
+    private transient Deque<T> orderedElements;
 
     public SetMarshaller(BytesReader<T> elementReader, BytesWriter<? super T> elementWriter) {
         this.elementReader = elementReader;
         this.elementWriter = elementWriter;
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        orderedElements = new ArrayDeque<>();
     }
 
     @NotNull
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArrayDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArrayDataAccess.java
index 0918b8c7e..fe7f0096a 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArrayDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteArrayDataAccess.java
@@ -24,10 +24,29 @@ import net.openhft.chronicle.hash.serialization.DataAccess;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 public class ByteArrayDataAccess extends AbstractData<byte[]> implements DataAccess<byte[]> {
 
+    /** Cache field */
+    private transient HeapBytesStore<byte[]> bs;
+
+    /** State field */
     private transient byte[] array;
-    private final transient HeapBytesStore<byte[]> bs = HeapBytesStore.uninitialized();
+
+    public ByteArrayDataAccess() {
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        bs = HeapBytesStore.uninitialized();
+    }
 
     @Override
     public RandomDataInput bytes() {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferDataAccess.java
index 2109957fa..f9bb72485 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteBufferDataAccess.java
@@ -24,17 +24,37 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import sun.nio.ch.DirectBuffer;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.nio.ByteBuffer;
 
 public class ByteBufferDataAccess extends AbstractData<ByteBuffer>
         implements DataAccess<ByteBuffer> {
 
+    // Cache fields
+    private transient HeapBytesStore heapBytesStore;
+    private transient NativeBytesStore nativeBytesStore;
+    private transient VanillaBytes<Void> bytes;
+
+    // State fields
     private transient ByteBuffer bb;
-    private final transient HeapBytesStore heapBytesStore = HeapBytesStore.uninitialized();
-    private final transient NativeBytesStore nativeBytesStore = NativeBytesStore.uninitialized();
-    final transient VanillaBytes<Void> bytes = VanillaBytes.vanillaBytes();
     private transient BytesStore bytesStore;
 
+    public ByteBufferDataAccess() {
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        heapBytesStore = HeapBytesStore.uninitialized();
+        nativeBytesStore = NativeBytesStore.uninitialized();
+        bytes = VanillaBytes.vanillaBytes();
+    }
+
     @Override
     public RandomDataInput bytes() {
         return bytesStore;
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteableDataAccess.java
index d2694c43a..4d5ab0a94 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ByteableDataAccess.java
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.Nullable;
 public class ByteableDataAccess<T extends Byteable> extends InstanceCreatingMarshaller<T>
         implements DataAccess<T>, Data<T> {
 
+    /** State field */
     private transient T instance;
 
     public ByteableDataAccess(Class<T> tClass) {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesAsSizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesAsSizedReader.java
index f5f481007..29510cc8a 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesAsSizedReader.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesAsSizedReader.java
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.Nullable;
 public class BytesAsSizedReader<T>
         implements SizedReader<T>, StatefulCopyable<BytesAsSizedReader<T>> {
 
+    /** Config field */
     private final BytesReader<T> reader;
 
     public BytesAsSizedReader(BytesReader<T> reader) {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesMarshallableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesMarshallableDataAccess.java
index 56910b14b..5512d2191 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesMarshallableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/BytesMarshallableDataAccess.java
@@ -24,14 +24,30 @@ import net.openhft.chronicle.hash.serialization.DataAccess;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 public class BytesMarshallableDataAccess<T extends BytesMarshallable>
         extends InstanceCreatingMarshaller<T> implements DataAccess<T>, Data<T> {
 
-    transient T instance;
-    final transient Bytes bytes = Bytes.allocateElasticDirect(1);
+    /** Cache field */
+    private transient Bytes bytes;
+
+    /** State field */
+    private transient T instance;
 
     public BytesMarshallableDataAccess(Class<T> tClass) {
         super(tClass);
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        bytes = Bytes.allocateElasticDirect(1);
     }
 
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedReader.java
index a23e0da41..9727e2c03 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedReader.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/CharSequenceSizedReader.java
@@ -23,10 +23,27 @@ import net.openhft.chronicle.hash.serialization.StatefulCopyable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 public class CharSequenceSizedReader
         implements SizedReader<CharSequence>, StatefulCopyable<CharSequenceSizedReader> {
 
-    private final transient StringBuilder sb = new StringBuilder();
+    /** Cache field */
+    private transient StringBuilder sb;
+
+    public CharSequenceSizedReader() {
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        sb = new StringBuilder();
+    }
 
     @NotNull
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ConstantSizeMarshaller.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ConstantSizeMarshaller.java
index 838e7b3d1..544e0eea6 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ConstantSizeMarshaller.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ConstantSizeMarshaller.java
@@ -20,6 +20,8 @@ import net.openhft.chronicle.bytes.Bytes;
 import net.openhft.chronicle.hash.serialization.SizeMarshaller;
 
 public final class ConstantSizeMarshaller implements SizeMarshaller {
+
+    /** Config field */
     private final long constantSize;
 
     public ConstantSizeMarshaller(long constantSize) {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalBytesMarshallableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalBytesMarshallableDataAccess.java
index e63ab8ce7..438b7a5b5 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalBytesMarshallableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalBytesMarshallableDataAccess.java
@@ -25,21 +25,39 @@ import net.openhft.chronicle.hash.serialization.SizedReader;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNeeded;
 
 public class ExternalBytesMarshallableDataAccess<T> extends InstanceCreatingMarshaller<T>
         implements DataAccess<T>, Data<T> {
 
+    // Config fields
     private final SizedReader<T> reader;
     private final BytesWriter<? super T> writer;
+
+    /** Cache field */
+    private transient Bytes bytes;
+
+    /** State field */
     private transient T instance;
-    private final transient Bytes bytes = Bytes.allocateElasticDirect(1);
 
     public ExternalBytesMarshallableDataAccess(
             Class<T> tClass, SizedReader<T> reader, BytesWriter<? super T> writer) {
         super(tClass);
         this.writer = writer;
         this.reader = reader;
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        bytes = Bytes.allocateElasticDirect(1);
     }
 
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalizableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalizableDataAccess.java
index b8037c545..d7a928694 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalizableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ExternalizableDataAccess.java
@@ -28,6 +28,7 @@ import java.io.ObjectOutputStream;
 
 public class ExternalizableDataAccess<T extends Externalizable> extends SerializableDataAccess<T> {
 
+    /** Config field */
     protected final Class<T> tClass;
 
     public ExternalizableDataAccess(Class<T> tClass) {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/NotReusingSizedMarshallableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/NotReusingSizedMarshallableDataAccess.java
index 646408384..0553c6b05 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/NotReusingSizedMarshallableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/NotReusingSizedMarshallableDataAccess.java
@@ -23,6 +23,7 @@ import net.openhft.chronicle.hash.serialization.SizedWriter;
 import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNeeded;
 
 public class NotReusingSizedMarshallableDataAccess<T> extends SizedMarshallableDataAccess<T> {
+
     public NotReusingSizedMarshallableDataAccess(
             Class<T> tClass, SizedReader<T> sizedReader, SizedWriter<? super T> sizedWriter) {
         super(tClass, sizedReader, sizedWriter);
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializableDataAccess.java
index f9c97db3c..4796be64e 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SerializableDataAccess.java
@@ -29,10 +29,28 @@ import java.io.*;
 public class SerializableDataAccess<T extends Serializable> extends AbstractData<T>
         implements DataAccess<T> {
 
+    // Cache fields
+    transient Bytes bytes;
+    transient OutputStream out;
+    transient InputStream in;
+
+    /** State field */
     transient T instance;
-    final transient Bytes bytes = Bytes.allocateElasticDirect(1);
-    final transient OutputStream out = bytes.outputStream();
-    final transient InputStream in = bytes.inputStream();
+
+    public SerializableDataAccess() {
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        bytes = Bytes.allocateElasticDirect(1);
+        out = bytes.outputStream();
+        in = bytes.inputStream();
+    }
 
     @Override
     public RandomDataInput bytes() {
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SizedMarshallableDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SizedMarshallableDataAccess.java
index 1926bf3ad..18a604b41 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/SizedMarshallableDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/SizedMarshallableDataAccess.java
@@ -25,21 +25,39 @@ import net.openhft.chronicle.hash.serialization.SizedWriter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 import static net.openhft.chronicle.hash.serialization.StatefulCopyable.copyIfNeeded;
 
 public class SizedMarshallableDataAccess<T> extends InstanceCreatingMarshaller<T>
         implements DataAccess<T>, Data<T> {
 
+    // Config fields
     final SizedReader<T> sizedReader;
     final SizedWriter<? super T> sizedWriter;
+
+    /** Cache field */
+    private transient Bytes bytes;
+
+    /** State field */
     private transient T instance;
-    private final transient Bytes bytes = Bytes.allocateElasticDirect(1);
 
     public SizedMarshallableDataAccess(
             Class<T> tClass, SizedReader<T> sizedReader, SizedWriter<? super T> sizedWriter) {
         super(tClass);
         this.sizedWriter = sizedWriter;
         this.sizedReader = sizedReader;
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        bytes = Bytes.allocateElasticDirect(1);
     }
 
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBytesReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBytesReader.java
index a84d7608d..ec9608993 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBytesReader.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringBytesReader.java
@@ -24,6 +24,9 @@ import net.openhft.chronicle.hash.serialization.StatefulCopyable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 /**
  * {@link BytesReader} implementation for String, for the primary ChronicleMap's key of value type
  * {@link StringSizedReader} + {@link CharSequenceSizedWriter} are more effective (because don't
@@ -35,7 +38,21 @@ import org.jetbrains.annotations.Nullable;
 public class StringBytesReader
         implements BytesReader<String>, StatefulCopyable<StringBytesReader> {
 
-    private final transient StringBuilder sb = new StringBuilder();
+    /** Cache field */
+    private transient StringBuilder sb;
+
+    public StringBytesReader() {
+        initTransients();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        sb = new StringBuilder();
+    }
 
     @NotNull
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringSizedReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringSizedReader.java
index 487052579..8284eae81 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringSizedReader.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/StringSizedReader.java
@@ -23,9 +23,25 @@ import net.openhft.chronicle.hash.serialization.StatefulCopyable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 public class StringSizedReader implements SizedReader<String>, StatefulCopyable<StringSizedReader> {
 
-    private final transient StringBuilder sb = new StringBuilder();
+    /** Cache field */
+    private transient StringBuilder sb;
+
+    public StringSizedReader() {
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
+    private void initTransients() {
+        sb = new StringBuilder();
+    }
 
     @NotNull
     @Override
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueDataAccess.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueDataAccess.java
index c6f952c59..79e269099 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueDataAccess.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueDataAccess.java
@@ -33,11 +33,16 @@ import static net.openhft.chronicle.bytes.NativeBytesStore.nativeStoreWithFixedC
 
 public class ValueDataAccess<T> extends AbstractData<T> implements DataAccess<T> {
 
+    /** The interface of values serialized. */
     protected final Class<T> valueType;
-    private transient Byteable nativeInstance;
-    private transient Copyable nativeInstanceAsCopyable;
+
+    // Cache fields
     protected transient Class<? extends T> nativeClass;
     protected transient Class<? extends T> heapClass;
+    private transient Byteable nativeInstance;
+    private transient Copyable nativeInstanceAsCopyable;
+
+    /** State field */
     private transient Byteable instance;
 
     public ValueDataAccess(Class<T> valueType) {
@@ -45,6 +50,11 @@ public class ValueDataAccess<T> extends AbstractData<T> implements DataAccess<T>
         initTransients();
     }
 
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
     private void initTransients() {
         nativeInstance = (Byteable) Values.newNativeReference(valueType);
         nativeInstanceAsCopyable = (Copyable) nativeInstance;
@@ -54,11 +64,6 @@ public class ValueDataAccess<T> extends AbstractData<T> implements DataAccess<T>
                 0, nativeInstance.maxSize());
     }
 
-    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
-        in.defaultReadObject();
-        initTransients();
-    }
-
     protected T createInstance() {
         try {
             return heapClass.newInstance();
diff --git a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueReader.java b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueReader.java
index 1f8577ff5..9cf36e3ee 100644
--- a/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueReader.java
+++ b/src/main/java/net/openhft/chronicle/hash/serialization/impl/ValueReader.java
@@ -32,9 +32,12 @@ import java.io.ObjectInputStream;
 public class ValueReader<T>
         implements SizedReader<T>, BytesReader<T>, StatefulCopyable<ValueReader<T>> {
 
+    /** The interface of values deserialized. */
     protected final Class<T> valueType;
+
+    // Cache fields
     protected transient Class<? extends T> heapClass;
-    private transient Class<? extends T> nativeClass;
+    protected transient Class<? extends T> nativeClass;
     private transient Byteable nativeReference;
 
     public ValueReader(Class<T> valueType) {
@@ -42,17 +45,17 @@ public class ValueReader<T>
         initTransients();
     }
 
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initTransients();
+    }
+
     private void initTransients() {
         heapClass = Values.heapClassFor(valueType);
         nativeClass = Values.nativeClassFor(valueType);
         nativeReference = (Byteable) Values.newNativeReference(valueType);
     }
 
-    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
-        in.defaultReadObject();
-        initTransients();
-    }
-
     protected T createInstance() {
         try {
             return heapClass.newInstance();