public interface CalculatedValueCache<K, V> {

    /**
     * @see Map#computeIfAbsent(Object, Function)
     */
    V computeIfAbsent(K key, Function<K, V> factory);

    /**
     * @see Map#clear()
     */
    void clear();

     * Starts writing to the given offset. Can be beyond the current length of the file.
     */
    public DataOutputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedOutputStream.clear();
        countingOutputStream = new CountingOutputStream(bufferedOutputStream);
        return new DataOutputStream(countingOutputStream);
    }

    /**

    @Override
    public void close() {
        flush();
        indexBlockCache.invalidateAll();
        store.close();
    }

    @Override
    public void clear() {
        dirty.clear();
        indexBlockCache.invalidateAll();
        store.clear();
    }

    @Override
    public void flush() {
        Iterator<BlockPayload> iterator = dirty.values().iterator();
        while (iterator.hasNext()) {

    }

    @Override
    public void close() {
        freeListBlock = null;
        store.close();
    }

    @Override
    public void clear() {
        store.clear();
    }

    @Override
    public void remove(BlockPayload block) {
        Block container = block.getBlock();
        store.remove(block);

        try {
            CompositeStoppable.stoppable().add(sinks).add(availableSources.values()).stop();
        } finally {
            sinks.clear();
            availableSinks.clear();
            availableSources.clear();
        }
    }

    private Sink<T> allocateSink() {
        Sink<T> sink = availableSinks.poll();
        if (sink != null) {
            return sink;

    @Override
    public void close() {
        if (!open) {
            return;
        }
        open = false;
        blockStore.close();
    }

    @Override
    public void clear() {
        assert open;
        blockStore.clear();
    }

    @Override
    public void remove(BlockPayload block) {
        assert open;
        blockStore.remove(block);
    }

    @Override

                IsolateOwners.OwnerGradle(gradle)
            )
            clear()
            IsolatedProjectEvaluationListener(gradle, isolate)
        }
    }

    override fun clear() {
        beforeProject.clear()
        afterProject.clear()
    }

    private
    fun isolate(actions: IsolatedProjectActions, owner: IsolateOwner) =

        println("[EDITOR_$severity] '$message' ${position?.line ?: ""}")
        reports.add(IdeReport(severity, message, position))
    }

    fun clear() {
        events.clear()
        reports.clear()
    }

    fun assertSuccessScenario() {
        assertThat(
            events.map { it.event },
            hasItems(
                instanceOf<ResolutionRequest>(),

        for (Object o : collection) {
            listener.onAccess(o);
            listener.onRemove(o);
        }
        return delegate.removeAll(collection);
    }

    @Override
    public void clear() {
        delegate.clear();
        listener.onClear();
    }

    @Override
    public Iterator<E> iterator() {
        reportAggregatingAccess();
        return Iterators.transform(delegate().iterator(), factory::apply);

        def cache = cache(map)

        expect:
        cache.get("a", { 1 } as Supplier) == 1
        cache.get("a", { 2 } as Supplier) == 1

        and:
        map.a == 1

        when:
        map.clear()

        then:
        cache.get("a", { 2 } as Supplier) == 2
    }