Java Deque.iterator方法代码示例

import java.util.Deque; //导入方法依赖的package包/类
protected void setupStepReturnPredicateBreak() {
	final IExecutionEngine seqEngine = (IExecutionEngine) engine;
	final Deque<MSEOccurrence> stack = seqEngine.getCurrentStack();
	if (stack.size() > 1) {
		final Iterator<MSEOccurrence> it = stack.iterator();
		it.next();
		addPredicateBreak(new BiPredicate<IExecutionEngine, MSEOccurrence>() {
			// The operation we want to step return
			private MSEOccurrence steppedReturn = it.next();

			@Override
			public boolean test(IExecutionEngine t, MSEOccurrence u) {
				// We finished stepping over once the mseoccurrence is not
				// there anymore
				return !seqEngine.getCurrentStack().contains(steppedReturn);
			}
		});
	}
}
 

import java.util.Deque; //导入方法依赖的package包/类
@Override
public void frameAdded(AbstractAjpClientStreamSinkChannel addedFrame, List<AbstractAjpClientStreamSinkChannel> pendingFrames, Deque<AbstractAjpClientStreamSinkChannel> holdFrames) {
    Iterator<AbstractAjpClientStreamSinkChannel> it = holdFrames.iterator();
    while (it.hasNext()){
        AbstractAjpClientStreamSinkChannel pending = it.next();
        if(pending instanceof AjpClientRequestClientStreamSinkChannel) {
            SendFrameHeader header = ((AjpClientRequestClientStreamSinkChannel) pending).generateSendFrameHeader();
            if(header.getByteBuffer() != null) {
                pendingFrames.add(pending);
                it.remove();
            } else {
                //we clear the header, as we want to generate a new real header when the flow control window is updated
                ((AjpClientRequestClientStreamSinkChannel) pending).clearHeader();
            }
        }
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
@Override
public void frameAdded(SpdyStreamSinkChannel addedFrame, List<SpdyStreamSinkChannel> pendingFrames, Deque<SpdyStreamSinkChannel> holdFrames) {
    Iterator<SpdyStreamSinkChannel> it = holdFrames.iterator();
    while (it.hasNext()){
        SpdyStreamSinkChannel pending = it.next();
        if(pending instanceof SpdyStreamStreamSinkChannel) {
            SendFrameHeader header = ((SpdyStreamStreamSinkChannel) pending).generateSendFrameHeader();
            if(header.getByteBuffer() != null) {
                pendingFrames.add(pending);
                it.remove();
            } else {
                //we clear the header, as we want to generate a new real header when the flow control window is updated
                ((SpdyStreamStreamSinkChannel) pending).clearHeader();
            }
        }
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
private void processOperationToken(
		final Queue<Token> outputQueue,
		final Deque<Token> operationStack,
		final Token token ) {
	if ( outputQueue.isEmpty() ) {
		throw new SyntaxExpressionException(
				"Found operation before an operand." );
	}
	final Operation operation = (Operation) token.getValue();
	for ( final Iterator<Token> tokenIterator = operationStack.iterator(); tokenIterator
			.hasNext(); ) {
		final Token stackedOperationToken = tokenIterator.next();
		if ( stackedOperationToken.getType().isGrouper() ) {
			break;
		}
		if ( stackedOperationToken.getType().isOperation() ) {
			final Operation stackedOperation = (Operation) stackedOperationToken
					.getValue();
			if ( stackedOperation.getPrecedence() >= operation
					.getPrecedence()
					&& operation.getAssociativeness() == Associativeness.LEFT ) {
				tokenIterator.remove();
				outputQueue.offer( stackedOperationToken );
			}
		}
	}
	operationStack.push( token );
}
 

import java.util.Deque; //导入方法依赖的package包/类
private void processGrouperTypeToken(
		final Queue<Token> outputQueue,
		final Deque<Token> operationStack,
		final Token token ) {
	final GrouperType grouperType = (GrouperType) token.getValue();
	if ( grouperType == GrouperType.LEFT_PARENTHESES ) {
		operationStack.push( token );
		return;
	}
	checkArgument( grouperType == GrouperType.RIGHT_PARENTHESES );
	boolean foundLeftParentheses = false;
	for ( final Iterator<Token> tokenIterator = operationStack.iterator(); tokenIterator
			.hasNext(); ) {
		final Token stackedOperationToken = tokenIterator.next();
		if ( isLeftParentheses( stackedOperationToken ) ) {
			foundLeftParentheses = true;
			tokenIterator.remove();
			break;
		}
		tokenIterator.remove();
		outputQueue.offer( stackedOperationToken );
	}
	if ( ! foundLeftParentheses ) {
		throw new SyntaxExpressionException(
				"Mismatched right parentheses." );
	}
}
 

import java.util.Deque; //导入方法依赖的package包/类
public List<Certificate> clean(List<Certificate> chain) throws SSLPeerUnverifiedException {
    Deque<Certificate> queue = new ArrayDeque(chain);
    List<Certificate> result = new ArrayList();
    result.add(queue.removeFirst());
    boolean foundTrustedCertificate = false;
    int c = 0;
    while (c < 9) {
        X509Certificate toVerify = (X509Certificate) result.get(result.size() - 1);
        X509Certificate trustedCert = this.trustRootIndex.findByIssuerAndSignature(toVerify);
        if (trustedCert != null) {
            if (result.size() > 1 || !toVerify.equals(trustedCert)) {
                result.add(trustedCert);
            }
            if (!verifySignature(trustedCert, trustedCert)) {
                foundTrustedCertificate = true;
                c++;
            }
        } else {
            Iterator<Certificate> i = queue.iterator();
            while (i.hasNext()) {
                X509Certificate signingCert = (X509Certificate) i.next();
                if (verifySignature(toVerify, signingCert)) {
                    i.remove();
                    result.add(signingCert);
                    c++;
                }
            }
            if (!foundTrustedCertificate) {
                throw new SSLPeerUnverifiedException("Failed to find a trusted cert that " +
                        "signed " + toVerify);
            }
        }
        return result;
    }
    throw new SSLPeerUnverifiedException("Certificate chain too long: " + result);
}
 

import java.util.Deque; //导入方法依赖的package包/类
public void run(Deque<Integer> deq) {
    while (deq.size() > 1) {
        Iterator<Integer> it = deq.iterator();
        it.next(); it.remove();
        it = deq.descendingIterator();
        it.next(); it.remove();
    }
    System.out.println(deq);
}
 

import java.util.Deque; //导入方法依赖的package包/类
private static Deque<Token> getGroup(Deque<Token> deque, EnumTokenType tokenTypeEnd, boolean tokenEndRequired) throws ParseException
{
    Deque<Token> deque1 = new ArrayDeque();
    int i = 0;
    Iterator iterator = deque1.iterator();

    while (iterator.hasNext())
    {
        Token token = (Token)iterator.next();
        iterator.remove();

        if (i == 0 && token.getType() == tokenTypeEnd)
        {
            return deque1;
        }

        deque1.add(token);

        if (token.getType() == EnumTokenType.BRACKET_OPEN)
        {
            ++i;
        }

        if (token.getType() == EnumTokenType.BRACKET_CLOSE)
        {
            --i;
        }
    }

    if (tokenEndRequired)
    {
        throw new ParseException("Missing end token: " + tokenTypeEnd);
    }
    else
    {
        return deque1;
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
/**
 * Returns a cleaned chain for {@code chain}.
 *
 * <p>This method throws if the complete chain to a trusted CA certificate cannot be constructed.
 * This is unexpected unless the trust root index in this class has a different trust manager than
 * what was used to establish {@code chain}.
 */
@Override public List<Certificate> clean(List<Certificate> chain, String hostname)
    throws SSLPeerUnverifiedException {
  Deque<Certificate> queue = new ArrayDeque<>(chain);
  List<Certificate> result = new ArrayList<>();
  result.add(queue.removeFirst());
  boolean foundTrustedCertificate = false;

  followIssuerChain:
  for (int c = 0; c < MAX_SIGNERS; c++) {
    X509Certificate toVerify = (X509Certificate) result.get(result.size() - 1);

    // If this cert has been signed by a trusted cert, use that. Add the trusted certificate to
    // the end of the chain unless it's already present. (That would happen if the first
    // certificate in the chain is itself a self-signed and trusted CA certificate.)
    X509Certificate trustedCert = trustRootIndex.findByIssuerAndSignature(toVerify);
    if (trustedCert != null) {
      if (result.size() > 1 || !toVerify.equals(trustedCert)) {
        result.add(trustedCert);
      }
      if (verifySignature(trustedCert, trustedCert)) {
        return result; // The self-signed cert is a root CA. We're done.
      }
      foundTrustedCertificate = true;
      continue;
    }

    // Search for the certificate in the chain that signed this certificate. This is typically
    // the next element in the chain, but it could be any element.
    for (Iterator<Certificate> i = queue.iterator(); i.hasNext(); ) {
      X509Certificate signingCert = (X509Certificate) i.next();
      if (verifySignature(toVerify, signingCert)) {
        i.remove();
        result.add(signingCert);
        continue followIssuerChain;
      }
    }

    // We've reached the end of the chain. If any cert in the chain is trusted, we're done.
    if (foundTrustedCertificate) {
      return result;
    }

    // The last link isn't trusted. Fail.
    throw new SSLPeerUnverifiedException(
        "Failed to find a trusted cert that signed " + toVerify);
  }

  throw new SSLPeerUnverifiedException("Certificate chain too long: " + result);
}
 

import java.util.Deque; //导入方法依赖的package包/类
private static void enqueueChildren(final Node node, final Class<?> nodeClass, final List<Field> children) {
    final Deque<Class<?>> stack = new ArrayDeque<>();

    /**
     * Here is some ugliness that can be overcome by proper ChildNode annotations
     * with proper orders. Right now we basically sort all classes up to Node
     * with super class first, as this often is the natural order, e.g. base
     * before index for an IndexNode.
     *
     * Also there are special cases as this is not true for UnaryNodes(lhs) and
     * BinaryNodes extends UnaryNode (with lhs), and TernaryNodes.
     *
     * TODO - generalize traversal with an order built on annotations and this
     * will go away.
     */
    Class<?> clazz = nodeClass;
    do {
        stack.push(clazz);
        clazz = clazz.getSuperclass();
    } while (clazz != null);

    if (node instanceof TernaryNode) {
        // HACK juggle "third"
        stack.push(stack.removeLast());
    }
    // HACK change operator order for BinaryNodes to get lhs first.
    final Iterator<Class<?>> iter = node instanceof BinaryNode ? stack.descendingIterator() : stack.iterator();

    while (iter.hasNext()) {
        final Class<?> c = iter.next();
        for (final Field f : c.getDeclaredFields()) {
            try {
                f.setAccessible(true);
                final Object child = f.get(node);
                if (child == null) {
                    continue;
                }

                if (child instanceof Node) {
                    children.add(f);
                } else if (child instanceof Collection) {
                    if (!((Collection<?>)child).isEmpty()) {
                        children.add(f);
                    }
                }
            } catch (final IllegalArgumentException | IllegalAccessException e) {
                return;
            }
        }
    }
}
 

import java.util.Deque; //导入方法依赖的package包/类
private static void enqueueChildren(final Node node, final Class<?> nodeClass, final List<Field> children) {
    final Deque<Class<?>> stack = new ArrayDeque<>();

    /**
     * Here is some ugliness that can be overcome by proper ChildNode annotations
     * with proper orders. Right now we basically sort all classes up to Node
     * with super class first, as this often is the natural order, e.g. base
     * before index for an IndexNode.
     *
     * Also there are special cases as this is not true for UnaryNodes(lhs) and
     * BinaryNodes extends UnaryNode (with lhs), and TernaryNodes.
     *
     * TODO - generalize traversal with an order built on annotations and this
     * will go away.
     */
    Class<?> clazz = nodeClass;
    do {
        stack.push(clazz);
        clazz = clazz.getSuperclass();
    } while (clazz != null);

    if (node instanceof TernaryNode) {
        // HACK juggle "third"
        stack.push(stack.removeLast());
    }
    // HACK change operator order for BinaryNodes to get lhs first.
    final Iterator<Class<?>> iter = node instanceof BinaryNode ? stack.descendingIterator() : stack.iterator();

    while (iter.hasNext()) {
        final Class<?> c = iter.next();
        for (final Field f : accessibleFields.get(c)) {
            try {
                final Object child = f.get(node);
                if (child == null) {
                    continue;
                }

                if (child instanceof Node) {
                    children.add(f);
                } else if (child instanceof Collection) {
                    if (!((Collection<?>)child).isEmpty()) {
                        children.add(f);
                    }
                }
            } catch (final IllegalArgumentException | IllegalAccessException e) {
                return;
            }
        }
    }
}