private final ReportRenderer<? super T, ? super E> delegate;

    public TrackingReportRenderer(ReportRenderer<? super T, ? super E> delegate) {
        this.delegate = delegate;
    }

    public Set<T> getItems() {
        return items;
    }

    @Override
    public void render(T model, E output) throws IOException {
        if (items.add(model)) {
            delegate.render(model, output);
        }
    }

  function initPreferredBuildScriptLanguage() {
    var lang = window.localStorage.getItem("preferred-gradle-dsl");
    if (GRADLE_DSLs.indexOf(lang) === -1) {
      window.localStorage.setItem("preferred-gradle-dsl", "kotlin");
      lang = "kotlin";
    }
    return lang;
  }

  function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }

import org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor

/**
 * A signature of a function-like symbol. This includes functions, getters, setters, lambdas, etc.
 */
public abstract class KaFunctionLikeSignature<out S : KaFunctionLikeSymbol> : KaCallableSignature<S>() {
    /**
     * The use-site-substituted value parameters.
     */

to the float64 argument f. More flexibility is provided with explicit
setters, for instance:

	var z1 Int
	z1.SetUint64(123)                 // z1 := 123
	z2 := new(Rat).SetFloat64(1.25)   // z2 := 5/4
	z3 := new(Float).SetInt(z1)       // z3 := 123.0

Setters, numeric operations and predicates are represented as methods of
the form:

	func (z *T) SetV(v V) *T          // z = v

            return isReadable() && setters.stream().noneMatch(method -> method.getParameterTypes()[0].equals(getType()));
        }

        public boolean isReadable() {
            return mainGetter != null;
        }

        public boolean isWritable() {
            return !setters.isEmpty();
        }

        return words;
    }

    public int getNum() {
        return num;
    }

    public long getTotal() {
        return total;
    }

    public List<SuggestItem> getItems() {
        return items;
    }

            import org.gradle.model.Managed

            @Managed
            interface CollectionType {
                ${collectionType.name}<String> getItems()
            }
        """

        then:
        failWhenRealized(managedType, canNotBeConstructed("CollectionType"),

import org.gradle.model.Managed

class ListModelProjectionTest extends AbstractCollectionModelProjectionTest<String, List<String>> {

    @Managed
    static interface Internal {
        List<String> getItems()
    }

    @Override
    Class<?> holderType() {
        Internal
    }

    def "can remove using index"() {
        when:
        mutate {
            add 'foo'
            add 'bar'

import java.lang.annotation.*;

/**
 * <p>Marks a property as specifying an output directory for a task.</p>
 *
 * <p>This annotation should be attached to the getter method in Java or the property in Groovy.
 * Annotations on setters or just the field in Java are ignored.</p>
 *
 * <p>The directory will be created before the task is executed if it does not exist already.</p>
 *

                // Add the items in this page of results to the list we'll return.
                // GCS API will return null on an empty list.
                if(objects.getItems() != null) {
                    results.addAll(objects.getItems());
                }

                // Get the next page, in the next iteration of this loop.
                listRequest.setPageToken(objects.getNextPageToken());