Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License 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 org.apache.tuscany.sca.core.invocation.impl;
 
 import java.util.List;
 
Default implementation of an invocation chain

Version:
$Rev: 1057648 $ $Date: 2011-01-11 16:14:06 +0200 (Tue, 11 Jan 2011) $
 
 public class InvocationChainImpl implements InvocationChain {
     private Operation sourceOperation;
     private Operation targetOperation;
     private List<Nodenodes = new ArrayList<Node>();
 
     private final PhaseManager phaseManager;
     private boolean forReference;
     private boolean allowsPassByReference;
     private boolean isAsyncInvocation;
 
     public InvocationChainImpl(Operation sourceOperationOperation targetOperationboolean forReferencePhaseManager phaseManagerboolean isAsyncInvocation) {
         this. = targetOperation;
         this. = sourceOperation;
         this. = forReference;
         this. = phaseManager;
         this. = isAsyncInvocation;
     }
 
     public Operation getTargetOperation() {
         return ;
     }
 
     public void setTargetOperation(Operation operation) {
         this. = operation;
     }
 
     public void addInterceptor(Interceptor interceptor) {
         if (interceptor instanceof PhasedInterceptor) {
             PhasedInterceptor pi = (PhasedInterceptor)interceptor;
             if (pi.getPhase() != null) {
                 addInvoker(pi.getPhase(), pi);
                 return;
             }
         }
         String phase =  ? . : .;
         addInterceptor(phaseinterceptor);
     } // end method addInterceptor
 
     public void addInvoker(Invoker invoker) {
         if (invoker instanceof PhasedInterceptor) {
             PhasedInterceptor pi = (PhasedInterceptor)invoker;
             if (pi.getPhase() != null) {
                 addInvoker(pi.getPhase(), pi);
                 return;
             }
         }
         String phase =  ? . : .;
         addInvoker(phaseinvoker);
     }
 
     public Invoker getHeadInvoker() {
         return .isEmpty() ? null : .get(0).getInvoker();
     }
     
     public Invoker getTailInvoker() {
     	int nodeCount = .size();
     	ifnodeCount > 0 ) {
     		return .getnodeCount - 1).getInvoker();
    	} // end if
    	
        return null;
    } // end method getTailInvoker
    
    public Invoker getHeadInvoker(String phase) {
        int index = .getAllPhases().indexOf(phase);
        if (index == -1) {
            throw new IllegalArgumentException("Invalid phase name: " + phase);
        }
        for (Node node : ) {
            if (index <= node.getPhaseIndex()) {
                return node.getInvoker();
            }
        }
        return null;
    }

    

Returns:
the sourceOperation
    public Operation getSourceOperation() {
        return ;
    }

    

