object NullValueSnapshotCodec : Codec<NullValueSnapshot> {
    override suspend fun WriteContext.encode(value: NullValueSnapshot) {
    }

    override suspend fun ReadContext.decode(): NullValueSnapshot {
        return NullValueSnapshot.INSTANCE
    }
}


object IsolatedEnumValueSnapshotCodec : Codec<IsolatedEnumValueSnapshot> {
    override suspend fun WriteContext.encode(value: IsolatedEnumValueSnapshot) {

    override suspend fun ReadContext.decode() =
        readLengthPrefixedShorts(this)
}


object IntArrayCodec : Codec<IntArray> {
    override suspend fun WriteContext.encode(value: IntArray) =
        writeLengthPrefixedInts(this, value)

    override suspend fun ReadContext.decode() =
        readLengthPrefixedInts(this)
}


object LongArrayCodec : Codec<LongArray> {

fun <T> singleton(value: T): Codec<T> =
    SingletonCodec(value)


fun <T> codec(
    encode: suspend WriteContext.(T) -> Unit,
    decode: suspend ReadContext.() -> T?
): Codec<T> = object : Codec<T> {
    override suspend fun WriteContext.encode(value: T) = encode(value)
    override suspend fun ReadContext.decode(): T? = decode()
}


inline fun <reified T> IsolateContext.ownerService() =

) : Codec<ImmutableAttributes> {

    override suspend fun WriteContext.encode(value: ImmutableAttributes) {
        writeAttributes(value)
    }

    override suspend fun ReadContext.decode(): ImmutableAttributes =
        readAttributesUsing(attributesFactory, managedFactories).asImmutable()
}


private
suspend fun WriteContext.writeAttributes(container: AttributeContainer) {

 */
class FixedValueReplacingProviderCodec(

    private
    val providerWithChangingValueCodec: Codec<Any?>

) {
    suspend fun WriteContext.encodeProvider(value: ProviderInternal<*>) {
        val state = value.calculateExecutionTimeValue()
        encodeValue(state)
    }

    suspend fun WriteContext.encodeValue(value: ValueSupplier.ExecutionTimeValue<*>) {
        val sideEffect = value.sideEffect
        when {

    override suspend fun WriteContext.encode(value: Directory) {
        writeFile(value.asFile)
    }

    override suspend fun ReadContext.decode(): Directory {
        return fileFactory.dir(readFile())
    }
}


class RegularFileCodec(private val fileFactory: FileFactory) : Codec<RegularFile> {
    override suspend fun WriteContext.encode(value: RegularFile) {

		}
		if *actual.Spec.Suspend != *expected.Spec.Suspend {
			t.Errorf("%s: got different suspend than expected: %v %v", name, *actual.Spec.Suspend, *expected.Spec.Suspend)
		}
		if *actual.Spec.SuccessfulJobsHistoryLimit != *expected.Spec.SuccessfulJobsHistoryLimit {

        return server;
    }

    public void setServer(boolean server) {
        this.server = server;
    }

    public boolean isSuspend() {
        return suspend;
    }

    public void setSuspend(boolean suspend) {
        this.suspend = suspend;
    }

    public String getAddress(){
        String port = Integer.toString(this.port);
        return isNullOrEmpty(host) ? port : host + ":" + port;
    }

            && Objects.equals(host.getOrNull(), that.host.getOrNull())
            && port.get().equals(that.port.get())
            && server.get() == that.server.get()
            && suspend.get() == that.suspend.get();
    }

    @Override
    public Property<Boolean> getEnabled() {
        return enabled;
    }

    @Override
    @Optional
    public Property<String> getHost() {

     * of stored included build directories.
     */
    suspend fun DefaultWriteContext.writeRootBuildState(build: VintageGradleBuild) {
        writeBuildInvocationId()
        writeRootBuild(build).also {
            writeInt(0x1ecac8e)
        }
    }

    suspend fun DefaultReadContext.readRootBuildState(
        graph: BuildTreeWorkGraph,