Re: Problem sending a Map over captp [patch]

>From 41f8c72e50b0202ef8c74a49c71598090f5dcefe Mon Sep 17 00:00:00 2001
From: Thomas Leonard <tal-v5nx5w6akNyLE8xUarVfuPLx9OUvmyODWmv/[email protected]>
Date: Thu, 25 Mar 2010 10:46:46 +0000
Subject: [PATCH] Serialize Switchable refs correctly

Java serialization gives each object the chance to replace itself with another
object. ConstMapImpl uses this to change itself into a ConstMap.fromColumns() call.
However, when serializing a resolved SwitchableRef Java only gives the SwitchableRef
this option, not the underlying object, so we should call it manually.

Also, if we do get a raw ConstMapImpl object, throw an expcetion immediately
rather than constructing an invalid object (with myTable == null).

Patch from the University of Southampton IT Innovation Centre.
---
 src/jsrc/net/captp/jcomm/CapTPReplacer.java        |   28 +++++++++++++++++++-
 .../org/erights/e/elib/tables/ConstMapImpl.java    |    7 +++++
 2 files changed, 34 insertions(+), 1 deletions(-)

diff --git a/src/jsrc/net/captp/jcomm/CapTPReplacer.java b/src/jsrc/net/captp/jcomm/CapTPReplacer.java
index 554084c..53487c0 100644
--- a/src/jsrc/net/captp/jcomm/CapTPReplacer.java
+++ b/src/jsrc/net/captp/jcomm/CapTPReplacer.java
@@ -14,6 +14,9 @@ import org.erights.e.elib.serial.Replacer;
 import org.erights.e.elib.slot.AuditChecker;
 import org.erights.e.elib.tables.ConstList;
 
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+
 /**
  * Used to specialize the SerializationStream for encoding a reference over a
  * CapTP connection.
@@ -50,7 +53,30 @@ class CapTPReplacer extends Replacer {
      * sure we're actually permitted to pass it by construction.
      */
     public Object substitute(Object ref) {
-        ref = Ref.resolution(ref);
+        Object resolvedRef = Ref.resolution(ref);
+        if (resolvedRef != ref) {
+            /* Java serialization has given the original ref the chance to
+             * writeReplace itself, but not the target. Do that now.
+             */
+            Method writeReplaceMethod;
+            try {
+                writeReplaceMethod = resolvedRef.getClass().getDeclaredMethod("writeReplace", new Class[] {});
+            } catch (NoSuchMethodException ex) {
+                writeReplaceMethod = null;
+            }
+            if (writeReplaceMethod == null) {
+                ref = resolvedRef;
+            } else {
+                try {
+                    writeReplaceMethod.setAccessible(true);
+                    ref = writeReplaceMethod.invoke(resolvedRef, new Object[] {});
+                } catch (InvocationTargetException ex) {
+                    throw new RuntimeException(ex);
+                } catch (IllegalAccessException ex) {
+                    throw new RuntimeException(ex);
+                }
+            }
+        }
 
         if (Ref.isJOSSPBCRef(ref)) {
             return ref;
diff --git a/src/jsrc/org/erights/e/elib/tables/ConstMapImpl.java b/src/jsrc/org/erights/e/elib/tables/ConstMapImpl.java
index 54ee0b5..a45d6bf 100644
--- a/src/jsrc/org/erights/e/elib/tables/ConstMapImpl.java
+++ b/src/jsrc/org/erights/e/elib/tables/ConstMapImpl.java
@@ -22,6 +22,8 @@ Contributor(s): ______________________________________.
 import org.erights.e.elib.base.Thunk;
 import org.erights.e.elib.serial.RemoteCall;
 
+import java.io.NotSerializableException;
+import java.io.ObjectInputStream;
 import java.io.ObjectStreamException;
 
 /**
@@ -107,4 +109,9 @@ class ConstMapImpl extends ConstMap {
     public Class valueType() {
         return myTable.valueType();
     }
+
+    /* Our super-class is Serializable, but we are not. */
+    private void readObject(ObjectInputStream stream) throws NotSerializableException {
+        throw new NotSerializableException("ConstMapImpl must be serialized specially.");
+    }
 }
-- 
1.6.3.3