/*
* 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());
}
}
}