2.1/user/src/com/google/gwt/rpc/server/CommandServerSerializationStreamReader.java - gwt - Git at Google

 /*
  * Copyright 2009 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.rpc.server;

 import com.google.gwt.rpc.client.ast.ArrayValueCommand;
 import com.google.gwt.rpc.client.ast.BooleanValueCommand;
 import com.google.gwt.rpc.client.ast.ByteValueCommand;
 import com.google.gwt.rpc.client.ast.CharValueCommand;
 import com.google.gwt.rpc.client.ast.DoubleValueCommand;
 import com.google.gwt.rpc.client.ast.EnumValueCommand;
 import com.google.gwt.rpc.client.ast.FloatValueCommand;
 import com.google.gwt.rpc.client.ast.IdentityValueCommand;
 import com.google.gwt.rpc.client.ast.InstantiateCommand;
 import com.google.gwt.rpc.client.ast.IntValueCommand;
 import com.google.gwt.rpc.client.ast.InvokeCustomFieldSerializerCommand;
 import com.google.gwt.rpc.client.ast.LongValueCommand;
 import com.google.gwt.rpc.client.ast.NullValueCommand;
 import com.google.gwt.rpc.client.ast.RpcCommandVisitor;
 import com.google.gwt.rpc.client.ast.ScalarValueCommand;
 import com.google.gwt.rpc.client.ast.SetCommand;
 import com.google.gwt.rpc.client.ast.ShortValueCommand;
 import com.google.gwt.rpc.client.ast.StringValueCommand;
 import com.google.gwt.rpc.client.ast.ValueCommand;
 import com.google.gwt.rpc.server.CommandSerializationUtil.Accessor;
 import com.google.gwt.user.client.rpc.SerializationException;
 import com.google.gwt.user.client.rpc.SerializationStreamReader;

 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Stack;

 /**
  * This class will use ValueCommands to reconstitute objects.
  */
 public class CommandServerSerializationStreamReader implements
     SerializationStreamReader {

   class Visitor extends RpcCommandVisitor {

     @SuppressWarnings("hiding")
     private final Stack<Object> values = new Stack<Object>();

     @Override
     public void endVisit(BooleanValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(ByteValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(CharValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(DoubleValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(EnumValueCommand x, Context ctx) {
       push(x, x.getValue());
     }

     @Override
     public void endVisit(FloatValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(IntValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(LongValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(NullValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(SetCommand x, Context ctx) {
       Exception ex;
       try {
         Field f = x.getFieldDeclClass().getDeclaredField(x.getField());
         Object value = values.pop();
         Object instance = values.peek();
         assert value == null
             || CommandSerializationUtil.getAccessor(f.getType()).canSet(
                 value.getClass()) : "Cannot assign a "
             + value.getClass().getName() + " into " + f.getType().getName();

         CommandSerializationUtil.getAccessor(f.getType()).set(instance, f,
             value);
         return;
       } catch (SecurityException e) {
         ex = e;
       } catch (NoSuchFieldException e) {
         ex = e;
       }
       halt(new SerializationException("Unable to set field value", ex));
     }

     @Override
     public void endVisit(ShortValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public void endVisit(StringValueCommand x, Context ctx) {
       pushScalar(x);
     }

     @Override
     public boolean visit(ArrayValueCommand x, Context ctx) {
       if (maybePushBackRef(x)) {
         Object array = Array.newInstance(x.getComponentType(),
             x.getComponentValues().size());
         push(x, array);

         int size = x.getComponentValues().size();
         Accessor a = CommandSerializationUtil.getAccessor(x.getComponentType());
         for (int i = 0; i < size; i++) {
           accept(x.getComponentValues().get(i));
           a.set(array, i, values.pop());
         }
       }

       return false;
     }

     @Override
     public boolean visit(InstantiateCommand x, Context ctx) {
       if (maybePushBackRef(x)) {
         Object instance;
         try {
           instance = CommandSerializationUtil.allocateInstance(x.getTargetClass());
           push(x, instance);
           return true;
         } catch (InstantiationException e) {
           halt(new SerializationException("Unable to create instance", e));
         }
       }

       return false;
     }

     @Override
     public boolean visit(InvokeCustomFieldSerializerCommand x, Context ctx) {
       if (maybePushBackRef(x)) {

         CommandServerSerializationStreamReader subReader = new CommandServerSerializationStreamReader(
             backRefs);
         subReader.prepareToRead(x.getValues());

         Class<?> serializerClass = x.getSerializerClass();
         assert serializerClass != null;

         Method instantiate = null;
         Method deserialize = null;
         for (Method m : serializerClass.getMethods()) {
           if ("instantiate".equals(m.getName())) {
             instantiate = m;
           } else if ("deserialize".equals(m.getName())) {
             deserialize = m;
           }

           if (instantiate != null && deserialize != null) {
             break;
           }
         }

         assert deserialize != null : "No deserialize method in "
             + serializerClass.getName();

         Object instance = null;
         if (instantiate != null) {
           assert Modifier.isStatic(instantiate.getModifiers()) : "instantiate method in "
               + serializerClass.getName() + " must be static";
           try {
             instance = instantiate.invoke(null, subReader);
           } catch (IllegalArgumentException e) {
             halt(new SerializationException("Unable to create instance", e));
           } catch (IllegalAccessException e) {
             halt(new SerializationException("Unable to create instance", e));
           } catch (InvocationTargetException e) {
             halt(new SerializationException("Unable to create instance", e));
           }
         } else {
           try {
             instance = x.getTargetClass().newInstance();
           } catch (InstantiationException e) {
             halt(new SerializationException("Unable to create instance", e));
           } catch (IllegalAccessException e) {
             halt(new SerializationException("Unable to create instance", e));
           }
         }

         assert instance != null : "Did not create instance";
         push(x, instance);

         // Process any additional fields
         accept(x.getSetters());

         try {
           deserialize.invoke(null, subReader, instance);
         } catch (IllegalArgumentException e) {
           halt(new SerializationException("Unable to deserialize instance", e));
         } catch (IllegalAccessException e) {
           halt(new SerializationException("Unable to deserialize instance", e));
         } catch (InvocationTargetException e) {
           halt(new SerializationException("Unable to deserialize instance", e));
         }
       }

       return false;
     }

     /**
      * Returns true if the command must be processed.
      */
     private boolean maybePushBackRef(IdentityValueCommand x) {
       Object instance = backRefs.get(x);
       if (instance == null) {
         return true;
       } else {
         values.push(instance);
         return false;
       }
     }

     private void push(IdentityValueCommand x, Object value) {
       assert !backRefs.containsKey(x) : "Trying to redefine a backref";
       backRefs.put(x, value);
       values.push(value);
     }

     private void pushScalar(ScalarValueCommand x) {
       values.push(x.getValue());
     }
   }

   final Map<IdentityValueCommand, Object> backRefs;
   Iterator<ValueCommand> values;

   public CommandServerSerializationStreamReader() {
     this(new HashMap<IdentityValueCommand, Object>());
   }

   private CommandServerSerializationStreamReader(
       Map<IdentityValueCommand, Object> backRefs) {
     this.backRefs = backRefs;
   }

   public void prepareToRead(List<ValueCommand> commands) {
     values = commands.iterator();
   }

   public boolean readBoolean() throws SerializationException {
     return readNumberCommand(BooleanValueCommand.class).getValue();
   }

   public byte readByte() throws SerializationException {
     return readNumberCommand(ByteValueCommand.class).getValue();
   }

   public char readChar() throws SerializationException {
     return readNumberCommand(CharValueCommand.class).getValue();
   }

   public double readDouble() throws SerializationException {
     return readNumberCommand(DoubleValueCommand.class).getValue();
   }

   public float readFloat() throws SerializationException {
     return readNumberCommand(FloatValueCommand.class).getValue();
   }

   public int readInt() throws SerializationException {
     return readNumberCommand(IntValueCommand.class).getValue();
   }

   public long readLong() throws SerializationException {
     return readNumberCommand(LongValueCommand.class).getValue();
   }

   public Object readObject() throws SerializationException {
     ValueCommand command = readNextCommand(ValueCommand.class);
     Visitor v = new Visitor();
     v.accept(command);
     return v.values.pop();
   }

   public short readShort() throws SerializationException {
     return readNumberCommand(ShortValueCommand.class).getValue();
   }

   public String readString() throws SerializationException {
     return (String) readObject();
   }

   private <T extends ValueCommand> T readNextCommand(Class<T> clazz)
       throws SerializationException {
     if (!values.hasNext()) {
       throw new SerializationException("Reached end of stream");
     }
     ValueCommand next = values.next();
     if (!clazz.isInstance(next)) {
       throw new SerializationException("Cannot assign "
           + next.getClass().getName() + " to " + clazz.getName());
     }
     return clazz.cast(next);
   }

   /**
    * Will perform narrowing conversions from double type to other numeric types.
    */
   private <T extends ValueCommand> T readNumberCommand(Class<T> clazz)
       throws SerializationException {
     if (!values.hasNext()) {
       throw new SerializationException("Reached end of stream");
     }
     ValueCommand next = values.next();

     if (clazz.isInstance(next)) {
       return clazz.cast(next);
     } else if (next instanceof LongValueCommand) {
       if (!clazz.isInstance(next)) {
         throw new SerializationException("Cannot assign "
             + next.getClass().getName() + " to " + clazz.getName());
       }
       return clazz.cast(next);
     } else if (next instanceof DoubleValueCommand) {
       Exception ex;
       try {
         Constructor<T> c = clazz.getConstructor(double.class);
         return c.newInstance(((DoubleValueCommand) next).getValue().doubleValue());
       } catch (SecurityException e) {
         throw new SerializationException("Cannot construct ValueCommand type",
             e);
       } catch (NoSuchMethodException e) {
         throw new SerializationException("Connot initialize a "
             + clazz.getName() + " from a DoubleValueCommand", e);
       } catch (IllegalArgumentException e) {
         ex = e;
       } catch (InstantiationException e) {
         ex = e;
       } catch (IllegalAccessException e) {
         ex = e;
       } catch (InvocationTargetException e) {
         ex = e;
       }
       throw new SerializationException("Cannot create ValueCommand", ex);
     } else {
       throw new SerializationException(
           "Cannot create a numeric ValueCommand from a "
               + next.getClass().getName());
     }
   }
 }
	/*
	* Copyright 2009 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.rpc.server;

	import com.google.gwt.rpc.client.ast.ArrayValueCommand;
	import com.google.gwt.rpc.client.ast.BooleanValueCommand;
	import com.google.gwt.rpc.client.ast.ByteValueCommand;
	import com.google.gwt.rpc.client.ast.CharValueCommand;
	import com.google.gwt.rpc.client.ast.DoubleValueCommand;
	import com.google.gwt.rpc.client.ast.EnumValueCommand;
	import com.google.gwt.rpc.client.ast.FloatValueCommand;
	import com.google.gwt.rpc.client.ast.IdentityValueCommand;
	import com.google.gwt.rpc.client.ast.InstantiateCommand;
	import com.google.gwt.rpc.client.ast.IntValueCommand;
	import com.google.gwt.rpc.client.ast.InvokeCustomFieldSerializerCommand;
	import com.google.gwt.rpc.client.ast.LongValueCommand;
	import com.google.gwt.rpc.client.ast.NullValueCommand;
	import com.google.gwt.rpc.client.ast.RpcCommandVisitor;
	import com.google.gwt.rpc.client.ast.ScalarValueCommand;
	import com.google.gwt.rpc.client.ast.SetCommand;
	import com.google.gwt.rpc.client.ast.ShortValueCommand;
	import com.google.gwt.rpc.client.ast.StringValueCommand;
	import com.google.gwt.rpc.client.ast.ValueCommand;
	import com.google.gwt.rpc.server.CommandSerializationUtil.Accessor;
	import com.google.gwt.user.client.rpc.SerializationException;
	import com.google.gwt.user.client.rpc.SerializationStreamReader;

	import java.lang.reflect.Array;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Stack;

	/**
	* This class will use ValueCommands to reconstitute objects.
	*/
	public class CommandServerSerializationStreamReader implements
	SerializationStreamReader {

	class Visitor extends RpcCommandVisitor {

	@SuppressWarnings("hiding")
	private final Stack<Object> values = new Stack<Object>();

	@Override
	public void endVisit(BooleanValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(ByteValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(CharValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(DoubleValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(EnumValueCommand x, Context ctx) {
	push(x, x.getValue());
	}

	@Override
	public void endVisit(FloatValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(IntValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(LongValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(NullValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(SetCommand x, Context ctx) {
	Exception ex;
	try {
	Field f = x.getFieldDeclClass().getDeclaredField(x.getField());
	Object value = values.pop();
	Object instance = values.peek();
	assert value == null
	\|\| CommandSerializationUtil.getAccessor(f.getType()).canSet(
	value.getClass()) : "Cannot assign a "
	+ value.getClass().getName() + " into " + f.getType().getName();

	CommandSerializationUtil.getAccessor(f.getType()).set(instance, f,
	value);
	return;
	} catch (SecurityException e) {
	ex = e;
	} catch (NoSuchFieldException e) {
	ex = e;
	}
	halt(new SerializationException("Unable to set field value", ex));
	}

	@Override
	public void endVisit(ShortValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public void endVisit(StringValueCommand x, Context ctx) {
	pushScalar(x);
	}

	@Override
	public boolean visit(ArrayValueCommand x, Context ctx) {
	if (maybePushBackRef(x)) {
	Object array = Array.newInstance(x.getComponentType(),
	x.getComponentValues().size());
	push(x, array);

	int size = x.getComponentValues().size();
	Accessor a = CommandSerializationUtil.getAccessor(x.getComponentType());
	for (int i = 0; i < size; i++) {
	accept(x.getComponentValues().get(i));
	a.set(array, i, values.pop());
	}
	}

	return false;
	}

	@Override
	public boolean visit(InstantiateCommand x, Context ctx) {
	if (maybePushBackRef(x)) {
	Object instance;
	try {
	instance = CommandSerializationUtil.allocateInstance(x.getTargetClass());
	push(x, instance);
	return true;
	} catch (InstantiationException e) {
	halt(new SerializationException("Unable to create instance", e));
	}
	}

	return false;
	}

	@Override
	public boolean visit(InvokeCustomFieldSerializerCommand x, Context ctx) {
	if (maybePushBackRef(x)) {

	CommandServerSerializationStreamReader subReader = new CommandServerSerializationStreamReader(
	backRefs);
	subReader.prepareToRead(x.getValues());

	Class<?> serializerClass = x.getSerializerClass();
	assert serializerClass != null;

	Method instantiate = null;
	Method deserialize = null;
	for (Method m : serializerClass.getMethods()) {
	if ("instantiate".equals(m.getName())) {
	instantiate = m;
	} else if ("deserialize".equals(m.getName())) {
	deserialize = m;
	}

	if (instantiate != null && deserialize != null) {
	break;
	}
	}

	assert deserialize != null : "No deserialize method in "
	+ serializerClass.getName();

	Object instance = null;
	if (instantiate != null) {
	assert Modifier.isStatic(instantiate.getModifiers()) : "instantiate method in "
	+ serializerClass.getName() + " must be static";
	try {
	instance = instantiate.invoke(null, subReader);
	} catch (IllegalArgumentException e) {
	halt(new SerializationException("Unable to create instance", e));
	} catch (IllegalAccessException e) {
	halt(new SerializationException("Unable to create instance", e));
	} catch (InvocationTargetException e) {
	halt(new SerializationException("Unable to create instance", e));
	}
	} else {
	try {
	instance = x.getTargetClass().newInstance();
	} catch (InstantiationException e) {
	halt(new SerializationException("Unable to create instance", e));
	} catch (IllegalAccessException e) {
	halt(new SerializationException("Unable to create instance", e));
	}
	}

	assert instance != null : "Did not create instance";
	push(x, instance);

	// Process any additional fields
	accept(x.getSetters());

	try {
	deserialize.invoke(null, subReader, instance);
	} catch (IllegalArgumentException e) {
	halt(new SerializationException("Unable to deserialize instance", e));
	} catch (IllegalAccessException e) {
	halt(new SerializationException("Unable to deserialize instance", e));
	} catch (InvocationTargetException e) {
	halt(new SerializationException("Unable to deserialize instance", e));
	}
	}

	return false;
	}

	/**
	* Returns true if the command must be processed.
	*/
	private boolean maybePushBackRef(IdentityValueCommand x) {
	Object instance = backRefs.get(x);
	if (instance == null) {
	return true;
	} else {
	values.push(instance);
	return false;
	}
	}

	private void push(IdentityValueCommand x, Object value) {
	assert !backRefs.containsKey(x) : "Trying to redefine a backref";
	backRefs.put(x, value);
	values.push(value);
	}

	private void pushScalar(ScalarValueCommand x) {
	values.push(x.getValue());
	}
	}

	final Map<IdentityValueCommand, Object> backRefs;
	Iterator<ValueCommand> values;

	public CommandServerSerializationStreamReader() {
	this(new HashMap<IdentityValueCommand, Object>());
	}

	private CommandServerSerializationStreamReader(
	Map<IdentityValueCommand, Object> backRefs) {
	this.backRefs = backRefs;
	}

	public void prepareToRead(List<ValueCommand> commands) {
	values = commands.iterator();
	}

	public boolean readBoolean() throws SerializationException {
	return readNumberCommand(BooleanValueCommand.class).getValue();
	}

	public byte readByte() throws SerializationException {
	return readNumberCommand(ByteValueCommand.class).getValue();
	}

	public char readChar() throws SerializationException {
	return readNumberCommand(CharValueCommand.class).getValue();
	}

	public double readDouble() throws SerializationException {
	return readNumberCommand(DoubleValueCommand.class).getValue();
	}

	public float readFloat() throws SerializationException {
	return readNumberCommand(FloatValueCommand.class).getValue();
	}

	public int readInt() throws SerializationException {
	return readNumberCommand(IntValueCommand.class).getValue();
	}

	public long readLong() throws SerializationException {
	return readNumberCommand(LongValueCommand.class).getValue();
	}

	public Object readObject() throws SerializationException {
	ValueCommand command = readNextCommand(ValueCommand.class);
	Visitor v = new Visitor();
	v.accept(command);
	return v.values.pop();
	}

	public short readShort() throws SerializationException {
	return readNumberCommand(ShortValueCommand.class).getValue();
	}

	public String readString() throws SerializationException {
	return (String) readObject();
	}

	private <T extends ValueCommand> T readNextCommand(Class<T> clazz)
	throws SerializationException {
	if (!values.hasNext()) {
	throw new SerializationException("Reached end of stream");
	}
	ValueCommand next = values.next();
	if (!clazz.isInstance(next)) {
	throw new SerializationException("Cannot assign "
	+ next.getClass().getName() + " to " + clazz.getName());
	}
	return clazz.cast(next);
	}

	/**
	* Will perform narrowing conversions from double type to other numeric types.
	*/
	private <T extends ValueCommand> T readNumberCommand(Class<T> clazz)
	throws SerializationException {
	if (!values.hasNext()) {
	throw new SerializationException("Reached end of stream");
	}
	ValueCommand next = values.next();

	if (clazz.isInstance(next)) {
	return clazz.cast(next);
	} else if (next instanceof LongValueCommand) {
	if (!clazz.isInstance(next)) {
	throw new SerializationException("Cannot assign "
	+ next.getClass().getName() + " to " + clazz.getName());
	}
	return clazz.cast(next);
	} else if (next instanceof DoubleValueCommand) {
	Exception ex;
	try {
	Constructor<T> c = clazz.getConstructor(double.class);
	return c.newInstance(((DoubleValueCommand) next).getValue().doubleValue());
	} catch (SecurityException e) {
	throw new SerializationException("Cannot construct ValueCommand type",
	e);
	} catch (NoSuchMethodException e) {
	throw new SerializationException("Connot initialize a "
	+ clazz.getName() + " from a DoubleValueCommand", e);
	} catch (IllegalArgumentException e) {
	ex = e;
	} catch (InstantiationException e) {
	ex = e;
	} catch (IllegalAccessException e) {
	ex = e;
	} catch (InvocationTargetException e) {
	ex = e;
	}
	throw new SerializationException("Cannot create ValueCommand", ex);
	} else {
	throw new SerializationException(
	"Cannot create a numeric ValueCommand from a "
	+ next.getClass().getName());
	}
	}
	}