public S setToConventionIfUnset(S value) {
            if (!explicitValue) {
                return setToConvention();
            }
            return value;
        }

        @Override
        public S explicitValue(S value) {
            explicitValue = true;
            return value;
        }

        @Override
        public S explicitValue(S value, S defaultValue) {
            if (!explicitValue) {

    protected abstract S finalValue(EvaluationContext.ScopeContext context, S value, ValueConsumer consumer);

    protected void setSupplier(S supplier) {
        assertCanMutate();
        this.value = state.explicitValue(supplier);
    }

    protected void setConvention(S convention) {
        assertCanMutate();
        this.value = state.applyConvention(value, convention);
    }

    /**

        value = valueState.applyConvention(value, convention);
    }

    private void setExplicitCollector(ValueCollector valueCollector) {
        value = valueState.explicitValue(valueCollector);
    }

    @Override
    public ConfigurableFileCollection unsetConvention() {
        assertMutable();
        setConventionCollector(EMPTY_COLLECTOR);
        return this;
    }

     */
    private void addExplicitCollector(Collector<T> collector, boolean ignoreAbsent) {
        assertCanMutate();
        CollectionSupplier<T, C> explicitValue = getExplicitValue(defaultValue).absentIgnoringIfNeeded(ignoreAbsent);
        setSupplier(explicitValue.plus(collector.absentIgnoringIfNeeded(ignoreAbsent)));
    }

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

    }

    private void addExplicitCollector(MapCollector<K, V> collector, boolean ignoreAbsent) {
        assertCanMutate();
        MapSupplier<K, V> explicitValue = getExplicitValue(defaultValue).absentIgnoringIfNeeded(ignoreAbsent);
        setSupplier(explicitValue.plus(collector.absentIgnoringIfNeeded(ignoreAbsent)));
    }

    private Configurer getConfigurer() {
        return getConfigurer(false);
    }