Java Code Examples for java.util.Stack#contains()

/**
 * Sets the recently changed filters.
 *
 * @param changeHistory the change history
 * @since 3.0
 */
private void setRecentlyChangedFilters(Stack<FilterDescriptor> changeHistory) {
	Stack<String> oldestFirstStack= new Stack<String>();

	int length= Math.min(changeHistory.size(), MAX_FILTER_MENU_ENTRIES);
	for (int i= 0; i < length; i++)
		oldestFirstStack.push(changeHistory.pop().getId());

	length= Math.min(fLRUFilterIdsStack.size(), MAX_FILTER_MENU_ENTRIES - oldestFirstStack.size());
	int NEWEST= 0;
	for (int i= 0; i < length; i++) {
		String filter= fLRUFilterIdsStack.remove(NEWEST);
		if (!oldestFirstStack.contains(filter))
			oldestFirstStack.push(filter);
	}
	fLRUFilterIdsStack= oldestFirstStack;
}
 

void scanDependencies(Stack<CtPackageReference> path) {
	CtPackageReference ref = path.peek();
	// return if already scanned
	if (scanned.contains(ref)) {
		return;
	}
	scanned.add(ref);
	Set<CtPackageReference> refs = packRefs.get(ref);
	if (refs != null) {
		for (CtPackageReference p : refs) {
			if (path.contains(p)) {
				List<CtPackageReference> circularPath = new ArrayList<>(
						path.subList(path.indexOf(p), path.size()));
				circularPath.add(p);

				circularPathes.add(circularPath);
				break;
			} else {
				path.push(p);
				scanDependencies(path);
				path.pop();
			}
		}
	}
}
 

private void walk ( final Stack<DataSourceNode> stack, final DataSourceNode node )
{
    if ( stack.contains ( node ) )
    {
        this.logStream.println ( "Loop found: " + StringHelper.join ( stack, " -> " ) );
        // loop found
        return;
    }

    stack.push ( node );
    for ( final DataSourceNode ref : node.getReferences () )
    {
        walk ( stack, ref );
    }
    stack.pop ();
}
 

private void calculateReachabilityAndMarkBackEdges(final Stack<RegionNode> aCurrentPath, final RegionNode aNode, final Set<RegionNode> aVisited) {
    if (aVisited.add(aNode)) {
        aCurrentPath.push(aNode);
        for (final Edge<ControlFlowEdgeType, RegionNode> theEdge : aNode.outgoingEdges().collect(Collectors.toList())) {
            final RegionNode theTarget = theEdge.targetNode();
            if (aCurrentPath.contains(theTarget)) {
                // This is a back edge
                theEdge.newTypeIs(ControlFlowEdgeType.back);
                // We have already visited the back edge, so we do not to continue here
                // As this would lead to an endless loop
            } else {
                // Normal edge
                // Continue with graph traversal
                calculateReachabilityAndMarkBackEdges(aCurrentPath, theTarget, aVisited);
            }
        }
        aCurrentPath.pop();
    }
}
 

private void inspectComponent(InspectedComponent component) {
	//stack for recursion algorithm
	Stack<InspectedComponent> componentsStack = new Stack<InspectedComponent>();
	
	componentsStack.push(component);
	while (!componentsStack.isEmpty()) {
		//what is current component?
		InspectedComponent topComponent = componentsStack.peek();
		//what is following component?
		InspectedComponent nextComponent = topComponent.getNextComponent();
		if (nextComponent != null) {
			if (!alreadyVisitedFromTheDirection(visitedComponents, nextComponent)) {
				//following component found
				if (componentsStack.contains(nextComponent)) {
					//cycle found
					componentsStack.push(nextComponent);
					cycleFound(componentsStack);
				} else {
					//recursion can go deeper 
					componentsStack.push(nextComponent);
				}
			}
		} else {
			visitedComponents.add(topComponent);
			//no other follower, let's step back in the stack
			componentsStack.pop();
		}
	}
}
 

