public ActionChainResult() 
{
        super();
}

 public ActionChainResult(String namespace,
    String actionName,
    String methodName) 
{
        this.namespace = namespace;
        this.actionName = actionName;
        this.methodName = methodName;
}

 public ActionChainResult(String namespace,
    String actionName,
    String methodName,
    String skipActions) 
{
        this.namespace = namespace;
        this.actionName = actionName;
        this.methodName = methodName;
        this.skipActions = skipActions;
}

 public boolean equals(Object o) 
{
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        final ActionChainResult that = (ActionChainResult) o;
        if (actionName != null ? !actionName.equals(that.actionName) : that.actionName != null) return false;
        if (methodName != null ? !methodName.equals(that.methodName) : that.methodName != null) return false;
        if (namespace != null ? !namespace.equals(that.namespace) : that.namespace != null) return false;
        return true;
}

 public  void execute(ActionInvocation invocation) throws Exception 
{
        // if the finalNamespace wasn't explicitly defined, assume the current one
        if (this.namespace == null) {
            this.namespace = invocation.getProxy().getNamespace();
        }
        ValueStack stack = ActionContext.getContext().getValueStack();
        String finalNamespace = TextParseUtil.translateVariables(namespace, stack);
        String finalActionName = TextParseUtil.translateVariables(actionName, stack);
        String finalMethodName = this.methodName != null
                ? TextParseUtil.translateVariables(this.methodName, stack)
                : null;
        if (isInChainHistory(finalNamespace, finalActionName, finalMethodName)) {
            addToHistory(finalNamespace, finalActionName, finalMethodName);
            throw new XWorkException("Infinite recursion detected: "
                    + ActionChainResult.getChainHistory().toString());
        }
        if (ActionChainResult.getChainHistory().isEmpty() && invocation != null && invocation.getProxy() != null) {
            addToHistory(finalNamespace, invocation.getProxy().getActionName(), invocation.getProxy().getMethod());
        }
        addToHistory(finalNamespace, finalActionName, finalMethodName);
        HashMap< String, Object > extraContext = new HashMap< String, Object >();
        extraContext.put(ActionContext.VALUE_STACK, ActionContext.getContext().getValueStack());
        extraContext.put(ActionContext.PARAMETERS, ActionContext.getContext().getParameters());
        extraContext.put(CHAIN_HISTORY, ActionChainResult.getChainHistory());
        if (LOG.isDebugEnabled()) {
            LOG.debug("Chaining to action " + finalActionName);
        }
        proxy = actionProxyFactory.createActionProxy(finalNamespace, finalActionName, finalMethodName, extraContext);
        proxy.execute();
}

 public static LinkedList<String> getChainHistory() 
{
        LinkedList< String > chainHistory = (LinkedList< String >) ActionContext.getContext().get(CHAIN_HISTORY);
        //  Add if not exists
        if (chainHistory == null) {
            chainHistory = new LinkedList< String >();
            ActionContext.getContext().put(CHAIN_HISTORY, chainHistory);
        }
        return chainHistory;
}

Get the XWork chain history. The stack is a list of namespace/action!method keys.

 public ActionProxy getProxy() 
{
        return proxy;
}

 public int hashCode() 
{
        int result;
        result = (actionName != null ? actionName.hashCode() : 0);
        result = 31 * result + (namespace != null ? namespace.hashCode() : 0);
        result = 31 * result + (methodName != null ? methodName.hashCode() : 0);
        return result;
}

 public  void setActionName(String actionName) 
{
        this.actionName = actionName;
}

Set the action name.

 public  void setActionProxyFactory(ActionProxyFactory actionProxyFactory) 
{
        this.actionProxyFactory = actionProxyFactory;
}

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

 public  void setNamespace(String namespace) 
{
        this.namespace = namespace;
}

sets the namespace of the Action that we're chaining to. if namespace is null, this defaults to the current namespace.

 public  void setSkipActions(String actions) 
{
        this.skipActions = actions;
}

Set the list of actions to skip. To test if an action should not throe an infinite recursion, only the action name is used, not the namespace.