if c.before != "" { // if defined before callback
			if c.before == "*" && len(sorted) > 0 {
				if curIdx := getRIndex(sorted, c.name); curIdx == -1 {
					sorted = append([]string{c.name}, sorted...)
				}
			} else if sortedIdx := getRIndex(sorted, c.before); sortedIdx != -1 {
				if curIdx := getRIndex(sorted, c.name); curIdx == -1 {
					// if before callback already sorted, append current callback just after it

        assertThat(indexed1.getIndex(), is(0));
        assertThat(indexed1.getElement(), is("aaa"));

        final Indexed<String> indexed2 = it.next();
        assertThat(indexed2.getIndex(), is(1));
        assertThat(indexed2.getElement(), is("bbb"));

        final Indexed<String> indexed3 = it.next();
        assertThat(indexed3.getIndex(), is(2));
        assertThat(indexed3.getElement(), is("ccc"));

    NestedExceptionPlaceholder(Kind kind, int index) {
        this.kind = kind;
        this.index = index;
    }

    public Kind getKind() {
        return kind;
    }

    public int getIndex() {
        return index;
    }

    enum Kind {
        cause,
        suppressed
    }

 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 * import static org.codelibs.core.io.LineIterator.*;
 *
 * BufferedReader reader = ...;
 * for (Indexed&lt;String%gt; indexed : indexed(iterable(reader))) {
 *     System.out.println(indexed.getIndex());

                return -1;
            } else if (!node1.isPriority() && node2.isPriority()) {
                return 1;
            }
            if (node1.getIndex() > node2.getIndex()) {
                return 1;
            } else if (node1.getIndex() < node2.getIndex()) {
                return -1;
            }
            return NodeComparator.INSTANCE.compare(node1, node2);
        }
    };

     * 要素を返します。
     *
     * @return 要素
     */
    public T getElement() {
        return element;
    }

    /**
     * インデックスを返します。
     *
     * @return インデックス
     */
    public int getIndex() {
        return index;
    }

        this.index = index;
        this.tookMs = tookMs;
        this.words = words;
        this.num = words.size();
        this.total = total;
        this.items = items;
    }

    public String getIndex() {
        return index;
    }

    public long getTookMs() {
        return tookMs;
    }

    public List<String> getWords() {
        return words;
    }

    public int getNum() {

        this.index = index;
        this.tookMs = tookMs;
        this.words = words;
        this.num = words.size();
        this.total = total;
        this.items = items;
    }

    public String getIndex() {
        return index;
    }

    public long getTookMs() {
        return tookMs;
    }

    public List<String> getWords() {
        return words;
    }

    public int getNum() {

        public boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination) {
            if (dataFile == null) {
                return false;
            }

            Index index = getIndex(classId, testId);
            if (index == null) {
                return false;
            } else {
                Region region = destination == TestOutputEvent.Destination.StdOut ? index.stdOut : index.stdErr;

public class IterationOrderRetainingSetElementSource<T> extends AbstractIterationOrderRetainingElementSource<T> {
    private static final Spec<ValuePointer<?>> NO_DUPLICATES = pointer -> !pointer.getElement().isDuplicate(pointer.getIndex());

    /**
     * Tracks the subset of values added with add() (without a Provider), allowing us to filter out duplicates
     * from that subset in constant time.
     */