return new CollectingSupplier(newCollector);
        }

        @Override
        public ExecutionTimeValue<? extends Map<K, V>> calculateExecutionTimeValue() {
            List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> execTimeValues = collectExecutionTimeValues();
            ExecutionTimeValue<Map<K, V>> fixedOrMissing = fixedOrMissingValueOf(execTimeValues);
            return fixedOrMissing != null

        }
    }

    private static <T> void visitValue(Action<? super ValueSupplier.ExecutionTimeValue<? extends Iterable<? extends T>>> visitor, ValueSupplier.ExecutionTimeValue<? extends T> value) {
        if (value.isMissing()) {
            visitor.execute(ValueSupplier.ExecutionTimeValue.missing());
        } else if (value.hasFixedValue()) {
            // transform preserving side effects

        @Nonnull
        private List<ExecutionTimeValue<? extends Iterable<? extends T>>> collectExecutionTimeValues() {
            List<ExecutionTimeValue<? extends Iterable<? extends T>>> values = new ArrayList<>();
            value.calculateExecutionTimeValue(values::add);
            return values;
        }

        public abstract ExecutionTimeValue<T> withChangingContent();

        public abstract ExecutionTimeValue<T> withSideEffect(@Nullable SideEffect<? super T> sideEffect);

        public static <T> ExecutionTimeValue<T> missing() {
            return Cast.uncheckedCast(MISSING);
        }

        public static <T> ExecutionTimeValue<T> fixedValue(T value) {
            assert value != null;

        return decodeValue().toProvider()
    }

    suspend fun ReadContext.decodeValue(): ValueSupplier.ExecutionTimeValue<*> =
        when (readByte()) {
            1.toByte() -> ValueSupplier.ExecutionTimeValue.missing<Any>()
            2.toByte() -> ValueSupplier.ExecutionTimeValue.ofNullable(read()) // nullable because serialization may replace value with null, e.g. when using provider of Task
            3.toByte() -> {

        }
    }

    suspend fun WriteContext.encodeContents(value: FileCollectionInternal) {
        val executionTimeValue = value.calculateExecutionTimeValue().getOrNull()
        if (executionTimeValue != null) {
            writeBoolean(true)
            write(executionTimeValue)
        } else {
            writeBoolean(false)
            encodeViaCollectingVisitor(value)
        }
    }

    private

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            ExecutionTimeValue<? extends T> value = calculateOwnExecutionTimeValue(context, this.value);
            if (getProducerTask() == null) {
                return value;

            return null;
        }

        @Override
        public ExecutionTimeValue<T> calculateExecutionTimeValue() {
            if (value.hasBeenObtained()) {
                return ExecutionTimeValue.ofNullable(value.obtain().get());
            } else {
                return ExecutionTimeValue.changingValue(this);
            }
        }

        @Override

 *     input providers that have a fixed value with that value, as above.
 *     </p>
 *     </li>
 * </ul>
 *
 * <p>See {@link org.gradle.api.internal.provider.ValueSupplier.ExecutionTimeValue}, which represents these states.</p>
 *
 * <p>The value itself might be "missing", which means there is no value available, or "broken", which means the calculation failed with some exception, or some object.

        when:
        def provider = parent.withSideEffect(sideEffect)
        def value = provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        def executionTimeValue = provider.calculateExecutionTimeValue()
        then:
        0 * _ // no side effects when values are not unpacked

        when:
        def unpackedValue = value.get()
        then: