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:pl.chormon.ultimatelib.commands.UltimateCommand.java

protected String printUsage(UltimateCommand command, boolean addArgs, boolean addOptionalArgs,
        boolean addDesc) {
    List<String> paths = new ArrayList<>();
    String d = command.getDesc();
    List<String> a = command.getArgs();
    List<String> oa = command.getOptionalArgs();
    while (command != null) {
        paths.add(StringUtils.implode(command.getAliases(), ","));
        command = command.getParent();/*from   w w  w.j a v  a2  s.  com*/
    }
    StringBuilder sb = new StringBuilder();
    String path = StringUtils.implode(Lists.reverse(paths), " ");
    sb.append("/");
    sb.append(path);
    if (addArgs) {
        for (String s : a) {
            sb.append(" <");
            sb.append(s);
            sb.append(">");
        }
    }
    if (addOptionalArgs) {
        for (String s : oa) {
            sb.append(" [");
            sb.append(s);
            sb.append("]");
        }
    }
    if (addDesc) {
        sb.append(" &7");
        sb.append(d);
    }
    return sb.toString();
}

From source file:io.druid.query.groupby.epinephelinae.GroupByRowProcessor.java

public static Sequence<Row> process(final Query queryParam, final Sequence<Row> rows,
        final GroupByQueryConfig config, final BlockingPool<ByteBuffer> mergeBufferPool,
        final ObjectMapper spillMapper) {
    final GroupByQuery query = (GroupByQuery) queryParam;
    final GroupByQueryConfig querySpecificConfig = config.withOverrides(query);

    final AggregatorFactory[] aggregatorFactories = new AggregatorFactory[query.getAggregatorSpecs().size()];
    for (int i = 0; i < query.getAggregatorSpecs().size(); i++) {
        aggregatorFactories[i] = query.getAggregatorSpecs().get(i);
    }/*from w w  w  . j a v a  2 s. c  om*/

    final File temporaryStorageDirectory = new File(System.getProperty("java.io.tmpdir"),
            String.format("druid-groupBy-%s_%s", UUID.randomUUID(), query.getId()));

    final Number queryTimeout = query.getContextValue(QueryContextKeys.TIMEOUT, null);
    final long timeout = queryTimeout == null ? JodaUtils.MAX_INSTANT : queryTimeout.longValue();
    final List<Interval> queryIntervals = query.getIntervals();
    final Filter filter = Filters.convertToCNFFromQueryContext(query, Filters.toFilter(query.getDimFilter()));
    final RowBasedValueMatcherFactory filterMatcherFactory = new RowBasedValueMatcherFactory();
    final ValueMatcher filterMatcher = filter == null ? new BooleanValueMatcher(true)
            : filter.makeMatcher(filterMatcherFactory);

    final FilteredSequence<Row> filteredSequence = new FilteredSequence<>(rows, new Predicate<Row>() {
        @Override
        public boolean apply(Row input) {
            boolean inInterval = false;
            DateTime rowTime = input.getTimestamp();
            for (Interval queryInterval : queryIntervals) {
                if (queryInterval.contains(rowTime)) {
                    inInterval = true;
                }
            }
            if (!inInterval) {
                return false;
            }
            filterMatcherFactory.setRow(input);
            return filterMatcher.matches();
        }
    });

    return new BaseSequence<>(
            new BaseSequence.IteratorMaker<Row, CloseableGrouperIterator<RowBasedKey, Row>>() {
                @Override
                public CloseableGrouperIterator<RowBasedKey, Row> make() {
                    final List<Closeable> closeOnFailure = Lists.newArrayList();

                    try {
                        final LimitedTemporaryStorage temporaryStorage = new LimitedTemporaryStorage(
                                temporaryStorageDirectory, querySpecificConfig.getMaxOnDiskStorage());

                        closeOnFailure.add(temporaryStorage);

                        final ReferenceCountingResourceHolder<ByteBuffer> mergeBufferHolder;
                        try {
                            // This will potentially block if there are no merge buffers left in the pool.
                            if (timeout <= 0 || (mergeBufferHolder = mergeBufferPool.take(timeout)) == null) {
                                throw new QueryInterruptedException(new TimeoutException());
                            }
                            closeOnFailure.add(mergeBufferHolder);
                        } catch (InterruptedException e) {
                            throw new QueryInterruptedException(e);
                        }

                        Pair<Grouper<RowBasedKey>, Accumulator<Grouper<RowBasedKey>, Row>> pair = RowBasedGrouperHelper
                                .createGrouperAccumulatorPair(query, true, querySpecificConfig,
                                        mergeBufferHolder.get(), -1, temporaryStorage, spillMapper,
                                        aggregatorFactories);
                        final Grouper<RowBasedKey> grouper = pair.lhs;
                        final Accumulator<Grouper<RowBasedKey>, Row> accumulator = pair.rhs;
                        closeOnFailure.add(grouper);

                        final Grouper<RowBasedKey> retVal = filteredSequence.accumulate(grouper, accumulator);
                        if (retVal != grouper) {
                            throw new ResourceLimitExceededException("Grouping resources exhausted");
                        }

                        return RowBasedGrouperHelper.makeGrouperIterator(grouper, query, new Closeable() {
                            @Override
                            public void close() throws IOException {
                                grouper.close();
                                mergeBufferHolder.close();
                                CloseQuietly.close(temporaryStorage);
                            }
                        });
                    } catch (Throwable e) {
                        // Exception caught while setting up the iterator; release resources.
                        for (Closeable closeable : Lists.reverse(closeOnFailure)) {
                            CloseQuietly.close(closeable);
                        }
                        throw e;
                    }
                }

                @Override
                public void cleanup(CloseableGrouperIterator<RowBasedKey, Row> iterFromMake) {
                    iterFromMake.close();
                }
            });
}

