/*
* Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package com.sun.xml.internal.ws.api.pipe;
import com.sun.xml.internal.ws.api.message.Packet;
/**
* Indicates what shall happen after {@link Tube#processRequest(Packet)} or
* {@link Tube#processResponse(Packet)} returns.
*
* <p>
* To allow reuse of this object, this class is mutable.
*
* @author Kohsuke Kawaguchi
*/
public final class NextAction {
int kind;
Tube next;
Packet packet;
/**
* Really either {@link RuntimeException} or {@link Error}.
*/
Throwable throwable;
// public enum Kind { INVOKE, INVOKE_AND_FORGET, RETURN, SUSPEND }
static final int INVOKE = 0;
static final int INVOKE_AND_FORGET = 1;
static final int RETURN = 2;
static final int THROW = 3;
static final int SUSPEND = 4;
private void set(int k, Tube v, Packet p, Throwable t) {
this.kind = k;
this.next = v;
this.packet = p;
this.throwable = t;
}
/**
* Indicates that the next action should be to
* invoke the next tube's {@link Tube#processRequest(Packet)},
* then later invoke the current tube's {@link Tube#processResponse(Packet)}
* with the response packet.
*/
public void invoke(Tube next, Packet p) {
set(INVOKE, next, p, null);
}
/**
* Indicates that the next action should be to
* invoke the next tube's {@link Tube#processRequest(Packet)},
* but the current tube doesn't want to receive the response packet to
* its {@link Tube#processResponse(Packet)}.
*/
public void invokeAndForget(Tube next, Packet p) {
set(INVOKE_AND_FORGET, next, p, null);
}
/**
* Indicates that the next action is to flip the processing direction
* and starts response processing.
*/
public void returnWith( Packet response ) {
set(RETURN, null, response, null);
}
/**
* Indicates that the next action is to flip the processing direction
* and starts exception processing.
*
* @param t
* Either {@link RuntimeException} or {@link Error}, but defined to
* take {@link Throwable} because {@link Tube#processException(Throwable)}
* takes {@link Throwable}.
*/
public void throwException(Throwable t) {
assert t instanceof RuntimeException || t instanceof Error;
set(THROW,null,null,t);
}
/**
* Indicates that the fiber should be suspended.
* Once {@link Fiber#resume(Packet) resumed}, return the response processing.
*/
public void suspend() {
set(SUSPEND, null, null, null);
}
/**
* Dumps the contents to assist debugging.
*/
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(super.toString()).append(" [");
buf.append("kind=").append(getKindString()).append(',');
buf.append("next=").append(next).append(',');
buf.append("packet=").append(packet).append(',');
buf.append("throwable=").append(throwable).append(']');
return buf.toString();
}
/**
* Returns {@link #kind} in a human readable string, to assist debugging.
*/
public String getKindString() {
switch(kind) {
case INVOKE: return "INVOKE";
case INVOKE_AND_FORGET: return "INVOKE_AND_FORGET";
case RETURN: return "RETURN";
case THROW: return "THROW";
case SUSPEND: return "SUSPEND";
default: throw new AssertionError(kind);
}
}
}