/*******************************************************************************
* Copyright (c) 2004, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
/*
*/
package org.eclipse.jem.internal.proxy.vm.remote;
import java.io.DataInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import org.eclipse.jem.internal.proxy.common.*;
import org.eclipse.jem.internal.proxy.common.remote.Commands;
import org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands;
import org.eclipse.jem.internal.proxy.initParser.tree.*;
/**
* This processes the commands for expression processing and sends them over
* to the common expression processer.
*
* This will be instantiated on the start of an expression. And then
* each expression request from the IDE will be sent into here. The
* reason this guy doesn't hold onto the connection and process the
* entire expression is because we need to return to the connection
* handler to keep the connection live (there is timeouts and stuff
* in there that we don't want to duplicate here).
* <p>
* If there are any expression processing errors (versus hard io errors) we
* will save up the error but don't do any more processing other than to make
* sure we read the complete subcommand. This is so that the inputstream is left
* in a valid state without standed data.
* <p>
* The at the sync point (either get value or sync subcommand) we will send back
* the error.
*
* @since 1.0.0
*/
public class ExpressionProcesserController {
protected final RemoteVMServerThread server;
protected final ConnectionHandler connHandler;
protected final ExpressionProcesser exp;
protected Commands.ValueObject workerValue = new Commands.ValueObject(); // A worker value object so we don't need to keep creating them and releasing them.
private ClassLoader classLoader;
/**
* Create with a default expression processer and use default flag for trace.
* @param server
*
* @since 1.0.0
*/
public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler) {
this(server, connHandler, new ExpressionProcesser(Boolean.getBoolean(ExpressionCommands.EXPRESSIONTRACE), Long.getLong(ExpressionCommands.EXPRESSIONTRACE_TIMER_THRESHOLD, -1L).longValue()));
}
/**
* Construct with a default expression processer.
* @param server
* @param connHandler
* @param trace
*
* @since 1.1.0
*/
public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, boolean trace) {
this(server, connHandler, new ExpressionProcesser(trace, Long.getLong(ExpressionCommands.EXPRESSIONTRACE_TIMER_THRESHOLD, -1L).longValue()));
}
/**
* Create from a subclass with a given expression processer.
*
* @param server
* @param exp
*
* @since 1.0.0
*/
protected ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, ExpressionProcesser exp) {
this.server = server;
this.connHandler = connHandler;
this.exp = exp;
}
/**
* Set the class loader to use for finding classes. If never set, or if <code>null</code>, then
* <code>Class.forName</code> will be used.
*
* @param classLoader
*
* @since 1.0.0
*/
public void setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
/*
* Array of primitive type names. Used to look up primtive types in primitive types array.
*
* @since 1.0.0
*/
private static final List PRIMITIVE_NAMES = Arrays.asList(new String[] {"byte", "char", "short", "int", "long", "float", "double"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
private static final Class[] PRIMITIVE_TYPES = new Class[] {Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
/**
* Load the class given the name. If not found, return null.
*
* @param className
* @return
*
* @since 1.0.0
*/
protected Class loadClass(String className) throws ClassNotFoundException {
if (className == null)
return null;
else if (className.endsWith("[]")) { //$NON-NLS-1$
// We have an array request instead. This is trickier.
return loadClass(MapTypes.getJNIFormatName(className));
} else {
int primIndex = PRIMITIVE_NAMES.indexOf(className);
if (primIndex >= 0)
return PRIMITIVE_TYPES[primIndex];
else if (classLoader == null) {
return Class.forName(className);
} else {
return classLoader.loadClass(className);
}
}
}
/**
* Now process the input stream. If either throws occurs, this is a hard error and we must terminate
* the entire connection. The input stream is in an unknown state.
*
* @param in The input stream to get the data for the current sub-command.
*
* @throws CommandException
* @throws IOException
* @since 1.0.0
*/
public void process(DataInputStream in) throws CommandException, IOException {
// In the following subcommand processing, we always read the entire subcommand from the stream.
// This is so that any errors during processing will not mess up the stream with unread data.
//
// Then we check if an error has occurred in the past. If it has, we simply break. This is because
// once an error occurred we don't want to continue wasting time evaluating, however we need to make
// sure that the stream is read completely so that we don't have a corrupted input stream. That way
// when all is done we can return the error and still have a valid connection socket.
byte subcommand = in.readByte();
try {
switch (subcommand) {
case InternalExpressionTypes.PUSH_TO_PROXY_EXPRESSION_VALUE:
// Getting a proxy push. The value is sent as valueObject, so use that to read it in.
Commands.readValue(in, workerValue);
Object value = connHandler.getInvokableObject(workerValue);
if (value == null)
exp.pushExpression(null, MethodHelper.NULL_TYPE);
else if (workerValue.isPrimitive())
exp.pushExpression(value, workerValue.getPrimitiveType());
else
exp.pushExpression(value, value.getClass());
break;
case InternalExpressionTypes.CAST_EXPRESSION_VALUE:
// Get a cast request. The type is sent as valueObject.
Commands.readValue(in, workerValue);
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushCast(classValue);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.INSTANCEOF_EXPRESSION_VALUE:
// Get a instanceof request. The type is sent as valueObject.
Commands.readValue(in, workerValue);
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushInstanceof(classValue);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.INFIX_EXPRESSION_VALUE:
// Get an infix request. The operator and operand type are sent as bytes.
byte infix_operator = in.readByte();
byte infix_operandType = in.readByte();
exp.pushInfix(InfixOperator.get(infix_operator), InternalInfixOperandType.get(infix_operandType));
break;
case InternalExpressionTypes.PREFIX_EXPRESSION_VALUE:
// Get a prefix request. The operator is sent as byte.
byte prefix_operandType = in.readByte();
exp.pushPrefix(PrefixOperator.get(prefix_operandType));
break;
case InternalExpressionTypes.ARRAY_ACCESS_EXPRESSION_VALUE:
// Get an array access request. The index cound is sent as int.
int arrayAccess_Indexcount = in.readInt();
exp.pushArrayAccess(arrayAccess_Indexcount);
break;
case InternalExpressionTypes.ARRAY_CREATION_EXPRESSION_VALUE:
// Get an array creation request. The type is sent as valueObject, followed by int dimension count.
Commands.readValue(in, workerValue);
int arrayCreation_dimCount = in.readInt();
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushArrayCreation(classValue, arrayCreation_dimCount);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION_VALUE:
// Get an array initializer request. The type is sent as valueObject, followed by int expression count.
Commands.readValue(in, workerValue);
int stripCount = in.readInt();
int arrayInitializer_expressionCount = in.readInt();
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushArrayInitializer(classValue, stripCount, arrayInitializer_expressionCount);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.CLASS_INSTANCE_CREATION_EXPRESSION_VALUE:
// Get a class instance creation request. The type is sent as valueObject, followed by int argument count.
Commands.readValue(in, workerValue);
int newInstance_argCount = in.readInt();
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushClassInstanceCreation(classValue, newInstance_argCount);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.TYPERECEIVER_EXPRESSION_VALUE:
// Get a type receiver request. The type is sent as valueObject.
Commands.readValue(in, workerValue);
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushExpression(classValue, classValue);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.FIELD_ACCESS_EXPRESSION_VALUE:
// Get a field access request. Command.ValueObject, followed by hasReceiver as boolean.
Commands.readValue(in, workerValue);
boolean has_fieldAccess_receiver = in.readBoolean();
try {
Object fieldAccess = getFieldValue(workerValue);
exp.pushFieldAccess(fieldAccess, workerValue.getType() == Commands.STRING, has_fieldAccess_receiver);
} catch (ClassCastException e) {
exp.processException(e); // Let the processor know we have a stopping error.
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.METHOD_EXPRESSION_VALUE:
// Get a method invocation request. Sent as Commands.ValueObject, followed by hasReceiver as boolean., and argCount as int.
Commands.readValue(in, workerValue);
boolean has_method_receiver = in.readBoolean();
int method_argCount = in.readInt();
try {
Object method = getMethodValue(workerValue);
exp.pushMethodInvocation(method, workerValue.getType() == Commands.STRING, has_method_receiver, method_argCount);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.CONDITIONAL_EXPRESSION_VALUE:
// Get a conditional expression request. The expression type (ie. condition/true/false) is sent as a byte
exp.pushConditional(InternalConditionalOperandType.get(in.readByte()));
break;
case InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION_VALUE:
// Get an assignment expression request. The proxy id is sent as an int.
int proxyid = in.readInt();
exp.pushAssignment(new RemoteExpressionProxy(proxyid));
break;
case InternalExpressionTypes.ASSIGNMENT_EXPRESSION_VALUE:
// Get an assignment expression request. Nothing else to read from stream.
exp.pushAssignment();
break;
case InternalExpressionTypes.PUSH_TO_EXPRESSION_PROXY_EXPRESSION_VALUE:
// Get a push expression proxy expression. The proxy id is sent as an int.
// First test if a possible FailedExpressionProxy because we could of been pushing
// a failed reflection proxy.
proxyid = in.readInt();
try {
exp.getExpressionProxy(proxyid, new Object[] {null, null});
} catch (NoExpressionValueException e1) {
if (e1.getProxy() != null) {
FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e1.getProxy();
exp.processException((Throwable) failure.getValue());
break; // Don't go on, we processed it. A standard no expression value should be passed on and let following code handle it.
}
}
exp.pushExpressionProxy(proxyid);
break;
case InternalExpressionTypes.BLOCK_BEGIN_EXPRESSION_VALUE:
// Get a begin block proxy expression. The block id is sent as an int.
exp.pushBlockBegin(in.readInt());
break;
case InternalExpressionTypes.BLOCK_BREAK_EXPRESSION_VALUE:
// Get a break block proxy expression. The block id is sent as an int.
exp.pushBlockBreak(in.readInt());
break;
case InternalExpressionTypes.BLOCK_END_EXPRESSION_VALUE:
// Get a end block proxy expression. The block id is sent as an int.
exp.pushBlockEnd(in.readInt());
break;
case InternalExpressionTypes.TRY_BEGIN_EXPRESSION_VALUE:
// Get a try begin proxy expression. The try id is sent as an int.
exp.pushTryBegin(in.readInt());
break;
case InternalExpressionTypes.TRY_CATCH_EXPRESSION_VALUE:
int tryNumber = in.readInt();
Commands.readValue(in, workerValue);
proxyid = in.readInt();
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushTryCatchClause(tryNumber, classValue, proxyid != -1 ? new RemoteExpressionProxy(proxyid) : null);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.TRY_FINALLY_EXPRESSION_VALUE:
// Get a try finally proxy expression. The try id is sent as an int.
exp.pushTryFinallyClause(in.readInt());
break;
case InternalExpressionTypes.TRY_END_EXPRESSION_VALUE:
// Get a try end proxy expression. The try id is sent as an int.
exp.pushTryEnd(in.readInt());
break;
case InternalExpressionTypes.THROW_EXPRESSION_VALUE:
exp.pushThrowException();
break;
case InternalExpressionTypes.RETHROW_EXPRESSION_VALUE:
// Get a rethrow proxy expression. The try id is sent as an int.
exp.pushTryRethrow(in.readInt());
break;
case InternalExpressionTypes.PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION_VALUE:
// Get the beantype expression proxy and resolve it.
proxyid = in.readInt();
String typeName = Commands.readStringData(in);
try {
Class classValue = loadClass(typeName);
RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
rep.setProxy(classValue, Class.class);
exp.allocateExpressionProxy(rep);
} catch (ClassNotFoundException e) {
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(e, e.getClass());
exp.allocateExpressionProxy(rep);
} catch (LinkageError e) {
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(e, e.getClass());
exp.allocateExpressionProxy(rep);
}
break;
case InternalExpressionTypes.PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION_VALUE:
// Get the Method expression proxy and resolve it.
// Comes over as:
// int for proxy id for the method
// beanTypeValue for declaring class (either beantype or expression proxy)
// string for method name
// int for arg count
// beanTypeValue(s) for arg types (as many as arg count).
proxyid = in.readInt();
Commands.ValueObject decClassValue = Commands.readValue(in, new Commands.ValueObject());
String methodName = Commands.readStringData(in);
int argCount = in.readInt();
Commands.ValueObject[] args = null;
if (argCount > 0) {
args = new Commands.ValueObject[argCount];
for (int i = 0; i < argCount; i++) {
args[i] = Commands.readValue(in, new Commands.ValueObject());
}
}
Class decClass = null;
Class[] argClasses = null;
try {
decClass = getBeanTypeValue(decClassValue);
argClasses = null;
if (argCount>0) {
argClasses = new Class[argCount];
for (int i = 0; i < argCount; i++) {
argClasses[i] = getBeanTypeValue(args[i]);
}
}
// Now get the method itself.
Method m = decClass.getMethod(methodName, argClasses);
RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
rep.setProxy(m, Method.class);
exp.allocateExpressionProxy(rep);
} catch (FailedProxyException e) {
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(e.getCause(), e.getCause().getClass());
exp.allocateExpressionProxy(rep);
} catch (NoSuchMethodException e) {
// The default trace doesn't show what method was being searched for, so recreate with that.
StringBuffer s = new StringBuffer();
s.append(decClass.getName());
s.append('.');
s.append(methodName);
s.append('(');
if (argClasses != null) {
for (int i = 0; i < argClasses.length; i++) {
if (i > 0)
s.append(',');
s.append(argClasses[i].getName());
}
}
s.append(')');
NoSuchMethodException ne = new NoSuchMethodException(s.toString());
ne.setStackTrace(e.getStackTrace());
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(ne, ne.getClass());
exp.allocateExpressionProxy(rep);
}
break;
case InternalExpressionTypes.PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION_VALUE:
// Get the Filed expression proxy and resolve it.
// Comes over as:
// int for proxy id for the field
// beanTypeValue for declaring class (either beantype or expression proxy)
// string for field name
proxyid = in.readInt();
decClassValue = Commands.readValue(in, new Commands.ValueObject());
String fieldName = Commands.readStringData(in);
try {
decClass = getBeanTypeValue(decClassValue);
// Now get the field itself.
Field f = decClass.getField(fieldName);
RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
rep.setProxy(f, Method.class);
exp.allocateExpressionProxy(rep);
} catch (FailedProxyException e) {
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(e.getCause(), e.getCause().getClass());
exp.allocateExpressionProxy(rep);
} catch (NoSuchFieldException e) {
FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
rep.setProxy(e, e.getClass());
exp.allocateExpressionProxy(rep);
}
break;
case InternalExpressionTypes.IF_TEST_EXPRESSION_VALUE:
// Get a if test expression request.
exp.pushIfElse();
break;
case InternalExpressionTypes.IF_ELSE_EXPRESSION_VALUE:
// Get a if/else expression clause request. The clause type (ie. true/false) is sent as a byte
exp.pushIfElse(InternalIfElseOperandType.get(in.readByte()));
break;
case InternalExpressionTypes.NEW_INSTANCE_VALUE:
// Get a new instance from string.
String initString = Commands.readStringData(in);
workerValue = Commands.readValue(in, new Commands.ValueObject());
try {
Class classValue = getBeanTypeValue(workerValue);
exp.pushNewInstanceFromString(initString, classValue, classLoader);
} catch (FailedProxyException e) {
exp.processException(e.getCause()); // Let the processor know we have a stopping error.
}
break;
case InternalExpressionTypes.MARK_VALUE:
// Do a mark.
int markID = in.readInt();
exp.pushMark(markID);
break;
case InternalExpressionTypes.ENDMARK_VALUE:
// Do an end mark.
markID = in.readInt();
boolean restore = in.readBoolean();
exp.pushEndmark(markID, restore);
break;
case InternalExpressionTypes.SUBEXPRESSION_BEGIN_EXPRESSION_VALUE:
// Get a begin subexpression proxy expression. The subexpression id is sent as an int.
exp.pushSubexpressionBegin(in.readInt());
break;
case InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION_VALUE:
// Get a end subexpression proxy expression. The subexpression id is sent as an int.
exp.pushSubexpressionEnd(in.readInt());
break;
}
} catch (RuntimeException e) {
exp.processException(e);
}
workerValue.set(); // Clear it out so nothing being held onto.
}
/**
* This is an exception that is thrown from the getBeanType, field, method (reflect type stuff)
* that wrappers the real throwable that occurred during the previous reflection. This is
* because reflection is done out of sequence with the use of the reflect value. So we need
* to store the reflection exception in this exception and then store this exception in
* a {@link FailedRemoteExpressionProxy}. This will then be picked up when trying to be
* used and it will get the true exception out of the {@link Throwable#getCause()}.
*
* @since 1.1.0
*/
private static class FailedProxyException extends Exception {
/**
* Comment for <code>serialVersionUID</code>
*
* @since 1.1.0
*/
private static final long serialVersionUID = 2872325672166348923L;
public FailedProxyException(Throwable realThrowable) {
super(realThrowable);
}
}
/**
* Get the beantype (class) out of the value object sent in. It can handle the beantype sent or
* as an expression proxy to a beantype expression proxy.
*
* @param value
* @return
* @throws FailedProxyException Wrappers the real throwable that caused the bean type to not be found.
*
* @since 1.1.0
*/
protected Class getBeanTypeValue(Commands.ValueObject value) throws FailedProxyException {
Object beantype = connHandler.getInvokableObject(value);
// It is either a type directly or is an expression proxy.
if (value.type == Commands.INT) {
// It is an expression proxy request.
Object[] expvalue = new Object[2];
try {
exp.getExpressionProxy(((Integer) beantype).intValue(), expvalue);
beantype = expvalue[0];
} catch (NoExpressionValueException e) {
// See if there is a failed proxy.
if (e.getProxy() != null) {
FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
throw new FailedProxyException((Throwable) failure.getValue());
} else
throw new FailedProxyException(new ClassNotFoundException()); // This shouldn't of occurred.
}
}
return (Class) beantype;
}
/**
* Get the method out of the value object sent in. It can handle the method sent or
* as an expression proxy to a method expression proxy.
* @param value
* @return method if a method or string if a string or get the method if an expression proxy.
* @throws FailedProxyException Wrappers the real Throwable that caused the method to not be found.
*
* @since 1.1.0
*/
protected Object getMethodValue(Commands.ValueObject value) throws FailedProxyException {
Object method = connHandler.getInvokableObject(value);
// It is either a method directly or is an expression proxy.
if (value.type == Commands.INT) {
// It is an expression proxy request.
Object[] expvalue = new Object[2];
try {
exp.getExpressionProxy(((Integer) method).intValue(), expvalue);
method = expvalue[0];
} catch (NoExpressionValueException e) {
// See if there is a failed proxy.
if (e.getProxy() != null) {
FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
throw new FailedProxyException((Throwable) failure.getValue());
} else
throw new FailedProxyException(new NoSuchMethodException()); // This shouldn't of occurred.
}
}
return method;
}
/**
* Get the field out of the value object sent in. It can handle the field sent or
* as an expression proxy to a field expression proxy.
* @param value
* @return field if a field or string if a string or get the field if an expression proxy.
* @throws FailedProxyException Wrappers the real throwable that caused the field to not be found.
*
* @since 1.1.0
*/
protected Object getFieldValue(Commands.ValueObject value) throws FailedProxyException {
Object field = connHandler.getInvokableObject(value);
// It is either a field directly or is an expression proxy.
if (value.type == Commands.INT) {
// It is an expression proxy request.
Object[] expvalue = new Object[2];
try {
exp.getExpressionProxy(((Integer) field).intValue(), expvalue);
field = expvalue[0];
} catch (NoExpressionValueException e) {
// See if there is a failed proxy.
if (e.getProxy() != null) {
FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
throw new FailedProxyException((Throwable) failure.getValue());
} else
throw new FailedProxyException(new NoSuchFieldException()); // This shouldn't of occurred.
}
}
return field;
}
/**
* Pull the Expression Proxy value into the result object.
* @param proxyID
* @param result
* @return <code>true</code> if value could be returned, <code>false</code> if it was no expression value assigned.
*
* @since 1.1.0
*/
public boolean pullExpressionProxyValue(int proxyID, Object[] result) {
try {
exp.pullExpressionProxyValue(proxyID, result);
return true;
} catch (NoExpressionValueException e) {
}
return false;
}
private static class RemoteExpressionProxy implements InternalExpressionProxy {
private final int proxyID;
private Object value;
private Class type;
private boolean set;
public RemoteExpressionProxy(int proxyID) {
this.proxyID = proxyID;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getProxyID()
*/
public int getProxyID() {
return proxyID;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getType()
*/
public Class getType() {
return type;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getValue()
*/
public Object getValue() {
return value;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#isSet()
*/
public boolean isSet() {
return set;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#setProxy(java.lang.Object, java.lang.Class)
*/
public void setProxy(Object value, Class type) {
this.value = value;
this.type = type;
set = true;
}
}
/**
* Used for the java.lang.reflect things (class, field, method) to indicate
* why they aren't found.
* <p>
* The exception will be placed into value, BUT this should never be sent
* back to the caller. It is intended only as a place-holder for subsequent
* usage. Use the {@link RemoteExpressionProxy#isFailedExpression()} method
* to determine if it is a failed one.
* <p>
* This is used because the reflect calls are done out of sequence from where
* they are used and so if there was an error, the error is reported in the
* wrong place.
*
* @since 1.1.0
*/
private static class FailedRemoteExpressionProxy extends RemoteExpressionProxy {
public FailedRemoteExpressionProxy(int proxyID) {
super(proxyID);
}
public boolean isSet() {
return false; // This should never be considered to be set. It is holder of info only.
}
}
/**
* Pull the value.
*
* @return r[0] is the value, r[1] is the type of the value.
* @throws NoExpressionValueException
*
* @since 1.0.0
*/
public Object[] pullValue() throws NoExpressionValueException {
Object[] result = new Object[2];
exp.pullValue(result);
return result;
}
/**
* Close out things.
*
* @since 1.0.0
*/
public void close() {
exp.close();
}
/**
* Get the throwable error.
* @return
*
* @since 1.1.0
*/
public Throwable getErrorThrowable() {
return exp.getErrorThrowable();
}
/**
* Return whether there were no errors or not.
* @return
*
* @since 1.1.0
*/
public boolean noErrors() {
return exp.noErrors();
}
/**
* Return whether there is a no expression value exception or not.
* @return
*
* @since 1.1.0
*/
public boolean isNoExpressionValue() {
return exp.isNoExpressionValue();
}
}