Parameters:
sourceOperation the sourceOperation to set
    public void setSourceOperation(Operation sourceOperation) {
        this. = sourceOperation;
    }
    public void addInterceptor(String phaseInterceptor interceptor) {
        addInvoker(phaseinterceptor);
    }
    private void addInvoker(String phaseInvoker invoker) {
        if ( &&
            !(invoker instanceof InvokerAsyncRequest) &&
            !(invoker instanceof InvokerAsyncResponse) ){
            // TODO - should raise an error but don't want to break
            //        the existing non-native async support
/*            
            throw new IllegalArgumentException("Trying to add synchronous invoker " +
                                               invoker.getClass().getName() +
                                               " to asynchronous chain");
*/                                             
        }
        
        int index = .getAllPhases().indexOf(phase);
        if (index == -1) {
            throw new IllegalArgumentException("Invalid phase name: " + phase);
        }
        Node node = new Node(indexinvoker);
        ListIterator<Nodeli = .listIterator();
        Node before = nullafter = null;
        boolean found = false;
        while (li.hasNext()) {
            before = after;
            after = li.next();
            if (after.getPhaseIndex() > index) {
                // Move back
                li.previous();
                li.add(node);
                found = true;
                break;
            }
        }
        if (!found) {
            // Add to the end
            .add(node);
            before = after;
            after = null;
        }
        // Relink the interceptors
        if (before != null) {
            if (before.getInvoker() instanceof Interceptor) {
                ((Interceptor)before.getInvoker()).setNext(invoker);
                if ((invoker instanceof InterceptorAsync) &&
                    (before.getInvoker() instanceof InvokerAsyncResponse)) {
                    ((InterceptorAsyncinvoker).setPrevious((InvokerAsyncResponse)before.getInvoker());
                }
            }
        }
        if (after != null) {
            if (invoker instanceof Interceptor) {
                ((Interceptor)invoker).setNext(after.getInvoker());
                if ((after.getInvoker() instanceof InterceptorAsync) &&
                    (invoker instanceof InvokerAsyncResponse)){
                    ((InterceptorAsyncafter.getInvoker()).setPrevious((InvokerAsyncResponse)invoker);
                }
            }
        }
    }
    public boolean allowsPassByReference() {
        if () {
            // No need to check the invokers
            return true;
        }
        // Check if any of the invokers allows pass-by-reference
        boolean allowsPBR = false;
        for (Node i : ) {
            if (i.getInvoker() instanceof DataExchangeSemantics) {
                if (((DataExchangeSemantics)i.getInvoker()).allowsPassByReference()) {
                    allowsPBR = true;
                    break;
                }
            }
        }
        return allowsPBR;
    }
    public void setAllowsPassByReference(boolean allowsPBR) {
        this. = allowsPBR;
    }
    private static class Node {
        private int phaseIndex;
        private Invoker invoker;
        public Node(int phaseIndexInvoker invoker) {
            super();
            this. = phaseIndex;
            this. = invoker;
        }
        public int getPhaseIndex() {
            return ;
        }
        public Invoker getInvoker() {
            return ;
        }
        @Override
        public String toString() {
            return "(" +  + ")" + ;
        }
    }
    
    public boolean isAsyncInvocation() {
        return ;
    }
	public void addHeadInterceptor(Interceptor interceptor) {
        if (interceptor instanceof PhasedInterceptor) {
            PhasedInterceptor pi = (PhasedInterceptor)interceptor;
            if (pi.getPhase() != null) {
            	phase = pi.getPhase();
            } // end if
        } // end if
       
        addHeadInterceptor(phaseinterceptor);
// end method addHeadInterceptor
	public void addHeadInterceptor(String phaseInterceptor interceptor) {
		// TODO Auto-generated method stub
		Invoker invoker = (Invoker)interceptor;
        int index = .getAllPhases().indexOf(phase);
        if (index == -1) {
            throw new IllegalArgumentException("Invalid phase name: " + phase);
        } // end if 
        Node node = new Node(indexinvoker);
        
        ListIterator<Nodeli = .listIterator();
        Node before = nullafter = null;
        boolean found = false;
        while (li.hasNext()) {
            before = after;
            after = li.next();
            // Look for the first node with a phase index equal to or greater than the one provided
            if (after.getPhaseIndex() >= index) {
                // Move back
                li.previous();
                li.add(node);
                found = true;
                break;
            }
        }
        if (!found) {
            // Add to the end
            .add(node);
            before = after;
            after = null;
        }
        // Relink the interceptors
        if (before != null) {
            if (before.getInvoker() instanceof Interceptor) {
                ((Interceptor)before.getInvoker()).setNext(invoker);
                if ((invoker instanceof InterceptorAsync) &&
                    (before.getInvoker() instanceof InvokerAsyncResponse)) {
                    ((InterceptorAsyncinvoker).setPrevious((InvokerAsyncResponse)before.getInvoker());
                }
            }
        }
        if (after != null) {
            if (invoker instanceof Interceptor) {
                ((Interceptor)invoker).setNext(after.getInvoker());
                if ((after.getInvoker() instanceof InterceptorAsync) &&
                    (invoker instanceof InvokerAsyncResponse)){
                    ((InterceptorAsyncafter.getInvoker()).setPrevious((InvokerAsyncResponse)invoker);
                }
            }
        }
// end method addHeadInterceptor
New to GrepCode? Check out our FAQ X