/*******************************************************************************
* Copyright (c) 2001, 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.remote;
/*
*/
import java.lang.reflect.Array;
import java.util.logging.Level;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jem.internal.proxy.common.CommandException;
import org.eclipse.jem.internal.proxy.common.remote.CommandErrorException;
import org.eclipse.jem.internal.proxy.common.remote.Commands;
import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.*;
/**
* IDE VM version of the Array proxy
*/
public final class REMArrayBeanProxy extends REMBeanProxy implements IArrayBeanProxy {
private int fLength = -1;
REMArrayBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType) {
super(aRegistry, anID, aType);
}
public boolean equals(Object anObject) {
if (!(anObject instanceof IArrayBeanProxy))
return false;
if (sameAs((IBeanProxy) anObject))
return true; // Identity
if (((IBeanProxy) anObject).getProxyFactoryRegistry() == fFactory)
try {
// The other is an array also, let the server do the check. We will use Arrays.equals.
return ((IBooleanBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperEquals().invoke(null, new IBeanProxy[] {this, (IBeanProxy) anObject})).booleanValue();
} catch (ThrowableProxy e) {
ProxyPlugin.getPlugin().getLogger().log(e, Level.INFO);
}
return false;
}
/**
* Get the object at the specified index.
*/
public IBeanProxy get(int index) throws ThrowableProxy {
// Format of getter parms is: (Object (array), int (index)).
Object[] parms = new Object[] {this, new Integer(index)};
// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
IBeanTypeProxy compType = ((IArrayBeanTypeProxy) getTypeProxy()).getComponentType();
if (!compType.isPrimitive()) {
// Use standard getter.
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGet()).invokeWithParms(null, parms);
} else {
// Use the correct primitive getter.
int id = ((IREMBeanProxy) compType).getID().intValue();
switch (id) {
case Commands.BYTE_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetByte()).invokeWithParms(null, parms);
case Commands.BOOLEAN_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetBoolean()).invokeWithParms(null, parms);
case Commands.CHARACTER_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetChar()).invokeWithParms(null, parms);
case Commands.DOUBLE_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetDouble()).invokeWithParms(null, parms);
case Commands.FLOAT_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetFloat()).invokeWithParms(null, parms);
case Commands.INTEGER_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetInt()).invokeWithParms(null, parms);
case Commands.LONG_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetLong()).invokeWithParms(null, parms);
case Commands.SHORT_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetShort()).invokeWithParms(null, parms);
}
}
return null;
}
/**
* Get the object at the specified multi-dimensional index.
* The array must be at least the number of dimensions specified,
* and each index along the way must exist.
* The number of dimensions can't be greater than the number
* of dimensions of the real object.
*/
public IBeanProxy get(int [] indexes) throws ThrowableProxy {
// Format of getter parms is: (Object (array), int[] (indexes)).
Object[] parms = new Object[] {this, indexes};
// If the component type at the specified dimension is primitive, we need to use the correct getter so that a valid value is returned,
// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
int dims = ((IArrayBeanTypeProxy) getTypeProxy()).getDimensions();
if (dims < indexes.length)
throw new IllegalArgumentException(); // Too many dimensions
IBeanTypeProxy finalCompType = ((IArrayBeanTypeProxy) getTypeProxy()).getFinalComponentType();
if (dims == indexes.length && finalCompType.isPrimitive()) {
// Use the correct primitive getter because we are accessing the final component and it is primitive.
int id = ((IREMBeanProxy) finalCompType).getID().intValue();
switch (id) {
case Commands.BYTE_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetByte()).invokeWithParms(null, parms);
case Commands.BOOLEAN_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetBoolean()).invokeWithParms(null, parms);
case Commands.CHARACTER_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetChar()).invokeWithParms(null, parms);
case Commands.DOUBLE_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetDouble()).invokeWithParms(null, parms);
case Commands.FLOAT_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetFloat()).invokeWithParms(null, parms);
case Commands.INTEGER_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetInt()).invokeWithParms(null, parms);
case Commands.LONG_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetLong()).invokeWithParms(null, parms);
case Commands.SHORT_TYPE:
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetShort()).invokeWithParms(null, parms);
}
} else {
// It is not the final component, or it is not primitive, use the standard accessor.
return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGet()).invokeWithParms(null, parms);
}
return null;
}
/**
* Set the object at the specified index.
*/
public void set(IBeanProxy value, int index) throws ThrowableProxy {
// Format of setter parms is: (Object (array), int (index), Object (value)).
Object[] parms = new Object[] {this, new Integer(index), value};
((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArraySet()).invokeWithParms(null, parms);
}
/**
* Set the object at the specified multi-dimensional index.
* The array must be at least the number of dimensions specified,
* and each index along the way must exist.
* The number of dimensions can't be greater than the number
* of dimensions of the real object.
*/
public void set(IBeanProxy value, int [] indexes) throws ThrowableProxy {
// Format of setter parms is: (Object (array), int[] (indexes), Object (value)).
Object[] parms = new Object[] {this, indexes, value};
((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperSet()).invokeWithParms(null, parms);
}
/**
* Get the length of the first dimension of this array.
* If there are multi-dimensions, you must get the appropriate
* dimension from the get method to see the size of that dimension.
*
* e.g.
* int [3] returns 3
* int [3][2] returns 3
*
* ((IArrayBeanProxy) get(1)).getLength() returns 2
* Since arrays do not have to be homogenous, there could
* be a different length array for each of the arrays
* returned from the first dimension, the returned length
* from get(2) and get(3) could result in a different value
* from get(1).
*/
public int getLength() {
if (fLength == -1) {
// It hasn't yet been quiered.
fLength = ((IIntegerBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetLength().invokeCatchThrowableExceptions(null, this)).intValue();
}
return fLength;
}
public IBeanProxy getCatchThrowableException(int index){
try {
return get(index);
} catch (ThrowableProxy e) {
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
return null;
}
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IArrayBeanProxy#getSnapshot()
*/
public IBeanProxy[] getSnapshot() throws ThrowableProxy {
IREMConnection connect = fFactory.getFreeConnection();
REMStandardBeanProxyFactory proxyFactory = (REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory();
proxyFactory.startTransaction(); // This is definately a transaction, so start it.
try {
Commands.ValueObject returnValue = new Commands.ValueObject();
try {
try {
connect.getArrayContents(getID().intValue(), returnValue);
return processReturnValue(connect, returnValue);
} catch (CommandErrorException e) {
proxyFactory.processErrorReturn(e);
}
} catch (CommandException e) {
if (!e.isRecoverable()) {
// Close the connection and try again.
fFactory.closeConnection(connect);
connect = null;
connect = fFactory.getFreeConnection();
try {
connect.getArrayContents(getID().intValue(), returnValue);
return processReturnValue(connect, returnValue);
} catch (CommandException eAgain) {
// Failed again. Just close and print trace.
fFactory.closeConnection(connect);
connect = null;
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
return null;
}
} else {
// A recoverable error, print trace and return
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
return null;
}
}
} finally {
proxyFactory.stopTransaction();
if (connect != null)
fFactory.returnConnection(connect);
}
return null;
}
/*
* @param returnValue
* @return
*
* @since 1.1.0
*/
private IBeanProxy[] processReturnValue(IREMConnection connection, ValueObject returnValue) throws CommandException, ThrowableProxy {
// It is an array containing IDs, as it normally would be.
// However it will become IBeanProxy[]. That is because if ID's
// they must be proxies over here.
BeanProxyValueSender valueSender = new BeanProxyValueSender((REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory(), returnValue);
connection.readProxyArrayValues(returnValue, valueSender, false);
Exception e = valueSender.getException();
if (e != null) {
if (e instanceof ThrowableProxy)
throw (ThrowableProxy) e;
else
throw (CommandException) e;
}
Object vals = valueSender.getArray();
IBeanProxy[] proxyArray = new IBeanProxy[Array.getLength(vals)];
System.arraycopy(vals, 0, proxyArray, 0, proxyArray.length);
return proxyArray;
}
}