jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/api/pipe/NextAction.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/pipe/NextAction.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/pipe/NextAction.java

Tue, 09 Apr 2013 14:51:13 +0100

author: alanb
date: Tue, 09 Apr 2013 14:51:13 +0100
changeset 368: 0989ad8c0860
parent 286: f50545b5e2f1
child 637: 9c07ef4934dd
permissions: -rw-r--r--

8010393: Update JAX-WS RI to 2.2.9-b12941
Reviewed-by: alanb, erikj
Contributed-by: miroslav.kos@oracle.com, martin.grebac@oracle.com

 /*
  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.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;
 import java.util.concurrent.Executor;
 /**
  * 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;
     Runnable onExitRunnable;
     // 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;
     // Used to abort processResponse chain if a fatal exception is encountered
     static final int THROW_ABORT_RESPONSE = 5;
     // Used to abort processResponse chain if a response should be aborted
     static final int ABORT_RESPONSE = 6;
     // Used to switch a tubeline from synchronous to asynchronous execution
     // with respect to the thread that started this tubeline.
     static final int INVOKE_ASYNC = 7;
   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, but with the indicated context.
      *
      * @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( Packet response, Throwable t ) {
         // Use of RETURN is correct -- Fiber processing does not set packet for type of THROW
         set(RETURN, null, response, t);
     }
     /**
      * 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 next action is to abort the processResponse chain
      * because of an exception. How that exception is processed is not
      * defined.
      *
      * @param t
      *      Either {@link RuntimeException} or {@link Error}
      */
     public void throwExceptionAbortResponse(Throwable t) {
         set(THROW_ABORT_RESPONSE,null,null,t);
     }
     /**
      * Indicates that the next action is to abort the processResponse chain
      * because of some non-exception condition.
      *
      * @param response The response that is being aborted
      */
     public void abortResponse(Packet response) {
         set(ABORT_RESPONSE,null,response,null);
     }
     /**
      * Indicates that the next action is to invoke the next tube in the
      * tubeline async from the thread that started the tubeline. Only fibers
      * that were started using startSync should use this next action kind.
      * @param next The next tube in the tubeline
      * @param p The request to pass to the next tube
      */
     public void invokeAsync(Tube next, Packet p) {
         set(INVOKE_ASYNC,next,p,null);
     }
     /**
      * Indicates that the fiber should be suspended.
      * Once {@link Fiber#resume(Packet) resumed}, return the response processing.
      * @deprecated Use variants that pass {@link Runnable}
      */
     public void suspend() {
         suspend(null, null);
     }
     /**
      * Indicates that the fiber should be suspended.  Once the current {@link Thread}
      * exits the fiber's control loop, the onExitRunnable will be invoked.  This {@link Runnable}
      * may call {@link Fiber#resume(Packet)}; however it is still guaranteed that the current
      * Thread will return control, therefore, further processing will be handled on a {@link Thread}
      * from the {@link Executor}.  For synchronous cases, the Thread invoking this fiber cannot return
      * until fiber processing is complete; therefore, the guarantee is only that the onExitRunnable
      * will be invoked prior to completing the suspension.
      * @since 2.2.7
      */
     public void suspend(Runnable onExitRunnable) {
         suspend(null, onExitRunnable);
     }
     /**
      * Indicates that the fiber should be suspended.
      * Once {@link Fiber#resume(Packet) resumed}, resume with the
      * {@link Tube#processRequest(Packet)} on the given next tube.
      * @deprecated Use variants that pass {@link Runnable}
      */
     public void suspend(Tube next) {
         suspend(next, null);
     }
     /**
      * Indicates that the fiber should be suspended.  Once the current {@link Thread}
      * exits the fiber's control loop, the onExitRunnable will be invoked.  This {@link Runnable}
      * may call {@link Fiber#resume(Packet)}; however it is still guaranteed that the current
      * fiber will return control, therefore, further processing will be handled on a {@link Thread}
      * from the {@link Executor}.  For synchronous cases, the Thread invoking this fiber cannot return
      * until fiber processing is complete; therefore, the guarantee is only that the onExitRunnable
      * will be invoked prior to completing the suspension.
      * <p>
      * Once {@link Fiber#resume(Packet) resumed}, resume with the
      * {@link Tube#processRequest(Packet)} on the given next tube.
      * @since 2.2.7
      */
     public void suspend(Tube next, Runnable onExitRunnable) {
         set(SUSPEND, next, null, null);
         this.onExitRunnable = onExitRunnable;
     }
     /** Returns the next tube
      * @return Next tube
      */
     public Tube getNext() {
         return next;
     }
     /** Sets the next tube
      * @param next Next tube
      */
     public void setNext(Tube next) {
         this.next = next;
     }
     /**
      * Returns the last Packet
      * @return Packet
      */
     public Packet getPacket() {
         return packet;
     }
     /**
      * Returns the Throwable generated by the last Tube
      * @return the Throwable
      */
     public Throwable getThrowable() {
         return throwable;
     }
     /**
      * Dumps the contents to assist debugging.
      */
     @Override
     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 != null ? packet.toShortString() : null).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";
         case THROW_ABORT_RESPONSE: return "THROW_ABORT_RESPONSE";
         case ABORT_RESPONSE:    return "ABORT_RESPONSE";
         case INVOKE_ASYNC:      return "INVOKE_ASYNC";
         default:                throw new AssertionError(kind);
         }
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/api/pipe/NextAction.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/pipe/NextAction.java