}

            return ExecutionTimeValue.value(filterValue(context, value.toValue()));
        }
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends T> value = provider.calculateValue(consumer);

            this.value = value
        }

        @Override
        Class<T> getType() {
            return type
        }

        @Override
        protected Value<T> calculateOwnValue(ValueConsumer consumer) {
            return Value.of(value)
        }

        void setValue(T value) {
            T previousValue = this.value
            this.value = value

        try (EvaluationContext.ScopeContext context = openScope()) {
            return backingProvider(context, consumer).calculatePresence(consumer);
        }
    }

    @Override
    protected Value<? extends S> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {

        }

        @Nullable
        @Override
        public Class<Set<PublishArtifact>> getType() {
            return null;
        }

        @Override
        protected Value<Set<PublishArtifact>> calculateOwnValue(ValueConsumer consumer) {
            if (defaultArtifacts == null) {
                defaultArtifacts = new LinkedHashSet<>();
                currentDefault = null;
                if (artifacts != null) {

        this.serviceName = serviceName;
        this.serviceType = serviceType;
        this.internalServices = internalServices;
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        RegisteredBuildServiceProvider<T, ?> resolvedProvider = resolve(true);
        if (resolvedProvider == null) {
            return Value.missing();
        }

    }

    private static boolean isChangingValue(ProviderInternal<?> provider) {
        return provider.calculateExecutionTimeValue().isChangingValue();
    }

    @Override
    protected Value<? extends R> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            Value<? extends A> leftValue = left.calculateValue(consumer);
            if (leftValue.isMissing()) {

        }

        @Override
        public boolean calculatePresence(ValueConsumer consumer) {
            return values.hasNext();
        }

        @Override
        protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
            if (values.hasNext()) {
                T result = values.next();
                if (result != null) {
                    return Value.of(result);
                }

    }

    private boolean isChangingValue(ProviderInternal<?> provider) {
        return provider.calculateExecutionTimeValue().isChangingValue();
    }

    @Override
    protected Value<List<R>> calculateOwnValue(ValueConsumer consumer) {

        List<Value<? extends R>> values = new ArrayList<>(items.size());
        for (Provider<R> provider : items) {

            }

            return ExecutionTimeValue.value(mapValue(context, value.toValue()));
        }
    }

    @Override
    protected Value<? extends OUT> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends IN> value = provider.calculateValue(consumer);

        @Override
        public Class<V> getType() {
            return valueType;
        }

        @Override
        protected Value<? extends V> calculateOwnValue(ValueConsumer consumer) {
            Value<? extends Map<K, V>> result = DefaultMapProperty.this.calculateOwnValue(consumer);
            if (result.isMissing()) {
                return result.asType();
            }