public void findInvalidDelays(OperatorMeta om, List<List<String>> invalidDelays, Stack<OperatorMeta> stack)
{
  stack.push(om);

  // depth first successors traversal
  boolean isDelayOperator = om.getOperator() instanceof Operator.DelayOperator;
  if (isDelayOperator) {
    if (om.getValue(OperatorContext.APPLICATION_WINDOW_COUNT) != 1) {
      LOG.debug("detected DelayOperator having APPLICATION_WINDOW_COUNT not equal to 1");
      invalidDelays.add(Collections.singletonList(om.getName()));
    }
  }

  for (StreamMeta downStream: om.outputStreams.values()) {
    for (InputPortMeta sink : downStream.sinks) {
      OperatorMeta successor = sink.getOperatorMeta();
      if (isDelayOperator) {
        sink.attributes.put(IS_CONNECTED_TO_DELAY_OPERATOR, true);
        // Check whether all downstream operators are already visited in the path
        if (successor != null && !stack.contains(successor)) {
          LOG.debug("detected DelayOperator does not immediately output to a visited operator {}.{}->{}.{}",
              om.getName(), downStream.getSource().getPortName(), successor.getName(), sink.getPortName());
          invalidDelays.add(Arrays.asList(om.getName(), successor.getName()));
        }
      } else {
        findInvalidDelays(successor, invalidDelays, stack);
      }
    }
  }
  stack.pop();
}
 

private void searchBackward(V node, Set<V> visited, Set<V> component) {
	Stack<V> worklist = new Stack<V>();
	worklist.push(node);
	while (!worklist.isEmpty()) {
		V curr = worklist.pop();
		visited.add(curr);
		component.add(curr);
		for (V pred: getDirectPredecessors(curr))
			if (!visited.contains(pred) && !worklist.contains(pred))
				worklist.add(pred);
	}
}
 

private void clearEvictionDataInAllCallers(String rootModuleConf, Stack<IvyNode> callerStack) {
    for (Caller caller : callerStack.peek().getCallers(rootModuleConf)) {
        IvyNode callerNode = findNode(caller.getModuleRevisionId());
        if (callerNode != null) {
            callerNode.eviction = new IvyNodeEviction(callerNode);
            if (!callerStack.contains(callerNode)) {
                callerStack.push(callerNode);
                clearEvictionDataInAllCallers(rootModuleConf, callerStack);
                callerStack.pop();
            }
        }
    }
}
 

private static final String resolve(String var,
                                    Resolver resolver,
                                    Stack<String> stack,
                                    final boolean failOnUnresolved)
{
    if (stack.contains(var))
    {
        throw new IllegalArgumentException
            (String.format("recursively defined variable: %s stack=%s", var,
                           stack));
    }

    String result = resolver.resolve(var, resolver);
    if (result == null)
    {
        if(failOnUnresolved)
        {
            throw new IllegalArgumentException("no such variable: " + var);
        }
        else
        {
            return "${"+var+"}";
        }
    }

    stack.push(var);
    try
    {
        return expand(result, resolver, stack, failOnUnresolved);
    }
    finally
    {
        stack.pop();
    }
}
 

public boolean hasLoopHashtable() {
    Node temp = head;
    Stack<Node> stack = new Stack<>();
    while (temp != null) {
        if (stack.contains(temp)) {
            temp.next = null;
            return true;
        }
        stack.add(temp);
        temp = temp.next;
    }
    return false;
}
 

private void writeRelationshipData(JsonGenerator gen, ResourceIdentifier resourceId,
		Map<ResourceIdentifier, Resource> resourceMap,
		Stack<ResourceIdentifier> inclusionStack,
		SerializerProvider serializerProvider) throws IOException {

	Resource resource = resourceMap.get(resourceId);
	if (resource != null && !inclusionStack.contains(resourceId)) {
		writeResource(gen, resource, resourceMap, inclusionStack, serializerProvider);
	}
	else {
		gen.writeObject(resourceId);
	}
}
 

/**
 * Unregister last registered context associated with current thread - the last context
 * has to be passed to validate right usage of ContextProvider.
 */
