Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   * 
   * Licensed under the Apache License, Version 2.0 (the "License"). You may not
   * use this file except in compliance with the License. A copy of the License is
   * located at
   * 
   * http://aws.amazon.com/apache2.0
   * 
  * or in the "license" file accompanying this file. This file is distributed on
  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  * express or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 package com.amazonaws.services.simpleworkflow.flow.core;
 
 import java.util.List;
 
 
 
     private List<AsyncContextBaseheirs = new ArrayList<AsyncContextBase>();
 
     private int nonDaemonHeirsCount;
 
     private Executor executor;
 
     private State state = .;
 
     private Throwable failure;
 
     private boolean canceled;
 
     private boolean executed;
 
     private boolean daemondCausedCancellation;
 
     private final TryCatchFinally tryCatchFinally;
 
     private final String parentTaskMethodName;
 
     TryCatchFinallyContext(TryCatchFinally tryCatchFinallyBoolean daemonString parentTaskMethodNameint skipStackLines,
             Promise<?>[] waitFor) {
         super(daemonwaitForskipStackLines);
         this. = tryCatchFinally;
         this. = .getExecutor();
         this. = parentTaskMethodName;
     }
 
     TryCatchFinallyContext(AsyncParentContext parentTryCatchFinally tryCatchFinallyBoolean daemon,
             String parentTaskMethodNameint skipStackLines, Promise<?>[] waitFor) {
         super(parentdaemonwaitForskipStackLines);
         this. = tryCatchFinally;
         this. = parent.getExecutor();
         this. = parentTaskMethodName;
     }
 
     public Executor getExecutor() {
         return ;
     }
 
     @Override
     public void add(final AsyncContextBase asyncPromise<?> waitFor) {
         checkClosed();
         .add(async);
         if (!async.isDaemon()) {
             ++;
         }
         if (waitFor == null) {
             .execute(async);
         }
         else {
             waitFor.addCallback(new Runnable() {
 
                 @Override
                 public void run() {
                     .execute(async);
                 }
 
             });
         }
     }
 
     private void checkClosed() {
         if ( == .) {
             throw new IllegalStateException(.toString());
         }
     }
 
     public void cancel(Throwable cause) {
         if ( == .) {
             assert .size() == 0;
              = .;
             .remove(this);
             return;
        }
        if ( == null) {
             = true;
             = new CancellationException();
            if ( != null) {
                .setStackTrace(.getStackTrace());
            }
            .initCause(cause);
            if ( == .) {
                cancelHeirs();
            }
        }
    }
    public boolean isCancelRequested() {
        return ;
    }
    public void remove(AsyncContextBase async) {
        checkClosed();
        .remove(async);
        if (!async.isDaemon()) {
            --;
            assert  >= 0;
        }
        updateState();
    }
    public void fail(AsyncContextBase asyncThrowable e) {
        checkClosed();
        boolean cancellationException = e instanceof CancellationException;
        // Explicit cancellation through cancel() call leads to CancellationException being 
        // thrown from the cancelled component. At the same time cancellation caused by the 
        // daemon flag is ignored.
        if (!cancellationException || ( == null && !)) {
             = e;
        }
        boolean removed = .remove(async);
        assert removed;
        if (!async.isDaemon()) {
            --;
            assert  >= 0;
        }
        cancelHeirs();
        updateState();
    }
    @Override
    public void run() {
        if ( == .) {
            return;
        }
        if ( == .) {
             = .;
        }
        setCurrent(this);
        Throwable f = ;
        try {
            switch () {
            case :
                if () {
                    return;
                }
                .doTry();
                break;
            case :
                 = null;
                .doCatch(f);
                break;
            case :
                .doFinally();
            }
        }
        catch (Throwable e) {
            if ( != null && e != f) {
                AsyncStackTrace merged = new AsyncStackTrace(e.getStackTrace(), 0);
                merged.setStartFrom(getParentTaskMethodName());
                e.setStackTrace(merged.getStackTrace());
            }
             = e;
            cancelHeirs();
        }
        finally {
            setCurrent(null);
             = true;
            updateState();
        }
    }
    private void cancelHeirs() {
        List<AsyncContextBasetoCancel = new ArrayList<AsyncContextBase>();
        for (AsyncContextBase heir : toCancel) {
            heir.cancel();
        }
    }
    private void updateState() {
        if ( == . || !) {
            return;
        }
        if ( == 0) {
            if (.isEmpty()) {
                if ( == .) {
                    if ( == null) {
                         = .;
                        execute();
                    }
                    else {
                         = .;
                        execute();
                    }
                }
                else if ( == .) {
                     = .;
                    execute();
                }
                else if ( == .) {
                    assert  != .;
                     = .;
                    if ( == null) {
                        .remove(this);
                    }
                    else {
                        .fail(this);
                    }
                }
                else {
                    throw new IllegalStateException("Unknown state " + );
                }
            }
            else {
                if ( == null) {
                     = true;
                }
                cancelHeirs();
            }
        }
    }
    private void execute() {
         = false;
        .execute(this);
    }
    @Override
    protected void getAsynchronousStackTraceDump(List<AsyncTaskInforesult) {
        if (.size() == 0) {
            result.add(getTaskInfo());
        }
        else {
            for (AsyncContextBase heir : ) {
                heir.getAsynchronousStackTraceDump(result);
            }
        }
    }
    public boolean isRethrown(Throwable e) {
        return e == ;
    }
    @Override
        return this;
    }

    
Heirs of the TryCatchFinally do not inherit daemon flag.
    @Override
    public boolean getDaemonFlagForHeir() {
        return false;
    }
    @Override
    public String getParentTaskMethodName() {
        if ( != null) {
            return ;
        }
        if ( == .) {
            return "doTry";
        }
        if ( == .) {
            return "doCatch";
        }
        if ( == .) {
            return "doFinally";
        }
        return null;
    }
    public State getState() {
        return ;
    }
    @Override
    public String toString() {
        if ( != null) {
            return .toString();
        }
        return super.toString();
    }
New to GrepCode? Check out our FAQ X