public DefaultNamedDomainObjectList(DefaultNamedDomainObjectList<? super T> objects, CollectionFilter<T> filter, Instantiator instantiator, Namer<? super T> namer) {
        super(objects, filter, instantiator, namer);
    }

    public DefaultNamedDomainObjectList(Class<T> type, Instantiator instantiator, Namer<? super T> namer, CollectionCallbackActionDecorator decorator) {
        super(type, new ListElementSource<T>(), instantiator, namer, decorator);
    }

    private final List<? extends BuildOption<? super ToolchainConfiguration>> options = Arrays.asList(
        new JavaInstallationPathsOption(),
        new JavaInstallationEnvironmentPathsOption(),
        new AutoDetectionOption(),
        new AutoDownloadOption(),
        new IntellijJdkBuildOption()
    );

    @Override
    public List<? extends BuildOption<? super ToolchainConfiguration>> getAllOptions() {

        @Override
        public <U> Try<U> flatMap(Function<? super T, Try<U>> f) {
            return f.apply(value);
        }

        @Override
        public <U> Try<U> map(Function<? super T, U> f) {
            return Try.successful(f.apply(value));
        }

        @Override
        public <U> Try<U> tryMap(final Function<? super T, U> f) {
            return Try.ofFailable(() -> f.apply(value));

  @Override
  public void testContainsKey() {
    try {
      super.testContainsKey();
    } catch (ClassCastException tolerated) {
    }
  }

  @J2ktIncompatible // https://youtrack.jetbrains.com/issue/KT-58242/ undefined behavior (crash)
  @Override
  public void testEntrySetContainsEntryIncompatibleKey() {
    try {
      super.testEntrySetContainsEntryIncompatibleKey();
    } catch (ClassCastException tolerated) {

    }

    @Override
    public Action<? super T> whenObjectAdded(Action<? super T> action) {
        assertMutable("whenObjectAdded(Action)");
        return addEagerAction(action);
    }

    @Override
    public void whenObjectAdded(Closure action) {
        whenObjectAdded(toAction(action));
    }

    private Action<? super T> addEagerAction(Action<? super T> action) {
        store.realizePending(type);

        return NOOP;
    }

    public static <A, B> BiAction<A, B> composite(final BiAction<? super A, ? super B>... actions) {
        return new BiAction<A, B>() {
            @Override
            public void execute(A a, B b) {
                for (BiAction<? super A, ? super B> action : actions) {
                    action.execute(a, b);
                }
            }
        };
    }

@ElementTypesAreNonnullByDefault
public class TreeBasedTable<R, C, V> extends StandardRowSortedTable<R, C, V> {
  private final Comparator<? super C> columnComparator;

  private static class Factory<C, V> implements Supplier<TreeMap<C, V>>, Serializable {
    final Comparator<? super C> comparator;

    Factory(Comparator<? super C> comparator) {
      this.comparator = comparator;
    }

    @Override
    public TreeMap<C, V> get() {

    private final List<NotationConverter<? super N, ? extends T>> converters;

    public CompositeNotationConverter(List<NotationConverter<? super N, ? extends T>> converters) {
        this.converters = converters;
    }

    @Override
    public void convert(N notation, NotationConvertResult<? super T> result) throws TypeConversionException {

        super(ASM_LEVEL, classVisitor);
    }

    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        String newSuperName = fixInternalNameForBackwardCompatibility(superName);
        String[] newInterfaces = fixInternalNamesForBackwardsCompatibility(interfaces);

final class TableCollectors {

  static <T extends @Nullable Object, R, C, V>
      Collector<T, ?, ImmutableTable<R, C, V>> toImmutableTable(
          Function<? super T, ? extends R> rowFunction,
          Function<? super T, ? extends C> columnFunction,
          Function<? super T, ? extends V> valueFunction) {
    checkNotNull(rowFunction, "rowFunction");
    checkNotNull(columnFunction, "columnFunction");