From source file:org.sosy_lab.cpachecker.cpa.bam.BAMDataManager.java

/**
 * Get a list of states {@code [s1,s2,s3...]},
 * such that {@code expand(s1)=s2}, {@code expand(s2)=s3},...
 * The state {@code s1} is the most inner state.
 *///  w ww  .  j a v a2  s .c om
List<AbstractState> getExpandedStatesList(AbstractState state) {
    List<AbstractState> lst = new ArrayList<>();
    AbstractState tmp = state;
    while (expandedStateToReducedState.containsKey(tmp)) {
        tmp = expandedStateToReducedState.get(tmp);
        lst.add(tmp);
    }
    return Lists.reverse(lst);
}

From source file:org.sosy_lab.cpachecker.util.precondition.segkro.RefineSolverBasedItp.java

@VisibleForTesting
List<ReversedEdge> getReversedTrace(ARGPath pTrace) {
    List<ReversedEdge> result = Lists.newArrayListWithCapacity(pTrace.asEdgesList().size());
    for (CFAEdge g : Lists.reverse(pTrace.asEdgesList())) {
        if (g != null) {
            result.add(new ReversedEdge(g));
        }//w  w w .j  ava2s . co  m
    }
    return result;
}

From source file:org.apache.drill.exec.planner.physical.explain.PrelSequencer.java

public Map<Prel, OpId> go(Prel root) {

    // get fragments.
    Frag rootFrag = new Frag(root);
    frags.add(rootFrag);/*w  ww. ja  v  a  2s.c o m*/
    root.accept(this, rootFrag);

    // do depth first traversal of fragments to assign major fragment ids.
    Queue<Frag> q = Lists.newLinkedList();

    q.add(rootFrag);
    int majorFragmentId = 0;
    while (!q.isEmpty()) {
        Frag frag = q.remove();

        frag.majorFragmentId = majorFragmentId++;

        for (Frag child : frag) {
            q.add(child);
        }
    }

    // for each fragment, do a dfs of operators to assign operator ids.
    Map<Prel, OpId> ids = Maps.newIdentityHashMap();

    ids.put(rootFrag.root, new OpId(0, 0));
    for (Frag f : frags) {
        int id = 1;
        Queue<Prel> ops = Lists.newLinkedList();
        ops.add(f.root);
        while (!ops.isEmpty()) {
            Prel p = ops.remove();
            boolean isExchange = p instanceof ExchangePrel;

            if (p != f.root) { // we account for exchanges as receviers to guarantee unique identifiers.
                ids.put(p, new OpId(f.majorFragmentId, id++));
            }

            if (!isExchange || p == f.root) {
                List<Prel> children = Lists.reverse(Lists.newArrayList(p.iterator()));
                for (Prel child : children) {
                    ops.add(child);
                }
            }
        }
    }

    return ids;
}

From source file:org.apache.brooklyn.util.math.BitList.java

public BigInteger asBigInteger() {
    if (length == 0)
        return BigInteger.ZERO;
    return new BigInteger(Bytes.toArray(Lists.reverse(asByteList())));
}

From source file:org.polymap.core.mapeditor.tooling.edit.BaseLayerEditorTool.java

protected List<ILayer> selectableLayers() {
    AssocCollection<ILayer> layers = getSite().getEditor().getMap().getLayers();
    Iterable<ILayer> result = filter(layers, Layers.isVisible());
    result = filter(result, isVector());
    result = filter(result, additionalLayerFilter);

    List<ILayer> list = newArrayList(result);
    Collections.sort(list, Layers.zPrioComparator());
    return Lists.reverse(list);
}

From source file:io.crate.operation.projectors.ShardProjectorChain.java

public void prepare() {
    this.finalDownstream.prepare();
    for (Projector projector : Lists.reverse(nodeProjectors)) {
        projector.prepare();/*  w w w . ja  v  a2  s  . c o m*/
    }
    if (shardProjectionsIndex >= 0) {
        for (Projector p : shardProjectors) {
            p.prepare();
        }
    }
}

From source file:ch.puzzle.itc.mobiliar.business.generator.control.extracted.templates.GenerationUnit.java

public static Set<GenerationUnit> forAppServer(Set<GenerationUnit> work, ResourceEntity node) {
    List<GenerationUnit> current = Lists.newArrayList();

    List<GenerationUnit> reverse = Lists.reverse(Lists.newArrayList(work));
    for (GenerationUnit unit : reverse) {
        // break as soon as we hit app level
        if (unit.getSlaveResource().getResourceType().isApplicationResourceType()) {
            break;
        }//from  w w  w  .jav a2  s .  c  om
        // skip any nodes that dont match the node passed
        if (unit.getSlaveResource().getResourceType().isNodeResourceType()) {
            if (!compareResource(unit.getSlaveResource(), node)) {
                continue;
            }

        }
        current.add(unit);
    }
    return Sets.newLinkedHashSet(Lists.reverse(current));
}

From source file:org.sonar.core.platform.ComponentContainer.java

private void stopChildren() {
    // loop over a copy of list of children in reverse order, both to stop last added child first and because children
    // remove themselves from the list of children of their parent (ie. changing this.children)
    Lists.reverse(new ArrayList<>(this.children)).forEach(ComponentContainer::stopComponents);
}