import org.gradle.api.provider.Provider;

/**
 * A {@link org.gradle.api.provider.Provider} that always has a value defined. The value may not necessarily be final.
 */
public abstract class AbstractProviderWithValue<T> extends AbstractMinimalProvider<T> {
    @Override
    public boolean isPresent() {
        return true;
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

import org.gradle.internal.Cast;

import javax.annotation.Nullable;

class OrElseFixedValueProvider<T> extends AbstractProviderWithValue<T> {
    private final ProviderInternal<? extends T> provider;
    private final T fallbackValue;

    public OrElseFixedValueProvider(ProviderInternal<? extends T> provider, T fallbackValue) {

import org.gradle.api.internal.tasks.TaskDependencyUtil;
import org.gradle.internal.Factory;

import javax.annotation.Nullable;
import java.util.Set;

public class BuildableBackedProvider<T> extends AbstractProviderWithValue<T> {

    private final Buildable buildable;
    private final Class<T> valueType;
    private final Factory<T> valueFactory;

    }

    public static <T> ProviderInternal<T> changing(SerializableCallable<T> value) {
        return new ChangingProvider<>(value);
    }

    public static class FixedValueProvider<T> extends AbstractProviderWithValue<T> {
        protected final T value;

        FixedValueProvider(T value) {
            this.value = value;
        }

        @Nullable
        @Override
        public Class<T> getType() {