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

    @Override
    public <T extends BlockPayload> T readFirst(Class<T> payloadType) {
        assert open;
        return blockStore.readFirst(payloadType);
    }

    @Override
    public <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType) {
        assert open;

            indexBlockCache.invalidate(block.getPos());
        }
        store.remove(block);
    }

    @Override
    public <T extends BlockPayload> T readFirst(Class<T> payloadType) {
        T block = store.readFirst(payloadType);
        maybeCache(block);
        return block;
    }

    @Override
    public <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType) {

    /**
     * Removes the given block from this store.
     */
    void remove(BlockPayload block);

    /**
     * Reads the first block from this store.
     */
    <T extends BlockPayload> T readFirst(Class<T> payloadType);
    
    /**
     * Reads a block from this store.
     */
    <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType);

    /**

                }
                return factory.create(type);
            }
        };

        store.open(freeListInitAction, freeListFactory);
        freeListBlock = store.readFirst(FreeListBlock.class);
    }

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

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

        BlockImpl blockImpl = (BlockImpl) block.getBlock();
        blockImpl.detach();
    }

    @Override
    public void flush() {
    }

    @Override
    public <T extends BlockPayload> T readFirst(Class<T> payloadType) {
        return read(BlockPointer.pos(0), payloadType);
    }

    @Override
    public <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType) {
        assert !pos.isNull();

                store.write(header);
                header.index.newRoot();
                store.flush();
            }
        };

        store.open(initAction, factory);
        header = store.readFirst(HeaderBlock.class);
    }

    public V get(K key) {
        try {
            try {
                DataBlock block = header.getRoot().get(key);
                if (block != null) {

            val filteringCharset = readString()
            val dirMode = readNullableSmallInt()
            val fileMode = readNullableSmallInt()
            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()
            val children = readList().uncheckedCast<List<CopySpecInternal>>()

import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.ownerService
import org.gradle.internal.serialize.graph.readList
import org.gradle.internal.serialize.graph.readNonNull
import org.gradle.internal.serialize.graph.runReadOperation
import org.gradle.internal.serialize.graph.runWriteOperation

        val ownerId = readNonNull<ComponentIdentifier>()
        val targetAttributes = readNonNull<ImmutableAttributes>()
        val capabilities: List<Capability> = readList().uncheckedCast()
        val files = readNonNull<List<Artifact>>()
        val steps: List<TransformStepSpec> = readList().uncheckedCast()
        return AbstractTransformedArtifactSet.CalculateArtifacts(
            ownerId,

import org.gradle.internal.serialize.graph.Codec
import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.readList
import org.gradle.internal.serialize.graph.withPropertyTrace
import org.gradle.internal.serialize.graph.writeCollection
import org.gradle.internal.cc.base.services.ConfigurationCacheEnvironmentChangeTracker