Refine search
private Set<Class> findAllInterfacesInHierarchy(Class candidateGoExtensionClass) { Stack<Class> classesInHierarchy = new Stack<>(); classesInHierarchy.add(candidateGoExtensionClass); Set<Class> interfaces = new HashSet<>(); while (!classesInHierarchy.empty()) { Class classToCheckFor = classesInHierarchy.pop(); if (classToCheckFor.isInterface()) { interfaces.add(classToCheckFor); } classesInHierarchy.addAll(Arrays.asList(classToCheckFor.getInterfaces())); if (classToCheckFor.getSuperclass() != null) { classesInHierarchy.add(classToCheckFor.getSuperclass()); } } return interfaces; }
private void validateRootExists(CaseInsensitiveString root, PipelineDependencyState pipelineDependencyState, Stack<CaseInsensitiveString> visiting) throws Exception { if (!pipelineDependencyState.hasPipeline(root)) { StringBuffer sb = new StringBuffer("Pipeline \""); sb.append(root); sb.append("\" does not exist."); visiting.pop(); if (!visiting.empty()) { CaseInsensitiveString parent = visiting.peek(); sb.append(" It is used from pipeline \""); sb.append(parent); sb.append("\"."); } throw new Exception(sb.toString()); } }
@Override protected soot.Value getSimpleAssignRightLocal(polyglot.ast.Assign assign) { boolean repush = false; soot.jimple.Stmt tNoop = null; soot.jimple.Stmt fNoop = null; if (!trueNoop.empty() && !falseNoop.empty()) { tNoop = trueNoop.pop(); fNoop = falseNoop.pop(); repush = true; } soot.Value right = base().createAggressiveExpr(assign.right(), false, false); if (repush) { trueNoop.push(tNoop); falseNoop.push(fNoop); } if (right instanceof soot.jimple.ConditionExpr) { right = handleCondBinExpr((soot.jimple.ConditionExpr) right); } return right; }
private GroovySourceAST getGrandParentNode() { GroovySourceAST grandParentNode = null; GroovySourceAST parentNode; GroovySourceAST currentNode = stack.pop(); if (!stack.empty()) { parentNode = stack.pop(); if (!stack.empty()) { grandParentNode = stack.peek(); } stack.push(parentNode); } stack.push(currentNode); return grandParentNode; }
private Set<Operator<?>> getAllOperatorsForSimpleFetch(Set<Operator<?>> opSet) { Set<Operator<?>> returnSet = new LinkedHashSet<Operator<?>>(); Stack<Operator<?>> opStack = new Stack<Operator<?>>(); // add all children opStack.addAll(opSet); while (!opStack.empty()) { Operator<?> op = opStack.pop(); returnSet.add(op); if (op.getChildOperators() != null) { opStack.addAll(op.getChildOperators()); } } return returnSet; } }
/** * Leave the current scope */ public void leaveScope() { if (!exec.signals.empty()) { Scope scope = exec.scopes.peek(); Signal signal = exec.signals.peek(); if (exec.conf.onError != OnError.SETERROR) { runExitHandler(); } if (signal.type == Signal.Type.LEAVE_ROUTINE && scope.type == Scope.Type.ROUTINE) { exec.signals.pop(); } } exec.currentScope = exec.scopes.pop().getParent(); }
/** * This function is called while parsing the filterString and an operator is parsed * <p> * @param operatorStack the stack containing the operators and parenthesis * @param filterStack the stack containing the filters * @param operator the operator found while parsing the filterString */ public void reduce(Stack<ByteBuffer> operatorStack, Stack<Filter> filterStack, ByteBuffer operator) { while (!operatorStack.empty() && !(ParseConstants.LPAREN_BUFFER.equals(operatorStack.peek())) && hasHigherPriority(operatorStack.peek(), operator)) { filterStack.push(popArguments(operatorStack, filterStack)); } }
private static List<SQLSelectQueryBlock> splitSQLSelectQuery(SQLSelectQuery x) { List<SQLSelectQueryBlock> groupList = new ArrayList<SQLSelectQueryBlock>(); Stack<SQLSelectQuery> stack = new Stack<SQLSelectQuery>(); stack.push(x); do { SQLSelectQuery query = stack.pop(); if (query instanceof SQLSelectQueryBlock) { groupList.add((SQLSelectQueryBlock) query); } else if (query instanceof SQLUnionQuery) { SQLUnionQuery unionQuery = (SQLUnionQuery) query; stack.push(unionQuery.getLeft()); stack.push(unionQuery.getRight()); } } while (!stack.empty()); return groupList; }
private Set<Operator<?>> getAllOperatorsForSimpleFetch(Set<Operator<?>> opSet) { Set<Operator<?>> returnSet = new LinkedHashSet<Operator<?>>(); Stack<Operator<?>> opStack = new Stack<Operator<?>>(); // add all children opStack.addAll(opSet); while (!opStack.empty()) { Operator<?> op = opStack.pop(); returnSet.add(op); if (op.getChildOperators() != null) { opStack.addAll(op.getChildOperators()); } } return returnSet; } }
public int firstOffendingParenthesis(String input) { /* Algorithm: 1. Iterate over all the characters of input String 2. If character is ')' and stack is not empty then remove element from stack 3. Else add the position into the stack 4. After iteration, if stack is empty then return -1 else get the first element and return its value. */ Stack<Integer> stack = new Stack<>(); for (int i = 0; i < input.length(); i++) { if (input.charAt(i) == ')' && !stack.empty()) { stack.pop(); } else { stack.push(i); } } return stack.empty() ? -1 : stack.elementAt(0); } }
public Set<Operator<?>> getAllOperators() { Set<Operator<?>> returnSet = new LinkedHashSet<Operator<?>>(); Set<Operator<?>> opSet = getAllRootOperators(); Stack<Operator<?>> opStack = new Stack<Operator<?>>(); // add all children opStack.addAll(opSet); while(!opStack.empty()) { Operator<?> op = opStack.pop(); returnSet.add(op); if (op.getChildOperators() != null) { opStack.addAll(op.getChildOperators()); } } return returnSet; }