Example usage for com.google.common.collect Lists reverse

Introduction

In this page you can find the example usage for com.google.common.collect Lists reverse.

Prototype

@CheckReturnValue
public static <T> List<T> reverse(List<T> list)

Source Link

Document

Returns a reversed view of the specified list.

Usage

From source file:org.diqube.metadata.inspect.TableMetadataInspector.java

/**
 * Identifies all interesting {@link FieldMetadata} for a given columnName, as it might be used in a diql query.
 * /*from   ww w  .  j  av a  2  s. com*/
 * <p>
 * The interesting {@link FieldMetadata}s are the ones of the field corresponding to the column itself and all its
 * parent fields.
 * 
 * @param columnName
 *          The column name as it might be used in a diql query. It might contain
 *          {@link RepeatedColumnNameGenerator#allEntriesIdentifyingSubstr()} etc.
 * @return A list of the {@link FieldMetadata} of all fields that are interesting. The list is ordered from the most
 *         generic (parent) to the most specific field.
 * @throws ColumnNameInvalidException
 *           If the columnName is not valid according to the metadata.
 */
public List<FieldMetadata> findAllFieldMetadata(String columnName) throws ColumnNameInvalidException {
    List<FieldMetadata> m = new ArrayList<>();
    String fieldName = FieldUtil.toFieldName(columnName);
    if (columnName.indexOf("..") > -1 || columnName.startsWith(".") || columnName.endsWith("."))
        throw new ColumnNameInvalidException(
                "Column name contains dots at at least one invalid position: " + columnName);

    String firstColName = columnName;
    boolean shouldBeLengthColumn = false;
    if (FieldUtil.isLengthColumn(fieldName)) {
        firstColName = columnName.substring(0, columnName.length() - FieldUtil.LENGTH.length());
        fieldName = fieldName.substring(0, fieldName.length() - FieldUtil.LENGTH.length());
        shouldBeLengthColumn = true;
    }

    findCurrentFieldMetadataAndParents(columnName, firstColName, fieldName, shouldBeLengthColumn, m);
    return Lists.reverse(m);
}

From source file:grakn.core.graql.reasoner.rule.RuleUtils.java

/**
 * @param rules to be stratified (ordered)
 * @return stream of rules ordered in terms of priority (high priority first)
 *//*from ww w . java2s  . c om*/
public static Stream<InferenceRule> stratifyRules(Set<InferenceRule> rules) {
    if (rules.stream().allMatch(r -> r.getBody().isPositive())) {
        return rules.stream().sorted(Comparator.comparing(r -> -r.resolutionPriority()));
    }
    Multimap<Type, InferenceRule> typeMap = HashMultimap.create();
    rules.forEach(r -> r.getRule().thenTypes().flatMap(Type::sups).forEach(t -> typeMap.put(t, r)));
    HashMultimap<Type, Type> typeGraph = persistedTypeSubGraph(rules);
    List<Set<Type>> scc = new TarjanSCC<>(typeGraph).getSCC();
    return Lists.reverse(scc).stream().flatMap(strata -> strata.stream().flatMap(t -> typeMap.get(t).stream())
            .sorted(Comparator.comparing(r -> -r.resolutionPriority())));
}

From source file:org.caleydo.view.bicluster.elem.AllClustersElement.java

/**
 * focus on the previous logical cluster
 *//*from  ww  w . j ava2 s  .  co  m*/
public void focusNext() {
    if (this.focussedElement == null)
        return;
    focusPrevious(Lists.reverse(getSortedClusters()));
}

From source file:org.testfx.robot.impl.TypeRobotImpl.java

private void pushKeyCodeCombination(KeyCode... keyCodeCombination) {
    List<KeyCode> keyCodesForwards = Lists.newArrayList(keyCodeCombination);
    List<KeyCode> keyCodesBackwards = Lists.reverse(keyCodesForwards);
    keyboardRobot.pressNoWait(toKeyCodeArray(keyCodesForwards));
    keyboardRobot.release(toKeyCodeArray(keyCodesBackwards));
}

From source file:org.glowroot.common.model.MutableProfile.java

public void merge(List<StackTraceElement> stackTraceElements, Thread.State threadState) {
    PeekingIterator<StackTraceElement> i = Iterators
            .peekingIterator(Lists.reverse(stackTraceElements).iterator());
    ProfileNode lastMatchedNode = null;//from  w w  w.  jav a 2s.c  om
    List<ProfileNode> mergeIntoNodes = rootNodes;

    boolean lookingForMatch = true;
    while (i.hasNext()) {
        StackTraceElement stackTraceElement = i.next();
        String fullClassName = stackTraceElement.getClassName();
        int index = fullClassName.lastIndexOf('.');
        String packageName;
        String className;
        if (index == -1) {
            packageName = "";
            className = fullClassName;
        } else {
            packageName = fullClassName.substring(0, index);
            className = fullClassName.substring(index + 1);
        }
        int packageNameIndex = getNameIndex(packageName, packageNameIndexes, packageNames);
        int classNameIndex = getNameIndex(className, classNameIndexes, classNames);
        int methodNameIndex = getNameIndex(
                MoreObjects.firstNonNull(stackTraceElement.getMethodName(), "<null method name>"),
                methodNameIndexes, methodNames);
        int fileNameIndex = getNameIndex(Strings.nullToEmpty(stackTraceElement.getFileName()), fileNameIndexes,
                fileNames);
        int lineNumber = stackTraceElement.getLineNumber();
        Profile.LeafThreadState leafThreadState = i.hasNext() ? Profile.LeafThreadState.NONE
                : getThreadState(threadState);

        ProfileNode node = null;
        if (lookingForMatch) {
            for (ProfileNode childNode : mergeIntoNodes) {
                if (isMatch(childNode, packageNameIndex, classNameIndex, methodNameIndex, fileNameIndex,
                        lineNumber, leafThreadState)) {
                    node = childNode;
                    break;
                }
            }
        }
        if (node == null) {
            lookingForMatch = false;
            node = new ProfileNode(packageNameIndex, classNameIndex, methodNameIndex, fileNameIndex, lineNumber,
                    leafThreadState);
            mergeIntoNodes.add(node);
        }
        node.sampleCount++;
        lastMatchedNode = node;
        mergeIntoNodes = lastMatchedNode.childNodes;
    }
}

From source file:com.synformation.boundary.ClosedBoundary.java

public List<Way> getReversedWayList() {
    List<Way> reversedListView = Lists.reverse(wayList);
    List<Way> newReversedList = reversedListView.stream().map(way -> new Way(reverseNodeList(way.getNodes())))
            .collect(Collectors.toCollection(LinkedList::new));
    return newReversedList;
}

From source file:org.jetbrains.jet.codegen.TailRecursionCodegen.java

private void assignParameterValues(CallableDescriptor fd, CallableMethod callableMethod,
        List<ResolvedValueArgument> valueArguments) {
    List<Type> types = callableMethod.getValueParameterTypes();
    for (ValueParameterDescriptor parameterDescriptor : Lists.reverse(fd.getValueParameters())) {
        ResolvedValueArgument arg = valueArguments.get(parameterDescriptor.getIndex());
        Type type = types.get(parameterDescriptor.getIndex());

        if (arg instanceof ExpressionValueArgument) {
            ExpressionValueArgument ev = (ExpressionValueArgument) arg;
            ValueArgument argument = ev.getValueArgument();
            JetExpression argumentExpression = argument == null ? null : argument.getArgumentExpression();

            if (argumentExpression instanceof JetSimpleNameExpression) {
                ResolvedCall<? extends CallableDescriptor> resolvedCall = state.getBindingContext()
                        .get(RESOLVED_CALL, argumentExpression);
                if (resolvedCall != null
                        && resolvedCall.getResultingDescriptor().equals(parameterDescriptor.getOriginal())) {
                    // do nothing: we shouldn't store argument to itself again
                    AsmUtil.pop(v, type);
                    continue;
                }//from ww w . j  av a  2  s.c  om
            }
            //assign the parameter below
        } else if (arg instanceof DefaultValueArgument) {
            AsmUtil.pop(v, type);
            DefaultParameterValueLoader.DEFAULT.putValueOnStack(parameterDescriptor, codegen);
        } else if (arg instanceof VarargValueArgument) {
            // assign the parameter below
        } else {
            throw new UnsupportedOperationException("Unknown argument type: " + arg + " in " + fd);
        }

        store(parameterDescriptor, type);
    }
}

From source file:de.se_rwth.langeditor.texteditor.hyperlinks.HyperlinkDetectorImpl.java

private Optional<ASTNode> getEnclosingASTNode(IRegion region) {
    return currentModelState.get()
            .flatMap(currentModelState -> ParseTrees
                    .getTerminalBySourceCharIndex(currentModelState.getRootContext(), region.getOffset()))
            .map(Trees::getAncestors).map(ancestors -> Lists.reverse(ancestors)).orElse(Collections.emptyList())
            .stream().filter(ParseTree.class::isInstance).map(ParseTree.class::cast).map(Nodes::getAstNode)
            .filter(Optional::isPresent).map(Optional::get).findFirst();
}

From source file:io.v.baku.sample.travel.TravelService.java

/**
 * This method finds the last certificate in our blessing's certificate
 * chains whose extension contains an '@'. We will assume that extension to
 * represent our username.//  ww  w  .java  2  s .  c  o m
 */
private static String mountNameFromBlessings(Blessings blessings) {
    for (List<VCertificate> chain : blessings.getCertificateChains()) {
        for (VCertificate certificate : Lists.reverse(chain)) {
            if (certificate.getExtension().contains("@")) {
                return certificate.getExtension();
            }
        }
    }
    return "";
}

From source file:org.sonar.javascript.checks.ArgumentTypesCheck.java

private void check(IntFunction<Constraint> signature, ProgramState currentState, List<Tree> arguments) {
    List<SymbolicValue> argumentValues = new ArrayList<>();

    for (int i = 0; i < arguments.size(); i++) {
        argumentValues.add(currentState.peekStack(i));
    }//from   w w  w .j a va2s  .  c o  m

    argumentValues = Lists.reverse(argumentValues);
    for (int i = 0; i < argumentValues.size(); i++) {
        Tree argumentTree = arguments.get(i);
        String errorMessage = errorMessage(signature.apply(i), currentState, argumentValues.get(i));
        if (errorMessage == null) {
            hasIssue.put(argumentTree, Optional.empty());

        } else if (!hasIssue.containsKey(argumentTree)) {
            hasIssue.put(argumentTree, Optional.of(errorMessage));
        }
    }
}