Refine search
public PartitioningScheme translateOutputLayout(List<Symbol> newOutputLayout) { requireNonNull(newOutputLayout, "newOutputLayout is null"); checkArgument(newOutputLayout.size() == outputLayout.size()); Partitioning newPartitioning = partitioning.translate(symbol -> newOutputLayout.get(outputLayout.indexOf(symbol))); Optional<Symbol> newHashSymbol = hashColumn .map(outputLayout::indexOf) .map(newOutputLayout::get); return new PartitioningScheme(newPartitioning, newOutputLayout, newHashSymbol, replicateNullsAndAny, bucketToPartition); }
assertEquals(0, list.size()); assertFalse(list.contains(1)); assertFalse(list.remove((Integer)1)); assertTrue(list.contains(2)); assertFalse(list.remove((Integer)10)); assertEquals(7, list.size()); assertEquals(7, list.size()); assertEquals(i, list.get(i - 1).intValue()); assertEquals(2, list.indexOf(3)); assertFalse(list.equals(list3)); list3.add(7); assertTrue(list3.equals(list)); assertTrue(list.equals(list3)); assertEquals(list.toString(), list3.toString()); list.remove(0); assertEquals(6, list.size());
@MapFeature.Require(SUPPORTS_PUT) public void testReplaceAllRotate() { getMap() .replaceAll( (K k, V v) -> { int index = keys().asList().indexOf(k); return values().asList().get(index + 1); }); List<Entry<K, V>> expectedEntries = new ArrayList<>(); for (Entry<K, V> entry : getSampleEntries()) { int index = keys().asList().indexOf(entry.getKey()); expectedEntries.add(Helpers.mapEntry(entry.getKey(), values().asList().get(index + 1))); } expectContents(expectedEntries); }
private void changeStartTimes(List<LatticeWord> words, int newStartTime) { ArrayList<LatticeWord> toRemove = new ArrayList<>(); for (LatticeWord lw : words) { latticeWords.remove(lw); int oldStartTime = lw.startNode; lw.startNode = newStartTime; if (latticeWords.contains(lw)) { if (DEBUG) { log.info("duplicate found"); LatticeWord twin = latticeWords.get(latticeWords.indexOf(lw)); latticeWords.add(lw); if (oldStartTime != newStartTime) {
void addAttributes(Collection<AttributeInfo> attributesToAdd) { removeMethodIfDuplicatedBySetter(attributesToAdd); for (AttributeInfo info : attributesToAdd) { int existingIndex = attributeInfo.indexOf(info); if (existingIndex > -1) { // Don't allow duplicates. attributeInfo.set(existingIndex, info); } else { attributeInfo.add(info); } } }
private static void changeColumnDefinitionPosition(final ColumnAfterPositionSegment columnAfterPositionSegment, final List<ColumnMetaData> columnMetaDataList) { Optional<ColumnMetaData> columnMetaData = find(columnAfterPositionSegment.getColumnName(), columnMetaDataList); Optional<ColumnMetaData> afterColumnMetaData = find(columnAfterPositionSegment.getAfterColumnName(), columnMetaDataList); if (columnMetaData.isPresent() && afterColumnMetaData.isPresent()) { columnMetaDataList.remove(columnMetaData.get()); columnMetaDataList.add(columnMetaDataList.indexOf(afterColumnMetaData.get()) + 1, columnMetaData.get()); } }
private boolean assertValidVertex(Vertex v) { // Allows to find bugs in collapsing. // System.out.println("Asserting " + v.index); for (Triangle t : v.triangles) { for (int i = 0; i < 3; i++) { // System.out.println("check " + t.vertex[i].index); //assert (collapseCostSet.contains(t.vertex[i])); assert (find(collapseCostSet, t.vertex[i])); assert (t.vertex[i].edges.contains(new Edge(t.vertex[i].collapseTo))); for (int n = 0; n < 3; n++) { if (i != n) { int id = t.vertex[i].edges.indexOf(new Edge(t.vertex[n])); Edge ed = t.vertex[i].edges.get(id); //assert (ed.collapseCost != UNINITIALIZED_COLLAPSE_COST); } else { assert (!t.vertex[i].edges.contains(new Edge(t.vertex[n]))); } } } } return true; }
@Override public int indexOf(Object o) { if (!(o instanceof List)) { return -1; } List<?> list = (List<?>) o; if (list.size() != axes.size()) { return -1; } ListIterator<?> itr = list.listIterator(); int computedIndex = 0; while (itr.hasNext()) { int axisIndex = itr.nextIndex(); int elemIndex = axes.get(axisIndex).indexOf(itr.next()); if (elemIndex == -1) { return -1; } computedIndex += elemIndex * axesSizeProduct[axisIndex + 1]; } return computedIndex; }
public void setAlternateRecipientInfo(List<Recipient> recipients) { this.recipients = recipients; int indexOfCurrentRecipient = recipients.indexOf(currentRecipient); if (indexOfCurrentRecipient >= 0) { currentRecipient = recipients.get(indexOfCurrentRecipient); } recipients.remove(currentRecipient); notifyDataSetChanged(); }
private void checkValueProviders(ResourceMethod method) { List<? extends Function<ContainerRequest, ?>> valueProviders = ParameterValueHelper.createValueProviders(valueParamProviders, method.getInvocable()); if (valueProviders.contains(null)) { int index = valueProviders.indexOf(null); Errors.fatal(method, LocalizationMessages.ERROR_PARAMETER_MISSING_VALUE_PROVIDER(index, method.getInvocable() .getHandlingMethod())); } }
private void selectWindow(@NotNull EditorWindow currentWindow, @NotNull List<EditorWindow> windows, int relativePosition) { final int pos = windows.indexOf(currentWindow); final int selected = pos + relativePosition; final int normalized = Math.max(0, Math.min(selected, windows.size() - 1)); windows.get(normalized).setAsCurrentWindow(true); }
/** * Inserts the given specific portion of an uncollapsed relation back into the * targetList * * @param specific Specific relation to put in. * @param relnTgtNode Node governed by the uncollapsed relation * @param tgtList Target List of words */ private void insertSpecificIntoList(String specific, IndexedWord relnTgtNode, List<IndexedWord> tgtList) { int currIndex = tgtList.indexOf(relnTgtNode); Set<IndexedWord> descendants = descendants(relnTgtNode); IndexedWord specificNode = new IndexedWord(); specificNode.set(CoreAnnotations.LemmaAnnotation.class, specific); specificNode.set(CoreAnnotations.TextAnnotation.class, specific); specificNode.set(CoreAnnotations.OriginalTextAnnotation.class, specific); while ((currIndex >= 1) && descendants.contains(tgtList.get(currIndex - 1))) { currIndex--; } tgtList.add(currIndex, specificNode); }