public static synchronized void unregister(Context requestedContext) {
	if (requestedContext == null) {
		//DO NOTHING
		return;
	}
	Stack<Context> threadCache = contextCache.get(Thread.currentThread());
	if (threadCache == null) {
		logger.error("Illegal state in ContextProvider. No cached contexts for current thread " + Thread.currentThread().getName() + ". Requested context: " + requestedContext);
		return;
	}
	if (!threadCache.isEmpty()) {
		Context deregisteredContext = threadCache.pop();
		if (deregisteredContext != requestedContext) {
			if (threadCache.contains(requestedContext)) {
				logger.error("Illegal state in ContextProvider. Context, which should be unregistered, is not on top of stack. Recovery is perfomed, context " + deregisteredContext + " is removed from stack.");
				while (deregisteredContext != requestedContext) {
					deregisteredContext = threadCache.pop();
					logger.error("Illegal state in ContextProvider. Context, which should be unregistered, is not on top of stack. Recovery is perfomed, context " + deregisteredContext + " is removed from stack.");
				}
				logger.error("Illegal state in ContextProvider. Context, which should be unregistered, is not on top of stack. Recovery finished. Requested context is " + requestedContext);
			} else {
				threadCache.push(deregisteredContext);
				logger.error("Illegal state in ContextProvider. Last context in stack was " + deregisteredContext + " but requested context is " + requestedContext);
				return;
			}
		}
		if (threadCache.isEmpty()) {
			contextCache.remove(Thread.currentThread());
		}
	} else {
		contextCache.remove(Thread.currentThread());
		logger.error("Illegal state in ContextProvider. Empty context cache.");
	}
}
 

private static void checkBlock(AMLTestCase block, List<AMLTestCase> blocks, Stack<String> refStack, Stack<AMLAction> actionStack, Set<String> recursiveBlocks, AlertCollector alertCollector) {
    for(AMLAction a : block.getActions()) {
        if(JavaStatement.value(a.getActionURI()) == JavaStatement.INCLUDE_BLOCK) {
            String blockReference = a.getTemplate();
            AMLTestCase refBlock = getBlockByReference(blockReference, blocks);

            if(refBlock == null) {
                alertCollector.add(new Alert(a.getLine(), a.getUID(), a.getReference(), Column.Template.getName(), "Reference to unknown block: " + blockReference));
                continue;
            }

            if(refStack.contains(blockReference)) {
                AMLAction firstAction = actionStack.firstElement();
                List<String> path = new ArrayList<>(refStack);

                path.add(blockReference);
                recursiveBlocks.addAll(refStack);

                alertCollector.add(new Alert(firstAction.getLine(), a.getUID(), firstAction.getReference(), "Recursion detected: " + StringUtils.join(path, " -> ")));

                continue;
            }

            refStack.push(blockReference);
            actionStack.push(a);
            checkBlock(refBlock, blocks, refStack, actionStack, recursiveBlocks, alertCollector);
            actionStack.pop();
            refStack.pop();
        }
    }
}
 

