public Invocation() 
{
   // The variables used to indicate what type of data and where to put it.
   //
   // We are using the generic payload to store some of our data, we define 
   // some integer entries. These are just some variables that we define for 
   // use in "typed" getters and setters. One can define anything either in
   // here explicitely or through the use of external calls to getValue
   //
}

No-args constructor exposed for externalization only.

 public Invocation(Object id,
    Method m,
    Object[] args,
    Transaction tx,
    Principal identity,
    Object credential) 
{
      setId(id);
      setMethod(m);
      setArguments(args);
      setTransaction(tx);
      setPrincipal(identity);
      setCredential(credential);
}

 public Object[] getArguments() 
{
      return this.args;
}

 public Map getAsIsPayload() 
{
      if (as_is_payload == null) as_is_payload = new HashMap();
      return as_is_payload;
}

 public Object getAsIsValue(Object key) 
{
      if (as_is_payload == null) return null;
      return as_is_payload.get(key);
}

 public Object getCredential() 
{
      return getPayloadValue(InvocationKey.CREDENTIAL);
}

 public Object getEnterpriseContext() 
{
      return getTransientPayload().get(InvocationKey.ENTERPRISE_CONTEXT);
}

 public Object getId() 
{
      return getPayloadValue(InvocationKey.CACHE_ID);
}

 public InvocationContext getInvocationContext() 
{
      return invocationContext;
}

 public Method getMethod() 
{
      return method;
}

get on method Return the invocation method.

 public Object getObjectName() 
{
      return objectName;
}

 public Map getPayload() 
{
      if (payload == null) payload = new HashMap();
      return payload;
}

 public Object getPayloadValue(Object key) 
{
      if (payload == null) return null;
      return payload.get(key);
}

 public Principal getPrincipal() 
{
      return (Principal) getAsIsPayload().get(InvocationKey.PRINCIPAL);
}

 public SecurityContext getSecurityContext() 
{
      return (SecurityContext) getAsIsPayload().get(InvocationKey.SECURITY_CONTEXT);
}

 public Transaction getTransaction() 
{
      Transaction tx = (Transaction) getAsIsPayload().get(InvocationKey.TRANSACTION);
      if( tx == null )
         tx = (Transaction) getTransientPayload().get(InvocationKey.TRANSACTION);
      return tx;
}

get the transaction.

 public Map getTransientPayload() 
{
      if (transient_payload == null) transient_payload = new HashMap();
      return transient_payload;
}

 public Object getTransientValue(Object key) 
{
      if (transient_payload == null) return null;
      return transient_payload.get(key);
}

 public InvocationType getType() 
{
      if (invocationType == null) return InvocationType.LOCAL;
      return invocationType;
}

 public Object getValue(Object key) 
{
 
      // find where it is
      Object rtn = getPayloadValue(key);
      if (rtn != null) return rtn;
      rtn = getAsIsValue(key);
      if (rtn != null) return rtn;
      rtn = getTransientValue(key);
      return rtn;
}

Get a value from the stores.

 public boolean isInterVM() 
{
      Boolean b = (Boolean) getAsIsPayload().get(InvocationKey.INTERVM);
      return b != null && b == Boolean.TRUE;
}

 public boolean isLocal() 
{
      InvocationType type = getType();
      return (type == InvocationType.LOCAL || type == InvocationType.LOCALHOME
            || type == InvocationType.SERVICE_ENDPOINT);
}

Helper method to determine whether an invocation is local

 public Boolean isSecure() 
{
      return (Boolean) this.getAsIsPayload().get(InvocationKey.SECURE);
}

Determine whether the invocation arrived on a secure channel

 public Object performCall(Object instance,
    Method m,
    Object[] arguments) throws Exception, IllegalArgumentException, InvocationTargetException, IllegalAccessException 
{
      return m.invoke(instance,arguments);
}

This method will be called by the container(ContainerInterceptor) to issue the ultimate method call represented by this invocation. It is overwritten, e.g., by the WS4EE invocation in order to realize JAXRPC pre- and postprocessing.

 public  void setArguments(Object[] arguments) 
{
      this.args = arguments;
}

A list of arguments for the method.

 public  void setCredential(Object credential) 
{
      getPayload().put(InvocationKey.CREDENTIAL, credential);
}

Change the security credentials of this invocation.

 public  void setEnterpriseContext(Object ctx) 
{
      getTransientPayload().put(InvocationKey.ENTERPRISE_CONTEXT, ctx);
}

 public  void setId(Object id) 
{
      getPayload().put(InvocationKey.CACHE_ID, id);
}

Return the invocation target ID. Can be used to identify a cached object

 public  void setInterVM(Boolean boolValue) 
{
      getAsIsPayload().put(InvocationKey.INTERVM, boolValue);
}

 public  void setInvocationContext(InvocationContext ctx) 
{
      this.invocationContext = ctx;
}

 public  void setMethod(Method method) 
{
      this.method = method;
}

set on method Return the invocation method.

 public  void setObjectName(Object objectName) 
{
      this.objectName = objectName;
}

container for server side association.

 public  void setPrincipal(Principal principal) 
{
      getAsIsPayload().put(InvocationKey.PRINCIPAL, principal);
}

Change the security identity of this invocation.

 public  void setSecure(Boolean secure) 
{
      this.getAsIsPayload().put(InvocationKey.SECURE, secure);
}

Set whether the invocation is secure or not

 public  void setSecurityContext(SecurityContext sc) 
{
      getAsIsPayload().put(InvocationKey.SECURITY_CONTEXT, sc);
}

 public  void setTransaction(Transaction tx) 
{
      if( tx instanceof Serializable )
         getAsIsPayload().put(InvocationKey.TRANSACTION, tx);
      else
         getTransientPayload().put(InvocationKey.TRANSACTION, tx);
}

set the transaction.

 public  void setType(InvocationType type) 
{
      invocationType = type;
}

An arbitrary type.

 public  void setValue(Object key,
    Object value) 
{
      setValue(key, value, PayloadKey.PAYLOAD);
}

The generic store of variables.

The generic getter and setter is really all that one needs to talk to this object. We introduce typed getters and setters for convenience and code readability in the codeba

 public  void setValue(Object key,
    Object value,
    PayloadKey type) 
{
      if(type == PayloadKey.TRANSIENT) 
      {
          getTransientPayload().put(key,value);
      }
      else if(type == PayloadKey.AS_IS)
      {
          getAsIsPayload().put(key,value);
      }
      else if(type == PayloadKey.PAYLOAD)
      {
          getPayload().put(key,value);
      }
      else 
      {
         throw new IllegalArgumentException("Unknown PayloadKey: " + type);
      }
}

Advanced store Here you can pass a TYPE that indicates where to put the value. TRANSIENT: the value is put in a map that WON'T be passed AS_IS: no need to marshall the value when passed (use for all JDK java types) PAYLOAD: we need to marshall the value as its type is application specific