Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ************************************************************************
  #
  #  DivConq
  #
  #  http://divconq.com/
  #
  #  Copyright:
  #    Copyright 2014 eTimeline, LLC. All rights reserved.
  #
 #  License:
 #    See the license.txt file in the project's top-level directory for details.
 #
 #  Authors:
 #    * Andy White
 #
 ************************************************************************ */
 package divconq.script;
 
 import java.util.List;
 
 
 public abstract class BlockInstruction extends Instruction {
 	protected List<Instructioninstructions = new ArrayList<Instruction>();
 
 	protected List<InstructiongetInstructions() { 
 		return this.
     }
 
     public void addInstruction(Instruction inst) {
     	this..add(inst);
     }
 
 	public void compile(ActivityManager managerOperationResult log) {
 		super.compile(managerlog);
 		
         for (XElement child : this..selectAll("*")) {
         	// Internal and Detail are always a special child tag, do not treat these as instructions
         	if ("Internal".equals(child.getName()) || "Detail".equals(child.getName()))
         		continue;
         	
             Instruction ni = manager.createInstruction(child);
             
             if (ni == null) {
             	log.errorTr(509, child.getName());
             	continue;
             }
             
             ni.setXml(child);
             
             this.addInstruction(ni);
             
             ni.compile(managerlog);
         }
 	}
 
 	// no need for try catch here, should always be handled in the subclass
     public void run(final StackEntry stack) {
 		if (stack.getState() == .) {
         	stack.resume();
         	return;
 		}
 		
 		if (stack.getState() == .) {
         	stack.setState(.);
         	//stack.resume();
         	//return;
 		}
 		
 		this.alignInstruction(stacknew OperationCallback() {			
 			public void callback() {
 		        if (stack.getState() != .) {
 		        	stack.resume();
 		        	return;
 		        }
 		        
 				final StackBlockEntry bstack = (StackBlockEntry)stack;
 				
 		        // give the debugger a more natural feel by pointing to the top instruction before executing it
 		        if (bstack.getTopFlag()) {
 		        	bstack.setTopFlag(false);
 		        	stack.resume();
 		        	return;
 		        }
 
 		        bstack.getChild().run(new IInstructionCallback() {
 					public void resume() {
 						StackEntry child = bstack.getChild();
 						
 						if (child == null) {
 						}
						else {				
							ExecuteState cstate = child.getState();
							if ((cstate != .) && (cstate != .)) {
						        if (cstate == .)  
						        	bstack.setState(.);
						        else if (cstate == .
						        	BlockInstruction.this.continueInstruction(stack);
						        else {  // if Done
						        	BlockInstruction.this.nextInstruction(stacknew OperationCallback() {										
										public void callback() {
											stack.resume();
										}
									});
						        	
						        	return;
						        }
							}
						}
						stack.resume();
					}
				});
			}
		});
    }
	// continue is essentially the same as reaching the end of the block
	// see alignInstruction - subclasses will treat end of block as flag
	// to either bail or continue the loop (check condition)
    public void continueInstruction(final StackEntry stack) {
		final StackBlockEntry bstack = (StackBlockEntry)stack;
		bstack.setChild(null);
		bstack.setTopFlag(true);
    }
    public void nextInstruction(final StackEntry stackOperationCallback callback) {
		final StackBlockEntry bstack = (StackBlockEntry)stack;
    	bstack.setPosition(bstack.getPosition() + 1);
    	
    	// if at end of block, treat as a continue - initiate iteration logic
    	if (bstack.getPosition() >= this..size()) { 
    		this.continueInstruction(stack);
    		callback.complete();
    	}
    	else
    		this.alignInstruction(stackcallback);
    }
    
    // sub classes will override this method to control instruction placement
    // and block repetition
    public void alignInstruction(final StackEntry stackOperationCallback callback) {
    	StackBlockEntry bstack = (StackBlockEntry)stack;
    	
    	if ((bstack.getState() == .) || (bstack.getState() == .) || (bstack.getState() == .)) {
        	bstack.setChild(null);
    	}
    	else if (bstack.getPosition() >= this..size()) {
        	bstack.setChild(null);
    		stack.setState(.);
    	}
        else {
        	Instruction inst = this..get(bstack.getPosition());        	
        	StackEntry child = bstack.getChild();
        	
        	// literally, is it the same inst?  if not then we load the current 
        	if ((child == null) || (child.getInstruction() != inst)) 
	        	bstack.setChild(inst.createStack(stack.getActivity(), bstack));
        }
    	
    	callback.complete();
    }
    @Override
	public StackEntry createStack(Activity actStackEntry parent) {
		return new StackBlockEntry(actparentthis);
	}	
	public void cancel(StackEntry stack) {
		// only cancel on current aligned instruction - it is possible to be off here in a race, but instructions
		// should just be smart and only cancel when running
        if (stack.getState() == .) {
			StackEntry child = ((StackBlockEntry)stack).getChild();
			if (child != null)
				child.cancel();
        }
	}
New to GrepCode? Check out our FAQ X