@VisibleForTesting
public static void validateActionInputDirectory(
    String directoryPath,
    Directory directory,
    Stack<Digest> pathDigests,
    Set<Digest> visited,
    Map<Digest, Directory> directoriesIndex,
    Consumer<String> onInputFile,
    Consumer<String> onInputDirectory,
    Consumer<Digest> onInputDigest,
    PreconditionFailure.Builder preconditionFailure) {
  Set<String> entryNames = new HashSet<>();

  String lastFileName = "";
  for (FileNode fileNode : directory.getFilesList()) {
    String fileName = fileNode.getName();
    if (entryNames.contains(fileName)) {
      preconditionFailure
          .addViolationsBuilder()
          .setType(VIOLATION_TYPE_INVALID)
          .setSubject("/" + directoryPath + ": " + fileName)
          .setDescription(DUPLICATE_DIRENT);
    } else if (lastFileName.compareTo(fileName) > 0) {
      preconditionFailure
          .addViolationsBuilder()
          .setType(VIOLATION_TYPE_INVALID)
          .setSubject("/" + directoryPath + ": " + lastFileName + " > " + fileName)
          .setDescription(DIRECTORY_NOT_SORTED);
    }
    /* FIXME serverside validity check? regex?
    Preconditions.checkState(
        fileName.isValidFilename(),
        INVALID_FILE_NAME);
    */
    lastFileName = fileName;
    entryNames.add(fileName);

    onInputDigest.accept(fileNode.getDigest());
    String filePath = directoryPath.isEmpty() ? fileName : (directoryPath + "/" + fileName);
    onInputFile.accept(filePath);
  }
  String lastDirectoryName = "";
  for (DirectoryNode directoryNode : directory.getDirectoriesList()) {
    String directoryName = directoryNode.getName();

    if (entryNames.contains(directoryName)) {
      preconditionFailure
          .addViolationsBuilder()
          .setType(VIOLATION_TYPE_INVALID)
          .setSubject("/" + directoryPath + ": " + directoryName)
          .setDescription(DUPLICATE_DIRENT);
    } else if (lastDirectoryName.compareTo(directoryName) > 0) {
      preconditionFailure
          .addViolationsBuilder()
          .setType(VIOLATION_TYPE_INVALID)
          .setSubject("/" + directoryPath + ": " + lastDirectoryName + " > " + directoryName)
          .setDescription(DIRECTORY_NOT_SORTED);
    }
    /* FIXME serverside validity check? regex?
    Preconditions.checkState(
        directoryName.isValidFilename(),
        INVALID_FILE_NAME);
    */
    lastDirectoryName = directoryName;
    entryNames.add(directoryName);

    Digest directoryDigest = directoryNode.getDigest();
    if (pathDigests.contains(directoryDigest)) {
      preconditionFailure
          .addViolationsBuilder()
          .setType(VIOLATION_TYPE_INVALID)
          .setSubject(DIRECTORY_CYCLE_DETECTED)
          .setDescription("/" + directoryPath + ": " + directoryName);
    } else {
      String subDirectoryPath =
          directoryPath.isEmpty() ? directoryName : (directoryPath + "/" + directoryName);
      onInputDirectory.accept(subDirectoryPath);
      if (!visited.contains(directoryDigest)) {
        validateActionInputDirectoryDigest(
            subDirectoryPath,
            directoryDigest,
            pathDigests,
            visited,
            directoriesIndex,
            onInputFile,
            onInputDirectory,
            onInputDigest,
            preconditionFailure);
      } else {
        enumerateActionInputDirectory(
            subDirectoryPath,
            directoriesIndex.get(directoryDigest),
            directoriesIndex,
            onInputFile,
            onInputDirectory);
      }
    }
  }
}
 

private Set<BytecodeBasicBlock> generateEdges(
        final Set<BytecodeBasicBlock> aVisited, final BytecodeBasicBlock aBlock, final Stack<BytecodeBasicBlock> aNestingStack, final Map<BytecodeOpcodeAddress, BytecodeBasicBlock> aBlocks) {
    aNestingStack.push(aBlock);

    if (aVisited.add(aBlock)) {
        for (final BytecodeInstruction theInstruction : aBlock.getInstructions()) {
            if (theInstruction.isJumpSource()) {
                for (final BytecodeOpcodeAddress theTarget : theInstruction.getPotentialJumpTargets()) {
                    final BytecodeBasicBlock theTargetBlock = aBlocks.get(theTarget);
                    if (!aNestingStack.contains(theTargetBlock)) {
                        // Normal edge
                        aBlock.addSuccessor(theTargetBlock);
                        generateEdges(aVisited, theTargetBlock, aNestingStack, aBlocks);
                    } else {
                        // Back edge
                        aBlock.addSuccessor(theTargetBlock);
                    }
                }
            }
        }

        // Properly handle the fall thru case
        if (!aBlock.endsWithReturn() && !aBlock.endsWithThrow() && !aBlock.endsWithGoto()) {
            final BytecodeInstruction theLast = aBlock.lastInstruction();
            final BytecodeInstruction theNext = nextInstructionOf(theLast);
            final BytecodeBasicBlock theNextBlock = aBlocks.get(theNext.getOpcodeAddress());
            aBlock.addSuccessor(theNextBlock);
            generateEdges(aVisited, theNextBlock, aNestingStack, aBlocks);
        }

        for (final BytecodeBasicBlock theBlock : aBlock.getSuccessors()) {
            if (theBlock.getType() != BytecodeBasicBlock.Type.NORMAL) {
                generateEdges(aVisited, theBlock, aNestingStack, aBlocks);
            }
        }
    }

    aNestingStack.pop();

    return aVisited;
}
 

private void service(Request request, Response response)
    throws IOException, ServletException
{
  if (httpContext.handleSecurity(request, response)) {

    final Thread t = Thread.currentThread();
    Stack<String> usedURIStack = threadStacks.get(t);
    if (usedURIStack == null) {
      usedURIStack = new Stack<String>();
      threadStacks.put(t, usedURIStack);
    }
    String uri =
      (String) request.getAttribute("javax.servlet.include.request_uri");
    if (uri == null) {
      uri = request.getRequestURI();
    }
    if (usedURIStack.contains(uri)) {
      throw new ServletException("Recursive include of \"" + uri + "\"");
    }

    usedURIStack.push(uri);
    try {
      if (servlet instanceof SingleThreadModel) {
        synchronized (servlet) {
          if (config == null) {
            // Activator.log.info("Serving: " + uri);
            servlet.service(request, response);
            // Activator.log.info("Served: " + uri);
          } else {
            serviceResource(request, response, config);
          }
        }
      } else {
        if (config == null) {
          // Activator.log.info(Thread.currentThread().getName() + " Serving: " + uri);
          servlet.service(request, response);
          // Activator.log.info(Thread.currentThread().getName() + " Served: " + uri);
        } else {
          serviceResource(request, response, config);
        }
      }
    } finally {
      usedURIStack.pop();
      if (usedURIStack.empty()) {
        threadStacks.remove(t);
      }
    }

  }
}
 

private void parseHtml(final String uri,
                       final ServletContext context,
                       final ServletOutputStream os,
                       final Stack<String> usedFiles)
    throws IOException
{
  if (usedFiles.contains(uri)) {
    os.print("<b><font color=\"red\">SSI Error: Recursive include: " + uri
             + "</font></b>");
    return;
  }
  usedFiles.push(uri);
  InputStream raw;
  try {
    raw = context.getResourceAsStream(uri);
  } catch (final Exception e) {
    raw = null;
  }
  if (raw == null) {
    os.print("<b><font color=\"red\">SSI Error: Error reading file: " + uri
             + "</font></b>");
    return;
  }
  final InputStream is = new BufferedInputStream(raw);

  byte c;
  boolean tagBegin = false;
  final StringBuffer buf = new StringBuffer(20);
  while ((c = (byte) is.read()) != -1) {
    if (c == '<') {
      buf.setLength(0);
      tagBegin = true;
    } else if (tagBegin && c == '>') {
      String restOfTag = buf.toString();

      final String ssi_pattern = "!--#";
      if (restOfTag.length() > ssi_pattern.length()
          && restOfTag.startsWith(ssi_pattern)) { // is this an
        // ssi tag?
        restOfTag = restOfTag.substring(ssi_pattern.length());

        final String include_pattern = "include";
        if (restOfTag.length() > include_pattern.length()
            && restOfTag.startsWith(include_pattern)) { // is
          // this
          // an
          // include
          // directive?
          restOfTag = restOfTag.substring(include_pattern.length());

          final String file_pattern = "file=\"";
          final int index = restOfTag.indexOf(file_pattern);
          if (index > 0 && Character.isWhitespace(restOfTag.charAt(0))) {
            restOfTag = restOfTag.substring(index + file_pattern.length());
            final String file = restOfTag.substring(0, restOfTag.indexOf('\"'));
            parseHtml(uri.substring(0, uri.lastIndexOf("/") + 1) + file,
                      context, os, usedFiles);
          } else {
            os.print("<b><font color=\"red\">SSI Error: Unsupported directive</font></b>");
          }
        } else {
          os.print("<b><font color=\"red\">SSI Error: Unsupported directive</font></b>");
        }
      } else {
        os.print('<');
        os.print(restOfTag);
        os.print('>');
      }

      tagBegin = false;
    } else if (tagBegin) {
      buf.append((char) c);
    } else {
      os.write(c);
    }
  }

  is.close();
  usedFiles.pop();
}
 

/**
 * uses trajans algorithm to get all strongly connected components
 *
 * @return Strongly connected components
 */
