public UnifiedMap(Pair<K, V>... pairs) { this(Math.max(pairs.length, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); ArrayIterate.forEach(pairs, new MapCollectProcedure<Pair<K, V>, K, V>( this, Functions.firstOfPair(), Functions.secondOfPair())); }
/** * Alias for identity(). Inlineable. * * @see #identity() */ public static <T> Function<T, T> getPassThru() { return Functions.identity(); }
@Override public <P, V> ParallelIterable<V> collectWith(Function2<? super T, ? super P, ? extends V> function, P parameter) { return this.collect(Functions.bind(function, parameter)); }
@Override public Function<String, String> convertDbObjectName() { return Functions.getPassThru(); }
private MutableList<IndexMap> getColumnsOrderedBySelectivity(MutableList<UnmatchedIndexMap> allMissingRows, MutableList<UnmatchedIndexMap> allSurplusRows, MutableList<IndexMap> columnIndices) { LOGGER.info("Calculating column selectivity"); MutableList<Pair<IndexMap, Integer>> columnSelectivities = Lists.mutable.of(); for (IndexMap column : columnIndices) { CellComparator expectedComparator = this.columnComparators.getComparator(expectedData.getColumnName(column.getExpectedIndex())); Set<String> expectedValues = getColumnValues(allMissingRows, Functions.chain(expectedValueFunction(column), expectedComparator.getFormatter())); CellComparator actualComparator = this.columnComparators.getComparator(actualData.getColumnName(column.getActualIndex())); Set<String> actualValues = getColumnValues(allSurplusRows, Functions.chain(actualValueFunction(column), actualComparator.getFormatter())); actualValues.retainAll(expectedValues); int selectivity = actualValues.size(); if (selectivity > 0) { columnSelectivities.add(Tuples.pair(column, Integer.valueOf(selectivity))); } } return columnSelectivities .sortThis(Comparators.reverse(Comparators.byFunction(Functions.<Integer>secondOfPair()))) .collect(Functions.<IndexMap>firstOfPair()); }
@Override public Iterable<Pair<T, SortableDependency>> valueOf(T group) { return group.getComponents().collect(Functions.pair(Functions.getFixedValue(group), Functions.<SortableDependency>getPassThru())); } });
final MutableList<Pair<T, SortableDependency>> sortedChanges = sortMetadataPairs.toSortedListBy(Functions.chain(Functions.<SortableDependency>secondOfPair(), new Function<SortableDependency, Integer>() { @Override public Integer valueOf(SortableDependency sortableDependency) {
@Override public MutableSortedSet<Pair<T, Integer>> zipWithIndex() { Comparator<? super T> comparator = this.comparator(); if (comparator == null) { TreeSortedSet<Pair<T, Integer>> pairs = TreeSortedSet.newSet(Comparators.byFunction(Functions.firstOfPair(), Comparators.naturalOrder())); return Iterate.zipWithIndex(this.delegate, pairs); } return Iterate.zipWithIndex(this.delegate, TreeSortedSet.newSet(Comparators.byFirstOfPair(comparator))); }
@Override public Function<String, String> convertDbObjectName() { return Functions.getStringPassThru(); }
private void validateNoBaselineBreaks(DbDeployerAppContext appContext, Predicate<? super CompareBreak> breakIgnorePredicate) { MutableList<CompareBreak> sortedCompareBreaks = this.calculateBaselineBreaks(appContext).toList().sortThis( Comparators.fromFunctions( CompareBreak.TO_COMPARE_SUBJECT, Functions.chain(CompareBreak.TO_CLAZZ, CLASS_TO_NAME), Functions.chain(Functions.getToClass(), CLASS_TO_NAME) )); MutableList<CompareBreak> relevantBreaks = sortedCompareBreaks.reject(breakIgnorePredicate); LOG.info("Found " + relevantBreaks.size() + " breaks"); if (!relevantBreaks.isEmpty()) { throw new IllegalArgumentException( "Found some mismatches between your change alters (LEFT) and your baseline files (RIGHT). Please review:\n" + relevantBreaks.makeString("\n")); } }
LOGGER.info("Grouping by '{}' column", this.actualData.getColumnName(column.getActualIndex())); CellComparator expectedComparator = this.columnComparators.getComparator(expectedData.getColumnName(column.getExpectedIndex())); MutableListMultimap<String, UnmatchedIndexMap> missingRowsByColumn = missingRows.groupBy(Functions.chain(expectedValueFunction(column), expectedComparator.getFormatter())); CellComparator actualComparator = this.columnComparators.getComparator(actualData.getColumnName(column.getActualIndex())); MutableListMultimap<String, UnmatchedIndexMap> surplusRowsByColumn = surplusRows.groupBy(Functions.chain(actualValueFunction(column), actualComparator.getFormatter())); for (String key : missingRowsByColumn.keysView())
.toSortedListBy(Functions.firstNotNullValue(new Function<ChangeEntry, String>() { @Override public String valueOf(ChangeEntry changeEntry1) { return changeEntry1.getName(); }, Functions.<ChangeEntry, String>getFixedValue(""))) .toSortedListBy(new Function<ChangeEntry, Integer>() { @Override
public <T> T parse(String[] args, T inputArgs) { return parse(args, inputArgs, Functions.<T, String>getFixedValue(null)); }
public static <T extends Comparable<? super T>, V> CaseFunction<T, V> caseDefault( Function<? super T, ? extends V> defaultFunction, Predicate<? super T> predicate, Function<? super T, ? extends V> function) { CaseFunction<T, V> caseFunction = Functions.<T, V>caseDefault(defaultFunction); return caseFunction.addCase(predicate, function); }
@Override public Function<String, String> convertDbObjectName() { return Functions.getPassThru(); }
@Override public Iterable<Pair<T, SortableDependency>> valueOf(T group) { return group.getComponents().collect(Functions.pair(Functions.getFixedValue(group), Functions.<SortableDependency>getPassThru())); } });
final MutableList<Pair<T, SortableDependency>> sortedChanges = sortMetadataPairs.toSortedListBy(Functions.chain(Functions.<SortableDependency>secondOfPair(), new Function<SortableDependency, Integer>() { @Override public Integer valueOf(SortableDependency sortableDependency) {
@Override public TreeSortedSet<Pair<T, Integer>> zipWithIndex() { Comparator<? super T> comparator = this.comparator(); if (comparator == null) { TreeSortedSet<Pair<T, Integer>> pairs = TreeSortedSet.newSet(Comparators.byFunction(Functions.firstOfPair(), Comparators.naturalOrder())); return Iterate.zipWithIndex(this, pairs); } return Iterate.zipWithIndex(this, TreeSortedSet.newSet(Comparators.byFirstOfPair(comparator))); }
@Override public Function<String, String> convertDbObjectName() { return Functions.getStringPassThru(); }
private void validateNoBaselineBreaks(DbDeployerAppContext appContext, Predicate<? super CompareBreak> breakIgnorePredicate) { MutableList<CompareBreak> sortedCompareBreaks = this.calculateBaselineBreaks(appContext).toList().sortThis( Comparators.fromFunctions( CompareBreak.TO_COMPARE_SUBJECT, Functions.chain(CompareBreak.TO_CLAZZ, CLASS_TO_NAME), Functions.chain(Functions.getToClass(), CLASS_TO_NAME) )); MutableList<CompareBreak> relevantBreaks = sortedCompareBreaks.reject(breakIgnorePredicate); LOG.info("Found " + relevantBreaks.size() + " breaks"); if (!relevantBreaks.isEmpty()) { throw new IllegalArgumentException( "Found some mismatches between your change alters (LEFT) and your baseline files (RIGHT). Please review:\n" + relevantBreaks.makeString("\n")); } }