org.eclipse.jem.proxy_2.0.400.v201101101900

pressionID(), (byte)17);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  private void pushToExpressionProxy(ExpressionProxy proxy)
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)16);
      connection.pushInt(proxy.getProxyID());
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  private static class BlockBegin
    extends REMExpression.PendingTransaction
  {
    public int blockNumber;
    
    public BlockBegin(int blockNumber)
    {
      this.blockNumber = blockNumber;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)18);
        connection.pushInt(blockNumber);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushBlockBeginToProxy(int blockNumber)
  {
    addPendingTransaction(new BlockBegin(blockNumber));
  }
  
  protected void pushBlockEndToProxy(int blockNumber)
  {
    PendingTransaction topEntry = getPendingEntryFromTop(1);
    if (((topEntry instanceof BlockBreak)) && (blockNumber == blockNumber))
    {
      popPendingEntry(1);
      topEntry = getPendingEntryFromTop(1);
    }
    if (((topEntry instanceof BlockBegin)) && (blockNumber == blockNumber))
    {
      popPendingEntry(1);
      return;
    }
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)20);
      connection.pushInt(blockNumber);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  private static class BlockBreak
    extends REMExpression.PendingTransaction
  {
    public int blockNumber;
    
    public BlockBreak(int blockNumber)
    {
      this.blockNumber = blockNumber;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)19);
        connection.pushInt(blockNumber);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushBlockBreakToProxy(int blockNumber)
  {
    addPendingTransaction(new BlockBreak(blockNumber));
  }
  
  private static class TryBegin
    extends REMExpression.PendingTransaction
  {
    public final int tryNumber;
    
    public TryBegin(int tryNumber)
    {
      this.tryNumber = tryNumber;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)21);
        connection.pushInt(tryNumber);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushTryBeginToProxy(int tryNumber)
  {
    addPendingTransaction(new TryBegin(tryNumber));
  }
  
  private static class TryCatch
    extends REMExpression.PendingTransaction
  {
    public final int tryNumber;
    private final IProxyBeanType exceptionType;
    private final ExpressionProxy ep;
    
    public TryCatch(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep)
    {
      this.tryNumber = tryNumber;
      this.exceptionType = exceptionType;
      this.ep = ep;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)22);
        connection.pushInt(tryNumber);
        remExpression.fillProxy(exceptionType, workerValue);
        connection.pushValueObject(workerValue);
        if (ep != null) {
          connection.pushInt(ep.getProxyID());
        } else {
          connection.pushInt(-1);
        }
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
      catch (CommandException e)
      {
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        if (!e.isRecoverable())
        {
          connection.close();
          remExpression.throwIllegalStateException(REMExpression.COMMAND_EXCEPTION_MSG);
        }
      }
    }
  }
  
  protected void pushTryCatchClauseToProxy(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep)
  {
    addPendingTransaction(new TryCatch(tryNumber, exceptionType, ep));
  }
  
  private static class TryFinally
    extends REMExpression.PendingTransaction
  {
    public final int tryNumber;
    
    public TryFinally(int tryNumber)
    {
      this.tryNumber = tryNumber;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)23);
        connection.pushInt(tryNumber);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushTryFinallyClauseToProxy(int tryNumber)
  {
    addPendingTransaction(new TryFinally(tryNumber));
  }
  
  protected void pushTryEndToProxy(int tryNumber)
  {
    int fromTop = 0;
    PendingTransaction topEntry;
    do
    {
      do
      {
        topEntry = getPendingEntryFromTop(++fromTop);
        if (!(topEntry instanceof TryFinally)) {
          break;
        }
      } while (tryNumber == tryNumber);
      break label77;
      if (!(topEntry instanceof TryCatch)) {
        break;
      }
    } while (tryNumber == tryNumber);
    break label77;
    if (((topEntry instanceof TryBegin)) && 
      (tryNumber == tryNumber))
    {
      popPendingEntry(fromTop);
      return;
    }
    label77:
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)24);
      connection.pushInt(tryNumber);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushThrowToProxy()
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)25);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushRethrowToProxy(int tryNumber)
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)26);
      connection.pushInt(tryNumber);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushBeanTypeToProxy(IBeanTypeExpressionProxy proxy)
  {
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)13);
      REMBeanTypeExpressionProxy ep = (REMBeanTypeExpressionProxy)proxy;
      connection.pushInt(ep.getProxyID());
      connection.pushString(ep.getTypeName());
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushMethodToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes)
  {
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)27);
      connection.pushInt(proxy.getProxyID());
      fillProxy(declaringType, workerValue);
      connection.pushValueObject(workerValue);
      connection.pushString(methodName);
      if ((parameterTypes == null) || (parameterTypes.length == 0))
      {
        connection.pushInt(0);
      }
      else
      {
        connection.pushInt(parameterTypes.length);
        for (int i = 0; i < parameterTypes.length; i++)
        {
          fillProxy(parameterTypes[i], workerValue);
          connection.pushValueObject(workerValue);
        }
      }
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
    catch (CommandException e)
    {
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      if (!e.isRecoverable())
      {
        connection.close();
        throwIllegalStateException(COMMAND_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushFieldToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String fieldName)
  {
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)28);
      connection.pushInt(proxy.getProxyID());
      fillProxy(declaringType, workerValue);
      connection.pushValueObject(workerValue);
      connection.pushString(fieldName);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
    catch (CommandException e)
    {
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      if (!e.isRecoverable())
      {
        connection.close();
        throwIllegalStateException(COMMAND_EXCEPTION_MSG);
      }
    }
  }
  
  public Map getMethods(IProxyBeanType beanType)
  {
    if (methodsCache == null) {
      methodsCache = new HashMap();
    }
    Map methods = (Map)methodsCache.get(beanType.getTypeName());
    if (methods == null)
    {
      methods = new HashMap(20);
      methodsCache.put(beanType.getTypeName(), methods);
    }
    return methods;
  }
  
  public Map getFields(IProxyBeanType beanType)
  {
    if (fieldsCache == null) {
      fieldsCache = new HashMap();
    }
    Map fields = (Map)fieldsCache.get(beanType.getTypeName());
    if (fields == null)
    {
      fields = new HashMap(20);
      fieldsCache.put(beanType.getTypeName(), fields);
    }
    return fields;
  }
  
  public IProxyBeanType getBeanType(String beanTypeName)
  {
    if (beanTypeCache == null) {
      beanTypeCache = new HashMap();
    }
    return (IProxyBeanType)beanTypeCache.get(beanTypeName);
  }
  
  public void addBeanType(String beanTypeName, IProxyBeanType beantype)
  {
    beanTypeCache.put(beanTypeName, beantype);
  }
  
  public void removeBeanType(String beanTypeName)
  {
    beanTypeCache.remove(beanTypeName);
  }
  
  protected void pushIfTestToProxy()
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)30);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushIfElseToProxy(InternalIfElseOperandType clauseType)
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)29);
      connection.pushByte((byte)clauseType.getValue());
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushNewInstanceToProxy(String initializationString, IProxyBeanType resultType)
  {
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)31);
      connection.pushString(initializationString);
      fillProxy(resultType, workerValue);
      connection.pushValueObject(workerValue);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
    catch (CommandException e)
    {
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      if (!e.isRecoverable())
      {
        connection.close();
        throwIllegalStateException(COMMAND_EXCEPTION_MSG);
      }
    }
  }
  
  private static class Mark
    extends REMExpression.PendingTransaction
  {
    public int markID;
    
    public Mark(int markID)
    {
      this.markID = markID;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)32);
        connection.pushInt(markID);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushMarkToProxy(int markID)
  {
    addPendingTransaction(new Mark(markID));
  }
  
  protected void pushEndmarkToProxy(int markID, boolean restore)
  {
    PendingTransaction topEntry = getPendingEntryFromTop(1);
    if (((topEntry instanceof Mark)) && (markID == markID))
    {
      popPendingEntry(1);
      return;
    }
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)33);
      connection.pushInt(markID);
      connection.pushBoolean(restore);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected void pushBeginTransferThreadToProxy()
    throws ThrowableProxy
  {
    if ((connection != null) && (expressionProcesserController == null))
    {
      IREMExpressionConnection lclConnection = getConnection();
      markInTransaction(lclConnection);
      try
      {
        workerValue.set();
        lclConnection.transferExpression(getREMExpressionID(), workerValue);
        expressionProcesserController = getREMBeanProxyFactory().getBeanProxy(workerValue);
        getREMRegistry().returnConnection(lclConnection);
        connection = null;
      }
      catch (CommandException e)
      {
        ProxyPlugin.getPlugin().getLogger().log(e);
        if (!e.isRecoverable())
        {
          lclConnection.close();
          throwIllegalStateException(COMMAND_EXCEPTION_MSG);
        }
      }
      finally
      {
        markEndTransaction(lclConnection);
      }
    }
  }
  
  protected void pushTransferThreadToProxy() {}
  
  private static class SubexpressionBegin
    extends REMExpression.PendingTransaction
  {
    public int subexpressionNumber;
    
    public SubexpressionBegin(int subexpressionNumber)
    {
      this.subexpressionNumber = subexpressionNumber;
    }
    
    public void pushTransaction(REMExpression remExpression)
    {
      IREMExpressionConnection connection = remExpression.getConnection();
      try
      {
        connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)34);
        connection.pushInt(subexpressionNumber);
      }
      catch (IOException e)
      {
        connection.close();
        ProxyPlugin.getPlugin().getLogger().log(e);
        remExpression.markInvalid(e.getLocalizedMessage());
        remExpression.throwIllegalStateException(REMExpression.IO_EXCEPTION_MSG);
      }
    }
  }
  
  protected void pushSubexpressionBeginToProxy(int subexpressionNumber)
  {
    addPendingTransaction(new SubexpressionBegin(subexpressionNumber));
  }
  
  protected void pushSubexpressionEndToProxy(int subexpressionNumber)
  {
    PendingTransaction topEntry = getPendingEntryFromTop(1);
    if (((topEntry instanceof SubexpressionBegin)) && (subexpressionNumber == subexpressionNumber))
    {
      popPendingEntry(1);
      return;
    }
    processPendingTransactions();
    IREMExpressionConnection connection = getConnection();
    try
    {
      connection.pushExpressionCommand(getREMExpressionID(), (byte)35);
      connection.pushInt(subexpressionNumber);
    }
    catch (IOException e)
    {
      connection.close();
      ProxyPlugin.getPlugin().getLogger().log(e);
      markInvalid(e.getLocalizedMessage());
      throwIllegalStateException(IO_EXCEPTION_MSG);
    }
  }
  
  protected static abstract class PendingTransaction
  {
    public abstract void pushTransaction(REMExpression paramREMExpression);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMExpression
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IFieldProxy;
import org.eclipse.jem.internal.proxy.core.IMethodProxy;
import org.eclipse.jem.internal.proxy.core.ThrowableProxy;

final class REMFieldProxy
  extends REMAccessibleObjectProxy
  implements IFieldProxy
{
  private IBeanTypeProxy fFieldType;
  
  REMFieldProxy(REMProxyFactoryRegistry aRegistry, Integer anID)
  {
    super(aRegistry, anID);
  }
  
  public IBeanTypeProxy getFieldType()
  {
    if (fFieldType == null) {
      fFieldType = 
        ((IBeanTypeProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetType().invokeCatchThrowableExceptions(
        this));
    }
    return fFieldType;
  }
  
  public void release()
  {
    fFieldType = null;
    super.release();
  }
  
  public IBeanProxy get(IBeanProxy subject)
    throws ThrowableProxy
  {
    IBeanTypeProxy fieldType = getFieldType();
    if (!fieldType.isPrimitive()) {
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGet()).invoke(this, subject);
    }
    int id = ((IREMBeanProxy)fieldType).getID().intValue();
    switch (id)
    {
    case 5: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetByte()).invoke(this, subject);
    case 1: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetBoolean()).invoke(
        this, 
        subject);
    case 7: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetChar()).invoke(this, subject);
    case 9: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetDouble()).invoke(
        this, 
        subject);
    case 11: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetFloat()).invoke(
        this, 
        subject);
    case 3: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetInt()).invoke(this, subject);
    case 15: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetLong()).invoke(this, subject);
    case 13: 
      return ((IREMMethodProxy)REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetShort()).invoke(
        this, 
        subject);
    }
    return null;
  }
  
  public void set(IBeanProxy subject, IBeanProxy value)
    throws ThrowableProxy
  {
    REMStandardBeanProxyConstants.getConstants(fFactory).getFieldSet().invoke(this, new IBeanProxy[] { subject, value });
  }
  
  public IBeanTypeProxy getTypeProxy()
  {
    return fFactory.getMethodProxyFactory()).fieldType;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFieldProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import java.lang.reflect.Field;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;

