beforeReadNoProducer(context, consumer);
            return doCalculateValue(context, consumer);
        }
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context, consumer);
            return doCalculateValue(context, consumer);
        }
    }

        ProducerDiscardingProvider(ProviderInternal<T> provider) {
            this.provider = provider
        }

        @Override
        protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
            return provider.calculateValue(consumer)
        }

        @Override
        ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {

        synchronized (instanceLock) {
            stopActions = stopActions.plus(stopAction);
        }
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        return Value.of(getInstance());
    }

    private T getInstance() {
        listener.beforeGet(this);
        synchronized (instanceLock) {

                if (match == t) {
                    action.execute(match);
                }
            });
        }

        @Override
        protected Value<S> calculateOwnValue(ValueConsumer consumer) {
            if (ambiguous) {
                throw new IllegalStateException("Found multiple elements");
            }
            return Value.ofNullable(match);
        }
    }

                throw domainObjectRemovedException(getName(), getType());
            }
            return super.get();
        }

        @Override
        protected Value<I> calculateOwnValue(ValueConsumer consumer) {
            return Value.ofNullable(Cast.uncheckedCast(findByNameWithoutRules(getName())));
        }
    }

            this.value = value
        }

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

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

        @Override
        int size() {
            return value.size()
        }
    }

            } else {
                return ExecutionTimeValue.changingValue(this);
            }
        }

        @Override
        protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
            return Value.ofNullable(value.obtain().get());
        }
    }

    private class LazilyObtainedValue<T, P extends ValueSourceParameters> {

                public Class<T> getType() {
                    return AbstractFileVar.this.getType();
                }

                @Override
                protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
                    return calculateOwnValueNoProducer(consumer);
                }
            };
        }
    }

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

            @Override
            protected ValueSupplier.Value<T> calculateOwnValue(ValueSupplier.ValueConsumer consumer) {
                throw new RuntimeException("broken!")
            }
        }
    }

        public ExecutionTimeValue<? extends C> calculateExecutionTimeValue() {
            return ExecutionTimeValue.changingValue(this);
        }

        @Override
        protected Value<? extends C> calculateOwnValue(ValueConsumer consumer) {
            ImmutableCollection.Builder<T> builder = collectionFactory.get();
            SideEffectBuilder<? super C> sideEffectBuilder = SideEffect.builder();