* see the {@link org.gradle.api.internal.provider.ProviderInternal} interface.</p>
 *
 * <p>Also, make sure to become familiar with {@link org.gradle.api.internal.provider.AbstractMinimalProvider},
 * the base class for all provider (and property) implementations.</p>
 *
 * <h3>Lazy properties</h3>
 *
 * <p>For the public API, see {@link org.gradle.api.provider.Property Property}.</p>
 *

package org.gradle.api.internal.provider;

import org.gradle.api.Transformer;
import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;

public class FlatMapProvider<S, T> extends AbstractMinimalProvider<S> {
    private final ProviderInternal<? extends T> provider;
    private final Transformer<? extends Provider<? extends S>, ? super T> transformer;

 *
 * <h3>Configuration Cache Behavior</h3>
 * <b>Eager</b>. The value is computed at store time and loaded from the cache.
 */
public class DefaultProvider<T> extends AbstractMinimalProvider<T> {
    private final Callable<? extends T> value;

    public DefaultProvider(Callable<? extends T> value) {
        this.value = value;
    }

    @Nullable
    @Override

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * A filtering provider that uses a spec to filter the value of another provider.
 **/
public class FilteringProvider<T> extends AbstractMinimalProvider<T> {

    protected final ProviderInternal<T> provider;
    protected final Spec<? super T> spec;

    public FilteringProvider(
        ProviderInternal<T> provider,
        Spec<? super T> spec
    ) {

    }

    def "toString() displays nice things"() {
        expect:
        new TestProvider().toString() == "provider(java.lang.String)"
    }

    static class TestProvider extends AbstractMinimalProvider {
        @Nullable
        String value

        void value(String s) {
            this.value = s
        }

        @Override
        Class getType() {
            return String

 */
package org.gradle.api.internal.provider;

import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;
import java.util.function.BiFunction;

public class BiProvider<R, A, B> extends AbstractMinimalProvider<R> {

    private final Class<R> type;
    private final BiFunction<? super A, ? super B, ? extends R> combiner;
    private final ProviderInternal<A> left;
    private final ProviderInternal<B> right;

        return new TestProviderWithChangingValue<>(valueType, Arrays.asList(values), producer);
    }

    private static class TestProvider<T> extends AbstractMinimalProvider<T> {
        final Class<T> type;
        final Iterator<T> values;
        final Task producer;

        TestProvider(Class<T> type, List<T> values, @Nullable  Task producer) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.collections

import org.gradle.api.internal.provider.AbstractMinimalProvider
import org.gradle.api.internal.provider.CollectionProviderInternal

class ListElementSourceTest extends AbstractIterationOrderRetainingElementSourceTest {

 *
 * This effectively converts a {@code List<Provider<T>>} to a {@code Provider<List<T>>}.
 *
 * @param <R> The type of the values that all source providers must share.
 */
public class MergeProvider<R> extends AbstractMinimalProvider<List<R>> {

    private final List<Provider<R>> items;

    public MergeProvider(List<Provider<R>> items) {
        this.items = ImmutableList.copyOf(items);
    }

    @Override

 *
 * @see ProviderInternal for a discussion of the "value" and "value contents".
 */
public class TransformBackedProvider<OUT, IN> extends AbstractMinimalProvider<OUT> {

    protected final Class<OUT> type;
    protected final ProviderInternal<? extends IN> provider;
    protected final Transformer<? extends OUT, ? super IN> transformer;