private Set<IndexedGraph> trajan(IndexedGraph graph) {
  Map<Integer, Node> nodes = createNodes(graph);
  Set<IndexedGraph> result = new HashSet<>();
  int index = 0;
  Stack<Node> tarStack = new Stack<>();
  for (Integer cat : nodes.keySet()) {
    Node u = nodes.get(cat);
    if (!nodes.get(cat).visited) {
      u.index = index;
      u.visited = true;
      u.lowlink = index;
      index++;
      u.vindex = 0;
      tarStack.push(u);
      u.caller = null;
      Node last = u;
      IndexedGraph curSCC = new IndexedGraph();
      Set<Node> curSCCnodes = new HashSet<>();
      while (true) {
        if (last.vindex < last.adjacentNodes.size()) {
          Node w = nodes.get(last.adjacentNodes.get(last.vindex));
          last.vindex++;
          if (w == null) continue;
          if (!w.visited) {
            w.caller = last;
            w.vindex = 0;
            w.index = index;
            w.visited = true;
            w.lowlink = index;
            index++;
            tarStack.push(w);
            last = w;
          } else if (tarStack.contains(w)) {
            last.lowlink = Math.min(last.lowlink, w.lowlink);
          }
        } else {
          if (last.lowlink == last.index) {
            Node top = tarStack.pop();
            curSCCnodes.add(top);

            while (!top.key.equals(last.key)) {
              top = tarStack.pop();
              curSCCnodes.add(top);
            }

            if (!curSCCnodes.isEmpty()) {
              for (Node n : curSCCnodes) {
                for (Integer adjacent : n.adjacentNodes) {
                  if (curSCCnodes.contains(nodes.get(adjacent))) curSCC.put(n.key, adjacent);
                }
              }
              if (!curSCC.isEmpty()) result.add(curSCC);
            }

            curSCCnodes.clear();
            curSCC = new IndexedGraph();
          }

          Node newLast = last.caller;
          if (newLast != null) {
            newLast.lowlink = Math.min(newLast.lowlink, last.lowlink);
            last = newLast;
          } else {
            break;
          }
        }
      }
    }
  }
  return result;
}
 

/**
 * Finds all components on the loop and convert all edges to fast-propagate.
 * @param loopComponent
 */
private static void inspectEdgesInLoop(InspectedComponent loopComponent) {
	Set<InspectedComponent> componentsInLoop = new HashSet<>();
	componentsInLoop.add(loopComponent);
	
	Stack<InspectedComponent> path = new Stack<>();
	
	InspectedComponent pointer = loopComponent.getOutputPortComponent(1);
	if (pointer != null) {
		path.push(pointer);
		while (pointer != null) {
			InspectedComponent follower = pointer.getNextComponent();
			if (follower != null) {
				if (componentsInLoop.contains(follower)) {
					componentsInLoop.addAll(path);
				} else if (!path.contains(follower)) {
					path.push(follower);
					pointer = follower;
				}
			} else {
				path.pop();
				pointer = !path.isEmpty() ? path.peek() : null;
			}
		}
	}

	//converts list of inspected components to list of engine components
	Set<Node> engineComponents = new HashSet<>();
	for (InspectedComponent component : componentsInLoop) {
		Node engineComponent = component.getComponent();
		//if one of inspected components is a Subgraph, the subgraph has to be executed in fast-propagate mode
		if (SubgraphUtils.isSubJobComponent(engineComponent.getType())) {
			//the component can be also instance of MockupComponent, which is used for cluster graph analyse 
			if (engineComponent instanceof SubgraphComponent) {
				((SubgraphComponent) engineComponent).setFastPropagateExecution(true);
			}
		}
		engineComponents.add(engineComponent);
	}

	//convert all edges to fast-propagate type
	try {
		GraphUtils.makeEdgesFastPropagate(engineComponents);
	} catch (Exception e) {
		throw new JetelRuntimeException("Phase edge detected inside the loop.", e);
	}
}
 

/**
 * Check: is the NODE n in the given stack<br>
 * <br>
 * <b>WARNING</b>: This is currently an inefficient implementation. 
 * This should be converted from a linear lookup to a constant operation.
 * 
 * @param stack
 * @param n
 * @return boolean
 */
protected boolean isInStack(Stack<NODE> stack, NODE n) {
	// TODO make this more efficient
	return stack.contains(n);
}