Refine search
private List<AlarmCallbackHistory> toAbstractListType(List<AlarmCallbackHistoryImpl> histories) { final List<AlarmCallbackHistory> result = Lists.newArrayListWithCapacity(histories.size()); result.addAll(histories); return result; }
private static List<DimFilter> negateAll(final List<DimFilter> children) { final List<DimFilter> newChildren = Lists.newArrayListWithCapacity(children.size()); for (final DimFilter child : children) { newChildren.add(negate(child)); } return newChildren; }
public ExecutorProvider(int numThreads, ThreadFactory threadFactory) { checkArgument(numThreads > 0); this.numThreads = numThreads; checkNotNull(threadFactory); executors = Lists.newArrayListWithCapacity(numThreads); for (int i = 0; i < numThreads; i++) { executors.add(Executors.newSingleThreadScheduledExecutor(threadFactory)); } }
public DumpMerger(List<Dump> dumps) { minHeap = new PriorityQueue<>(dumps.size(), new Comparator<Entry<byte[], Integer>>() { @Override public int compare(Entry<byte[], Integer> o1, Entry<byte[], Integer> o2) { return bytesComparator.compare(o1.getKey(), o2.getKey()); } }); dumpIterators = Lists.newArrayListWithCapacity(dumps.size()); dumpCurrentValues = Lists.newArrayListWithCapacity(dumps.size()); Iterator<Pair<byte[], byte[]>> it; for (int i = 0; i < dumps.size(); i++) { it = dumps.get(i).iterator(); dumpCurrentValues.add(i, null); if (it.hasNext()) { dumpIterators.add(i, it); enqueueFromDump(i); } else { dumpIterators.add(i, null); } } }
checkNotNull(executorService); checkNotNull(unit); int ntasks = tasks.size(); checkArgument(ntasks > 0); List<Future<T>> futures = Lists.newArrayListWithCapacity(ntasks); BlockingQueue<Future<T>> futureQueue = Queues.newLinkedBlockingQueue(); long timeoutNanos = unit.toNanos(timeout); Iterator<? extends Callable<T>> it = tasks.iterator(); futures.add(submitAndAddQueueListener(executorService, it.next(), futureQueue)); --ntasks; int active = 1; if (ntasks > 0) { --ntasks; futures.add(submitAndAddQueueListener(executorService, it.next(), futureQueue)); ++active; } else if (active == 0) {
@Override public void purgeWindow(Object state, TimeWindow window) { LOG.info("purging window: {}", window); final HashMap<String, Integer> counts = (HashMap<String, Integer>) state; List<String> keys = Lists.newArrayList(counts.keySet()); Collections.sort(keys, new Comparator<String>() { @Override public int compare(String o1, String o2) { return -counts.get(o1).compareTo(counts.get(o2)); } }); List<Object> pairs = Lists.newArrayListWithCapacity(n); for (int i = 0; i < n; i++) { pairs.add(new Pair<>(keys.get(i), counts.get(keys.get(i)))); } collector.emit(pairs); }
if (collection.size() > 0) { List<byte[]> byteArrayList = Lists.newArrayListWithCapacity(collection.size()); int totalByteLength = 0; for (T eachItem : collection) { final byte[] byteArray = serializeFunction.apply(eachItem); totalByteLength += byteArray.length; byteArrayList.add(byteArray); final int bufSize = Integer.BYTES + separator.length * (byteArrayList.size() - 1) + totalByteLength; final ByteBuffer buffer = ByteBuffer.allocate(bufSize) .putInt(byteArrayList.size()) .put(iterator.next());
dimConversions = Lists.newArrayListWithCapacity(adapters.size()); for (int i = 0; i < adapters.size(); ++i) { dimConversions.add(null); Indexed<String>[] dimValueLookups = new Indexed[adapters.size() + 1]; for (int i = 0; i < adapters.size(); i++) { @SuppressWarnings("MustBeClosedChecker") // we register dimValues in the closer Indexed<String> dimValues = closer.register(adapters.get(i).getDimValueLookup(dimensionName)); if (dimValues != null && !allNull(dimValues)) { dimHasValues = true;
public EnumerableRel createEnumerable(OLAPRel parent) { ArrayList<EnumerableRel> enumInputs = null; List<RelNode> children = parent.getInputs(); if (children != null) { enumInputs = Lists.newArrayListWithCapacity(children.size()); for (RelNode child : children) { enumInputs.add(createEnumerable((OLAPRel) child)); } } EnumerableRel result = parent.implementEnumerable(enumInputs); relContexts.put(result, parent.getContext()); return result; }
@Override // SecondaryNameNodeInfoMXBean public String[] getCheckpointDirectories() { ArrayList<String> r = Lists.newArrayListWithCapacity(checkpointDirs.size()); for (URI d : checkpointDirs) { r.add(d.toString()); } return r.toArray(new String[r.size()]); }
/** * Pack the list of {@code WorkUnit}s into {@code MultiWorkUnit}s. * * TODO: this is currently a simple round-robin packing. More sophisticated bin packing may be necessary * if the round-robin approach leads to mapper skew. */ private static List<WorkUnit> pack(List<WorkUnit> workUnits, int numOfMultiWorkunits) { Preconditions.checkArgument(numOfMultiWorkunits > 0); if (workUnits.size() <= numOfMultiWorkunits) { return workUnits; } List<WorkUnit> result = Lists.newArrayListWithCapacity(numOfMultiWorkunits); for (int i = 0; i < numOfMultiWorkunits; i++) { result.add(MultiWorkUnit.createEmpty()); } for (int i = 0; i < workUnits.size(); i++) { ((MultiWorkUnit) result.get(i % numOfMultiWorkunits)).addWorkUnit(workUnits.get(i)); } return result; }
public static <V> List<Version> getVersions(List<Versioned<V>> versioneds) { List<Version> versions = Lists.newArrayListWithCapacity(versioneds.size()); for(Versioned<?> versioned: versioneds) versions.add(versioned.getVersion()); return versions; }
protected List<OLAPContext> listContextsHavingScan() { // Context has no table scan is created by OLAPJoinRel which looks like // (sub-query) as A join (sub-query) as B // No realization needed for such context. int size = OLAPContext.getThreadLocalContexts().size(); List<OLAPContext> result = Lists.newArrayListWithCapacity(size); for (int i = 0; i < size; i++) { OLAPContext ctx = OLAPContext.getThreadLocalContextById(i); if (ctx.firstTableScan != null) result.add(ctx); } return result; }
private MeshAnimationData createAnimation(MD5 md5) { List<String> boneNames = Lists.newArrayListWithCapacity(md5.numJoints); TIntList boneParents = new TIntArrayList(md5.numJoints); for (int i = 0; i < md5.numJoints; ++i) { boneNames.add(md5.joints[i].name); boneParents.add(md5.joints[i].parent); List<Vector3f> rawRotations = Lists.newArrayListWithExpectedSize(md5.numJoints); for (int i = 0; i < md5.numJoints; ++i) { positions.add(new Vector3f(md5.baseFramePosition[i])); rawRotations.add(new Vector3f(md5.baseFrameOrientation[i])); int compIndex = 0; if ((md5.joints[jointIndex].flags & POSITION_X_FLAG) != 0) { positions.get(jointIndex).x = frame.components[md5.joints[jointIndex].startIndex + compIndex]; compIndex++; positions.get(jointIndex).y = frame.components[md5.joints[jointIndex].startIndex + compIndex]; compIndex++; positions.get(jointIndex).z = frame.components[md5.joints[jointIndex].startIndex + compIndex]; compIndex++;
/** * Gets an iterator representing an immutable snapshot of all subscribers to the given event at * the time this method is called. */ Iterator<Subscriber> getSubscribers(Object event) { ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass()); List<Iterator<Subscriber>> subscriberIterators = Lists.newArrayListWithCapacity(eventTypes.size()); for (Class<?> eventType : eventTypes) { CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); if (eventSubscribers != null) { // eager no-copy snapshot subscriberIterators.add(eventSubscribers.iterator()); } } return Iterators.concat(subscriberIterators.iterator()); }
public List<Vector3f> getBindPoseVertexPositions() { List<Vector3f> positions = Lists.newArrayListWithCapacity(bones.size()); List<Quat4f> rotations = Lists.newArrayListWithCapacity(getBones().size()); for (Bone bone : bones) { positions.add(bone.getObjectPosition()); rotations.add(bone.getObjectRotation()); } return getVertexPositions(positions, rotations); }
@Override public Iterator<UIWidget> iterator() { List<UIWidget> widgets = Lists.newArrayListWithCapacity(contents.size()); widgets.addAll(contents.stream().map(info -> info.widget).collect(Collectors.toList())); return widgets.iterator(); }
public static List<byte[]> persistAll(Iterable<? extends Persistable> persistables) { List<byte[]> output; if (persistables instanceof Collection) { output = Lists.newArrayListWithCapacity(((Collection<? extends Persistable>) persistables).size()); } else { output = Lists.newArrayList(); } return persistAll(persistables, output); }
IllegalAccessException, InvocationTargetException, FactoryMethodReturnsNullException { List<Parameter> params = factory.getParameters(); List<FreshValueGenerator> argGenerators = Lists.newArrayListWithCapacity(params.size()); List<Object> args = Lists.newArrayListWithCapacity(params.size()); for (Parameter param : params) { FreshValueGenerator generator = newFreshValueGenerator(); argGenerators.add(generator); args.add(generateDummyArg(param, generator)); argGroups.add(ImmutableList.of(args, equalArgs)); EqualsTester tester = new EqualsTester( for (int i = 0; i < params.size(); i++) { List<Object> newArgs = Lists.newArrayList(args); Object newArg = argGenerators.get(i).generateFresh(params.get(i).getType()); if (newArg == null || Objects.equal(args.get(i), newArg)) { if (params.get(i).getType().getRawType().isEnum()) { continue; // Nothing better we can do if it's single-value enum
private static List<AnnotationMirror> asCaching(List<? extends AnnotationMirror> mirrors) { List<AnnotationMirror> cachingMirrors = Lists.newArrayListWithCapacity(mirrors.size()); for (AnnotationMirror mirror : mirrors) { cachingMirrors.add(new CachingAnnotationMirror(mirror)); } return cachingMirrors; }