@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();
            }

            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);
        }
    }

                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();