final class REMFieldTypeProxy
  extends REMAbstractBeanTypeProxy
{
  REMFieldTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy accessibleTypeProxy)
  {
    super(aRegistry, new Integer(26), Field.class.getName(), accessibleTypeProxy);
  }
  
  public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract)
  {
    throw new UnsupportedOperationException();
  }
  
  public IREMBeanProxy newBeanProxy(Integer objectID)
  {
    return new REMFieldProxy(fRegistry, objectID);
  }
  
  public IBeanProxy newInstance()
  {
    throw new UnsupportedOperationException();
  }
  
  public IBeanProxy newInstance(String initializationString)
  {
    throw new UnsupportedOperationException();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFieldTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;

class REMFloatClassBeanProxy
  extends REMNumberBeanProxy
{
  REMFloatClassBeanProxy(REMProxyFactoryRegistry aRegistry, Float aFloat)
  {
    super(aRegistry, aFloat);
  }
  
  public IBeanTypeProxy getTypeProxy()
  {
    return fFactory.getBeanTypeProxyFactory()).floatClass;
  }
  
  public void renderBean(Commands.ValueObject value)
  {
    value.set((Float)numberValue());
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFloatClassBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.INumberBeanProxy;

final class REMFloatClassBeanTypeProxy
  extends REMAbstractNumberBeanTypeProxy
{
  private final INumberBeanProxy zeroProxy;
  
  REMFloatClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType)
  {
    super(aRegistry, new Integer(12), Float.class.getName(), numberType);
    
    zeroProxy = new REMFloatClassBeanProxy(aRegistry, new Float(0.0F));
  }
  
  INumberBeanProxy createFloatBeanProxy(Float aFloat)
  {
    return aFloat.floatValue() != 0.0F ? 
      new REMFloatClassBeanProxy(fRegistry, aFloat) : zeroProxy;
  }
  
  protected INumberBeanProxy createNumberBeanProxy(Number aNumber)
  {
    return createFloatBeanProxy((Float)aNumber);
  }
  
  public IBeanProxy newInstance()
  {
    return zeroProxy;
  }
  
  public IBeanProxy newBeanProxy(Commands.ValueObject value)
  {
    return createFloatBeanProxy(new Float(aFloat));
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFloatClassBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.INumberBeanProxy;

class REMFloatTypeBeanProxy
  extends REMConstantBeanProxy
  implements INumberBeanProxy
{
  private final float fFloat;
  
  REMFloatTypeBeanProxy(REMProxyFactoryRegistry aRegistry, float aFloat)
  {
    super(aRegistry);
    fFloat = aFloat;
  }
  
  public boolean equals(Object anObject)
  {
    if (this == anObject) {
      return true;
    }
    if ((anObject instanceof REMFloatTypeBeanProxy)) {
      return fFloat == ((REMFloatTypeBeanProxy)anObject).floatValue();
    }
    if ((anObject instanceof Double)) {
      return fFloat == ((Float)anObject).floatValue();
    }
    return false;
  }
  
  public boolean sameAs(IBeanProxy aBeanProxy)
  {
    if (this == aBeanProxy) {
      return true;
    }
    if ((aBeanProxy instanceof REMFloatTypeBeanProxy)) {
      return fFloat == ((REMFloatTypeBeanProxy)aBeanProxy).floatValue();
    }
    return false;
  }
  
  public byte byteValue()
  {
    return (byte)(int)fFloat;
  }
  
  public double doubleValue()
  {
    return fFloat;
  }
  
  public float floatValue()
  {
    return fFloat;
  }
  
  public int intValue()
  {
    return (int)fFloat;
  }
  
  public long longValue()
  {
    return fFloat;
  }
  
  public Number numberValue()
  {
    return new Float(fFloat);
  }
  
  public short shortValue()
  {
    return (short)(int)fFloat;
  }
  
  public String toBeanString()
  {
    return String.valueOf(fFloat);
  }
  
  public IBeanTypeProxy getTypeProxy()
  {
    return fFactory.getBeanTypeProxyFactory()).floatType;
  }
  
  public void renderBean(Commands.ValueObject value)
  {
    value.set(fFloat);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFloatTypeBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.INumberBeanProxy;
import org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory;
import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
import org.eclipse.jem.internal.proxy.core.ThrowableProxy;

final class REMFloatTypeBeanTypeProxy
  extends REMPrimitiveBeanTypeProxy
{
  private final INumberBeanProxy zeroProxy;
  
  REMFloatTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry)
  {
    super(aRegistry, new Integer(11), Float.TYPE.getName());
    
    zeroProxy = new REMFloatTypeBeanProxy(aRegistry, 0.0F);
  }
  
  INumberBeanProxy createFloatBeanProxy(float aFloat)
  {
    return aFloat != 0.0F ? 
      new REMFloatTypeBeanProxy(fRegistry, aFloat) : zeroProxy;
  }
  
  public IBeanProxy newInstance()
  {
    return zeroProxy;
  }
  
  public IBeanProxy newBeanProxy(Commands.ValueObject value)
  {
    return createFloatBeanProxy(aFloat);
  }
  
  public IBeanProxy newInstance(String initializationString)
    throws ThrowableProxy, ClassCastException, InstantiationException
  {
    String trim = initializationString.trim();
    if (trim.length() == 0) {
      return super.newInstance(initializationString);
    }
    if (trim.startsWith("(float)"))
    {
      Number v = parseString(trim.substring("(float)".length()).trim());
      float aFloat;
      if (v != null) {
        aFloat = v.floatValue();
      } else {
        return super.newInstance(initializationString);
      }
    }
    else
    {
      try
      {
        aFloat = Float.valueOf(initializationString).floatValue();
      }
      catch (NumberFormatException localNumberFormatException)
      {
        float aFloat;
        return super.newInstance(initializationString);
      }
    }
    float aFloat;
    return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aFloat);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMFloatTypeBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IConstructorProxy;
import org.eclipse.jem.internal.proxy.core.IExpression;
import org.eclipse.jem.internal.proxy.core.IFieldProxy;
import org.eclipse.jem.internal.proxy.core.IInvokable;
import org.eclipse.jem.internal.proxy.core.IMethodProxy;
import org.eclipse.jem.internal.proxy.core.IProxyBeanType;
import org.eclipse.jem.internal.proxy.core.IProxyField;
import org.eclipse.jem.internal.proxy.core.IProxyMethod;
import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
import org.eclipse.jem.internal.proxy.core.ThrowableProxy;

public class REMInitErrorBeanTypeProxy
  implements IREMBeanTypeProxy
{
  protected final String initializationError;
  protected final REMProxyFactoryRegistry registry;
  protected final String classname;
  
  public REMInitErrorBeanTypeProxy(REMProxyFactoryRegistry registry, String initializationError, String classname)
  {
    this.registry = registry;
    this.initializationError = initializationError;
    this.classname = classname;
  }
  
  public IREMBeanProxy newBeanProxy(Integer anID)
  {
    return null;
  }
  
  public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract)
  {
    return null;
  }
  
  public IConstructorProxy getConstructorProxy(String[] argumentClassNames)
  {
    return null;
  }
  
  public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IConstructorProxy[] getConstructors()
  {
    return null;
  }
  
  public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames)
  {
    return null;
  }
  
  public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IConstructorProxy[] getDeclaredConstructors()
  {
    return null;
  }
  
  public IFieldProxy[] getFields()
  {
    return null;
  }
  
  public IFieldProxy[] getDeclaredFields()
  {
    return null;
  }
  
  public IFieldProxy getFieldProxy(String fieldName)
  {
    return null;
  }
  
  public IFieldProxy getDeclaredFieldProxy(String fieldName)
  {
    return null;
  }
  
  public IMethodProxy[] getMethods()
  {
    return null;
  }
  
  public IMethodProxy[] getDeclaredMethods()
  {
    return null;
  }
  
  public IMethodProxy getMethodProxy(String methodName)
  {
    return null;
  }
  
  public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames)
  {
    return null;
  }
  
  public IMethodProxy getMethodProxy(String methodName, String argumentClassName)
  {
    return null;
  }
  
  public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames)
  {
    return null;
  }
  
  public IConstructorProxy getNullConstructorProxy()
  {
    return null;
  }
  
  public ProxyFactoryRegistry getProxyFactoryRegistry()
  {
    return registry;
  }
  
  public IBeanTypeProxy getSuperBeanTypeProxy()
  {
    return null;
  }
  
  public String getTypeName()
  {
    return classname;
  }
  
  public String getFormalTypeName()
  {
    return getTypeName();
  }
  
  public boolean isArray()
  {
    return false;
  }
  
  public boolean isInterface()
  {
    return false;
  }
  
  public boolean isPrimitive()
  {
    return false;
  }
  
  public boolean isKindOf(IBeanTypeProxy aBeanProxyType)
  {
    return false;
  }
  
  public IBeanProxy newInstance()
    throws ThrowableProxy
  {
    return null;
  }
  
  public IBeanProxy newInstance(String initializationString)
    throws ThrowableProxy, ClassCastException, InstantiationException
  {
    return null;
  }
  
  public String getInitializationError()
  {
    return initializationError;
  }
  
  public Integer getID()
  {
    return null;
  }
  
  public void release() {}
  
  public void renderBean(Commands.ValueObject renderInto) {}
  
  public IBeanTypeProxy getTypeProxy()
  {
    return null;
  }
  
  public String toBeanString()
  {
    return "";
  }
  
  public boolean isValid()
  {
    return false;
  }
  
  public boolean sameAs(IBeanProxy aBeanProxy)
  {
    return this == aBeanProxy;
  }
  
  public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IInvokable getInvokable(String methodName, String argumentClassName)
  {
    return null;
  }
  
  public IInvokable getInvokable(String methodName, String[] argumentClassNames)
  {
    return null;
  }
  
  public IInvokable getInvokable(String methodName)
  {
    return null;
  }
  
  public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes)
  {
    return null;
  }
  
  public final boolean isBeanProxy()
  {
    return true;
  }
  
  public final boolean isExpressionProxy()
  {
    return false;
  }
  
  public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameters)
  {
    return null;
  }
  
  public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes)
  {
    return null;
  }
  
  public IProxyMethod getMethodProxy(IExpression expression, String methodName)
  {
    return null;
  }
  
  public IProxyField getFieldProxy(IExpression expression, String fieldName)
  {
    return null;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMInitErrorBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;

class REMIntegerClassBeanProxy
  extends REMNumberBeanProxy
  implements IIntegerBeanProxy
{
  REMIntegerClassBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anInteger)
  {
    super(aRegistry, anInteger);
  }
  
  public IBeanTypeProxy getTypeProxy()
  {
    return fFactory.getBeanTypeProxyFactory()).integerClass;
  }
  
  public void renderBean(Commands.ValueObject value)
  {
    value.set((Integer)numberValue());
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMIntegerClassBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;
import org.eclipse.jem.internal.proxy.core.INumberBeanProxy;

final class REMIntegerClassBeanTypeProxy
  extends REMAbstractNumberBeanTypeProxy
{
  private final IIntegerBeanProxy zeroProxy;
  private final IIntegerBeanProxy oneProxy;
  private final IIntegerBeanProxy twoProxy;
  private final IIntegerBeanProxy threeProxy;
  
  REMIntegerClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType)
  {
    super(aRegistry, new Integer(4), Integer.class.getName(), numberType);
    
    zeroProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(0));
    oneProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(1));
    twoProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(2));
    threeProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(3));
  }
  
  IIntegerBeanProxy createIntegerBeanProxy(Integer anInteger)
  {
    switch (anInteger.intValue())
    {
    case 0: 
      return zeroProxy;
    case 1: 
      return oneProxy;
    case 2: 
      return twoProxy;
    case 3: 
      return threeProxy;
    }
    return new REMIntegerClassBeanProxy(fRegistry, anInteger);
  }
  
  protected INumberBeanProxy createNumberBeanProxy(Number aNumber)
  {
    return createIntegerBeanProxy((Integer)aNumber);
  }
  
  public IBeanProxy newInstance()
  {
    return zeroProxy;
  }
  
  public IBeanProxy newBeanProxy(Commands.ValueObject value)
  {
    return createIntegerBeanProxy(new Integer(anInt));
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.remote.REMIntegerClassBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.remote;

import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;

class REMIntegerTypeBeanProxy
  extends REMConstantBeanProxy
  implements IIntegerBeanProxy
{
  private final int fInt;
  
  REMIntegerTypeBeanProxy(REMProxyFactoryRegistry aRegistry, int anInt)
  {
    super(aRegistry);
    fInt = anInt;
  }
  
  public boolean equals(Object anObject)
  {
    if (this == anObject) {
      return true;
    }
    if ((anObject instanceof REMIntegerTypeBeanProxy)) {
      return fInt == ((REMIntegerTypeBeanProxy)anObject).intValue();
    }
    if ((anObject instanceof Integer)) {
      return fInt == ((Integer)anObject).intValue();
    }
    return false;
  }
  
  public boolean sameAs(IBeanProxy aBeanProxy)
  {
    if (this == aBeanProxy) {
      return true;
    }
    if ((aBeanProxy instanceof REMIntegerTypeBeanProxy)) {
      return fInt == ((REMIntegerTypeBeanProxy)aBeanProxy).intValue();
    }
    return false;
  }
  
  public byte byteValue()
  {
    return (byte)fInt;
  }
  
  public double doubleValue()
  {
    return fInt;
  }
  
  public float floatValue()
  {
    return fInt;
  }
  
  public int intValue()
  {
    return fInt;
  }
  
  public long longValue()
  {
    return fInt;
  }
  
  public Number numberValue()
 
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd