fix #39 bump version 2.14. fix bug in some exception handlers

RuedigerMoeller · Nov 20, 2014 · 123cd07 · 123cd07
1 parent e3e7013
commit 123cd07
Show file tree

Hide file tree

Showing 16 changed files with 143 additions and 28 deletions.
diff --git a/build.gradle b/build.gradle
@@ -2,7 +2,7 @@ import java.util.zip.ZipFile
 
 apply plugin: 'java'
 apply plugin: 'maven'
-version="2.13"
+version="2.14"
 
 targetCompatibility = 1.7
 sourceCompatibility = 1.7

diff --git a/pom.xml b/pom.xml
@@ -10,7 +10,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>de.ruedigermoeller</groupId>
     <artifactId>fst</artifactId>
-    <version>2.13</version>
+    <version>2.14</version>
 
     <description>a fast java serialization drop in-replacement + some serialization based utils (Structs, OffHeap Memory)</description>
     <url>https://code.google.com/p/fast-serialization/</url>

diff --git a/src/main/java/org/nustaq/offheap/FSTSerializedOffheapMap.java b/src/main/java/org/nustaq/offheap/FSTSerializedOffheapMap.java
@@ -44,7 +44,7 @@ public ByteSource encodeValue(V value) {
             tmpVal.setLen(buffer.length);
             return encodeValue(value);
         } catch (Exception e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
         return tmpVal;
     }

diff --git a/src/main/java/org/nustaq/serialization/FSTConfiguration.java b/src/main/java/org/nustaq/serialization/FSTConfiguration.java
@@ -206,7 +206,7 @@ public static FSTConfiguration createDefaultConfiguration() {
         reg.putSerializer(HashSet.class, new FSTCollectionSerializer(), false); // subclass should register manually
         reg.putSerializer(HashMap.class, new FSTMapSerializer(), false); // subclass should register manually
         reg.putSerializer(LinkedHashMap.class, new FSTMapSerializer(), false); // subclass should register manually
-        reg.putSerializer(Hashtable.class, new FSTMapSerializer(), false); // subclass should register manually
+        reg.putSerializer(Hashtable.class, new FSTMapSerializer(), true); // subclass should register manually
         reg.putSerializer(ConcurrentHashMap.class, new FSTMapSerializer(), true); // subclass should register manually
         reg.putSerializer(FSTStruct.class, new FSTStructSerializer(), true); // subclasses also use this
         return conf;

diff --git a/src/main/java/org/nustaq/serialization/FSTObjectInput.java b/src/main/java/org/nustaq/serialization/FSTObjectInput.java
@@ -506,7 +506,7 @@ protected Object instantiateAndReadNoSer(Class c, FSTClazzInfo clzSerInfo, FSTCl
                 final Object prevNew = newObj;
                 newObj = handleReadRessolve(clzSerInfo, newObj);
                 if ( newObj != prevNew && needsRefLookup ) {
-                    objects.replace(prevNew,newObj,tmp);
+                    objects.replace(prevNew, newObj, tmp);
                 }
             }
         } else if (clzSerInfo.useCompatibleMode())
@@ -573,8 +573,19 @@ protected void readObjectCompatibleRecursive(FSTClazzInfo.FSTFieldInfo reference
                 {
                     // came from writeMethod, but no readMethod defined => assume defaultWriteObject
                     tag = readByte(); // consume tag of defaultwriteobject (99)
-//                    if ( tag != 99 )
-//                        System.out.println("weird stuff incoming");
+                    if ( tag == 77 ) // came from putfield
+                    {
+                        HashMap<String, Object> fieldMap = (HashMap<String, Object>) FSTObjectInput.this.readObjectInternal(HashMap.class);
+                        final FSTClazzInfo.FSTFieldInfo[] fieldArray = fstCompatibilityInfo.getFieldArray();
+                        for (int i = 0; i < fieldArray.length; i++) {
+                            FSTClazzInfo.FSTFieldInfo fstFieldInfo = fieldArray[i];
+                            final Object val = fieldMap.get(fstFieldInfo.getField().getName());
+                            if ( val != null ) {
+                                fstFieldInfo.setObjectValue(toRead,val);
+                            }
+                        }
+                        return;
+                    }
                 }
                 readObjectFields(referencee, serializationInfo, fstCompatibilityInfo.getFieldArray(), toRead,0,0);
             }

diff --git a/src/main/java/org/nustaq/serialization/coders/FSTBytezDecoder.java b/src/main/java/org/nustaq/serialization/coders/FSTBytezDecoder.java
@@ -74,7 +74,7 @@ protected void readNextInputChunk(int bytes) {
                 readUntil = pos+read;
             }
         } catch (IOException e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
     }
 

diff --git a/src/main/java/org/nustaq/serialization/coders/FSTBytezEncoder.java b/src/main/java/org/nustaq/serialization/coders/FSTBytezEncoder.java
@@ -240,7 +240,7 @@ public void writeInt32At(int position, int v) {
         try {
             ensureFree( position+4);
         } catch (IOException e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
         buffout.putInt(position,v);
     }

diff --git a/src/main/java/org/nustaq/serialization/simpleapi/DefaultCoder.java b/src/main/java/org/nustaq/serialization/simpleapi/DefaultCoder.java
@@ -59,7 +59,7 @@ public int toByteArray( Object obj, byte result[], int resultOffset, int avaiabl
         try {
             output.writeObject(obj);
         } catch (IOException e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
         int written = output.getWritten();
         if ( written > avaiableSize ) {
@@ -74,7 +74,7 @@ public byte[] toByteArray( Object o ) {
         try {
             output.writeObject(o);
         } catch (IOException e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
         return output.getCopyOfWrittenBuffer();
     }
@@ -94,9 +94,8 @@ public Object toObject( byte arr[], int off, int len ) {
             }
             return input.readObject();
         } catch (Exception e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
-        return null;
     }
 
     public Object toObject( byte arr[] ) {

diff --git a/src/main/java/org/nustaq/serialization/simpleapi/OnHeapCoder.java b/src/main/java/org/nustaq/serialization/simpleapi/OnHeapCoder.java
@@ -92,7 +92,7 @@ public int toByteArray( Object o, byte arr[], int startIndex, int availableSize
         try {
             out.writeObject(o);
         } catch (IOException e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
         int written = out.getWritten();
         return written;
@@ -107,7 +107,7 @@ public byte[] toByteArray(Object o) {
             try {
                 out.writeObject(o);
             } catch (IOException e) {
-                FSTUtil.rethrow(e);
+                throw FSTUtil.rethrow(e);
             }
             return out.getCopyOfWrittenBuffer();
         } catch (FSTBufferTooSmallException ex) {
@@ -138,9 +138,8 @@ public Object toObject( byte arr[], int startIndex, int availableSize) {
             Object o = in.readObject();
             return o;
         } catch (Exception e) {
-            FSTUtil.rethrow(e);
+            throw FSTUtil.rethrow(e);
         }
-        return null;
     }
 
     /**

diff --git a/src/test/ser/GitHub39.java b/src/test/ser/GitHub39.java
@@ -0,0 +1,106 @@
+package ser;
+
+import com.cedarsoftware.util.DeepEquals;
+import junit.framework.Assert;
+import org.junit.Test;
+import org.nustaq.serialization.FSTConfiguration;
+import org.nustaq.serialization.FSTObjectInput;
+import org.nustaq.serialization.FSTObjectOutput;
+import org.nustaq.serialization.serializers.FSTCollectionSerializer;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Stack;
+
+/**
+ * Created by ruedi on 20.11.2014.
+ */
+public class GitHub39 {
+
+    static class OneStackClass implements Serializable {
+
+        Stack<String> a;
+
+        public OneStackClass(Stack<String> a) {
+            this.a = a;
+        }
+    }
+
+    static class TwoStackClass implements Serializable {
+
+        Stack<String> a;
+        Stack<String> b;
+
+        public TwoStackClass(Stack<String> a, Stack<String> b) {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    @Test
+    public void test() {
+
+        OneStackClass osc = new OneStackClass(new Stack<String>());
+        byte[] mywriteMethod1 = FSTSerialization.mywriteMethod(osc);
+        OneStackClass myreadMethod1 = FSTSerialization.myreadMethod(mywriteMethod1, OneStackClass.class);
+        Assert.assertTrue(DeepEquals.deepEquals(osc,myreadMethod1));
+        //
+        TwoStackClass tsc = new TwoStackClass(new Stack<String>(), new Stack<String>());
+        byte[] mywriteMethod2 = FSTSerialization.mywriteMethod(tsc);
+        TwoStackClass myreadMethod2 = FSTSerialization.myreadMethod(mywriteMethod2, TwoStackClass.class);
+        Assert.assertTrue(DeepEquals.deepEquals(tsc,myreadMethod2));
+
+    }
+
+    static public class FSTSerialization {
+
+        final static FSTConfiguration configuration;
+
+        public static FSTConfiguration getConfiguration() {
+            return configuration;
+        }
+
+        static {
+            configuration = FSTConfiguration.createDefaultConfiguration();
+//            configuration.setShareReferences(true);
+//            configuration.registerSerializer(Stack.class,new FSTCollectionSerializer(), true);
+            configuration.registerClass(
+                Stack.class,
+                String.class
+            );
+        }
+
+        public static <T> T myreadMethod(byte[] stream, Class<T> c) {
+            FSTObjectInput in = configuration.getObjectInput(stream);
+            T result = null;
+            try {
+                result = (T) in.readObject(c);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+            return result;
+        }
+
+        @SuppressWarnings("null")
+        public static byte[] mywriteMethod(Object toWrite) {
+            return mywriteMethod(null, toWrite);
+        }
+
+        public static byte[] mywriteMethod(byte[] stream, Object toWrite) {
+            FSTObjectOutput out = configuration.getObjectOutput(stream);
+            try {
+                out.writeObject(toWrite, toWrite.getClass());
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            try {
+                out.flush();
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            return out.getBuffer();
+        }
+
+    }
+
+}
diff --git a/...nit/tests/TestFastSerializationBean1.java → ...nit/tests/TestFastSerializationBean1.java b/...nit/tests/TestFastSerializationBean1.java → ...nit/tests/TestFastSerializationBean1.java
@@ -1,4 +1,4 @@
-package unit.tests;
+package ser.unit.tests;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -13,8 +13,8 @@
 import org.nustaq.serialization.FSTConfiguration;
 import org.nustaq.serialization.FSTObjectOutput;
 
-import unit.tests.externalizable.BeanTestClass1;
-import unit.tests.externalizable.ExternalizableTestClass;
+import ser.unit.tests.externalizable.BeanTestClass1;
+import ser.unit.tests.externalizable.ExternalizableTestClass;
 
 public class TestFastSerializationBean1 {
 

diff --git a/...nit/tests/TestFastSerializationBean2.java → ...nit/tests/TestFastSerializationBean2.java b/...nit/tests/TestFastSerializationBean2.java → ...nit/tests/TestFastSerializationBean2.java
@@ -1,4 +1,4 @@
-package unit.tests;
+package ser.unit.tests;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -15,8 +15,8 @@
 import org.nustaq.serialization.FSTConfiguration;
 import org.nustaq.serialization.FSTObjectOutput;
 
-import unit.tests.externalizable.BeanTestClass2;
-import unit.tests.externalizable.ExternalizableTestClass;
+import ser.unit.tests.externalizable.BeanTestClass2;
+import ser.unit.tests.externalizable.ExternalizableTestClass;
 
 public class TestFastSerializationBean2 {
 

diff --git a/...unit/tests/TestFastSerializationList.java → ...unit/tests/TestFastSerializationList.java b/...unit/tests/TestFastSerializationList.java → ...unit/tests/TestFastSerializationList.java
@@ -1,4 +1,4 @@
-package unit.tests;
+package ser.unit.tests;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -15,7 +15,7 @@
 import org.nustaq.serialization.FSTConfiguration;
 import org.nustaq.serialization.FSTObjectOutput;
 
-import unit.tests.externalizable.ExternalizableTestClass;
+import ser.unit.tests.externalizable.ExternalizableTestClass;
 
 public class TestFastSerializationList {
 

diff --git a/.../tests/externalizable/BeanTestClass1.java → .../tests/externalizable/BeanTestClass1.java b/.../tests/externalizable/BeanTestClass1.java → .../tests/externalizable/BeanTestClass1.java
@@ -1,4 +1,4 @@
-package unit.tests.externalizable;
+package ser.unit.tests.externalizable;
 
 import java.io.Serializable;
 

diff --git a/.../tests/externalizable/BeanTestClass2.java → .../tests/externalizable/BeanTestClass2.java b/.../tests/externalizable/BeanTestClass2.java → .../tests/externalizable/BeanTestClass2.java
@@ -1,4 +1,4 @@
-package unit.tests.externalizable;
+package ser.unit.tests.externalizable;
 
 import java.io.Serializable;
 import java.util.Set;

diff --git a/...ternalizable/ExternalizableTestClass.java → ...ternalizable/ExternalizableTestClass.java b/...ternalizable/ExternalizableTestClass.java → ...ternalizable/ExternalizableTestClass.java
@@ -1,4 +1,4 @@
-package unit.tests.externalizable;
+package ser.unit.tests.externalizable;
 import java.io.*;
 
 public class ExternalizableTestClass implements Externalizable {