@NotNull public static <T> LinkedHashSet<T> newLinkedHashSet(@NotNull Iterable<? extends T> elements) { if (elements instanceof Collection) { @SuppressWarnings("unchecked") Collection<? extends T> collection = (Collection<? extends T>) elements; return new com.intellij.util.containers.LinkedHashSet<T>(collection); } return copy(ContainerUtilRt.<T>newLinkedHashSet(), elements); }
@NotNull public static <T> ArrayList<T> newArrayList(@NotNull Iterable<? extends T> elements) { if (elements instanceof Collection) { @SuppressWarnings("unchecked") Collection<? extends T> collection = (Collection<? extends T>) elements; return new ArrayList<T>(collection); } return copy(ContainerUtilRt.<T>newArrayList(), elements); }
@SuppressWarnings("unchecked") private static <E extends ArrangementEntry> void doArrange( @NotNull List<ArrangementEntryWrapper<E>> wrappers, @NotNull Context<E> context) { if (wrappers.isEmpty()) { return; } Map<E, ArrangementEntryWrapper<E>> map = ContainerUtilRt.newHashMap(); List<E> arranged = ContainerUtilRt.newArrayList(); List<E> toArrange = ContainerUtilRt.newArrayList(); for (ArrangementEntryWrapper<E> wrapper : wrappers) { E entry = wrapper.getEntry(); map.put(wrapper.getEntry(), wrapper); if (!entry.canBeMatched()) { // Split entries to arrange by 'can not be matched' rules. // See IDEA-104046 for a problem use-case example. if (toArrange.isEmpty()) { arranged.addAll(arrange(toArrange, context.rules, context.rulesByPriority)); } arranged.add(entry); toArrange.clear(); } else { toArrange.add(entry); } } if (!toArrange.isEmpty()) { arranged.addAll(arrange(toArrange, context.rules, context.rulesByPriority)); } context.changer.prepare(wrappers, context); // We apply changes from the last position to the first position in order not to bother with // offsets shifts. for (int i = arranged.size() - 1; i >= 0; i--) { ArrangementEntryWrapper<E> arrangedWrapper = map.get(arranged.get(i)); ArrangementEntryWrapper<E> initialWrapper = wrappers.get(i); context.changer.replace( arrangedWrapper, initialWrapper, i > 0 ? map.get(arranged.get(i - 1)) : null, context); } }
private static class Context<E extends ArrangementEntry> { @NotNull public final List<ArrangementMoveInfo> moveInfos = ContainerUtilRt.newArrayList(); @NotNull public final Rearranger<E> rearranger; @NotNull public final Collection<ArrangementEntryWrapper<E>> wrappers; @NotNull public final Document document; @NotNull public final List<? extends ArrangementMatchRule> rules; @NotNull public final List<? extends ArrangementMatchRule> rulesByPriority; @NotNull public final CodeStyleSettings settings; @NotNull public final Changer changer; private Context( @NotNull Rearranger<E> rearranger, @NotNull Collection<ArrangementEntryWrapper<E>> wrappers, @NotNull Document document, @NotNull List<? extends ArrangementMatchRule> rules, @NotNull List<? extends ArrangementMatchRule> rulesByPriority, @NotNull CodeStyleSettings settings, @NotNull Changer changer) { this.rearranger = rearranger; this.wrappers = wrappers; this.document = document; this.rules = rules; this.rulesByPriority = rulesByPriority; this.settings = settings; this.changer = changer; } public void addMoveInfo(int oldStart, int oldEnd, int newStart) { moveInfos.add(new ArrangementMoveInfo(oldStart, oldEnd, newStart)); } public static <T extends ArrangementEntry> Context<T> from( @NotNull Rearranger<T> rearranger, @NotNull Document document, @NotNull PsiElement root, @NotNull Collection<TextRange> ranges, @NotNull ArrangementSettings arrangementSettings, @NotNull CodeStyleSettings codeStyleSettings) { Collection<T> entries = rearranger.parse(root, document, ranges, arrangementSettings); Collection<ArrangementEntryWrapper<T>> wrappers = new ArrayList<ArrangementEntryWrapper<T>>(); ArrangementEntryWrapper<T> previous = null; for (T entry : entries) { ArrangementEntryWrapper<T> wrapper = new ArrangementEntryWrapper<T>(entry); if (previous != null) { previous.setNext(wrapper); wrapper.setPrevious(previous); } wrappers.add(wrapper); previous = wrapper; } Changer changer; if (document instanceof DocumentEx) { changer = new RangeMarkerAwareChanger<T>((DocumentEx) document); } else { changer = new DefaultChanger(); } final List<? extends ArrangementMatchRule> rulesByPriority = ArrangementUtil.getRulesSortedByPriority(arrangementSettings); return new Context<T>( rearranger, wrappers, document, arrangementSettings.getRules(), rulesByPriority, codeStyleSettings, changer); } }
/** * Arranges (re-orders) given entries according to the given rules. * * @param entries entries to arrange * @param rules rules to use for arrangement * @param rulesByPriority rules sorted by priority ('public static' rule will have higher priority * than 'public') * @param <E> arrangement entry type * @return arranged list of the given rules */ @SuppressWarnings("AssignmentToForLoopParameter") @NotNull public static <E extends ArrangementEntry> List<E> arrange( @NotNull Collection<E> entries, @NotNull List<? extends ArrangementMatchRule> rules, @NotNull List<? extends ArrangementMatchRule> rulesByPriority) { List<E> arranged = ContainerUtilRt.newArrayList(); Set<E> unprocessed = ContainerUtilRt.newLinkedHashSet(); List<Pair<Set<ArrangementEntry>, E>> dependent = ContainerUtilRt.newArrayList(); for (E entry : entries) { List<? extends ArrangementEntry> dependencies = entry.getDependencies(); if (dependencies == null) { unprocessed.add(entry); } else { if (dependencies.size() == 1 && dependencies.get(0) == entry.getParent()) { // Handle a situation when the entry is configured to be at the first parent's children. arranged.add(entry); } else { Set<ArrangementEntry> first = new HashSet<ArrangementEntry>(dependencies); dependent.add(Pair.create(first, entry)); } } } Set<E> matched = new HashSet<E>(); MultiMap<ArrangementMatchRule, E> elementsByRule = new MultiMap<ArrangementMatchRule, E>(); for (ArrangementMatchRule rule : rulesByPriority) { matched.clear(); for (E entry : unprocessed) { if (entry.canBeMatched() && rule.getMatcher().isMatched(entry)) { elementsByRule.putValue(rule, entry); matched.add(entry); } } unprocessed.removeAll(matched); } for (ArrangementMatchRule rule : rules) { if (elementsByRule.containsKey(rule)) { final Collection<E> arrangedEntries = elementsByRule.get(rule); // Sort by name if necessary. if (StdArrangementTokens.Order.BY_NAME.equals(rule.getOrderType())) { sortByName((List<E>) arrangedEntries); } arranged.addAll(arrangedEntries); } } arranged.addAll(unprocessed); for (int i = 0; i < arranged.size() && !dependent.isEmpty(); i++) { E e = arranged.get(i); for (Iterator<Pair<Set<ArrangementEntry>, E>> iterator = dependent.iterator(); iterator.hasNext(); ) { Pair<Set<ArrangementEntry>, E> pair = iterator.next(); pair.first.remove(e); if (pair.first.isEmpty()) { iterator.remove(); arranged.add(i + 1, pair.second); } } } return arranged; }
@NotNull public static <T> CopyOnWriteArrayList<T> createEmptyCOWList() { // does not create garbage new Object[0] return new CopyOnWriteArrayList<T>(ContainerUtilRt.<T>emptyList()); }
@NotNull public static <T> TreeSet<T> newTreeSet(@NotNull Iterable<? extends T> elements) { return copy(ContainerUtilRt.<T>newTreeSet(), elements); }
@NotNull public static <T> LinkedList<T> newLinkedList(@NotNull Iterable<? extends T> elements) { return copy(ContainerUtilRt.<T>newLinkedList(), elements); }