}
        }

        private void writeStopEvents(Encoder encoder, DaemonRegistryContent registry) throws Exception {
            List<DaemonStopEvent> stopEvents = registry.stopEvents;
            encoder.writeInt(stopEvents.size());
            for (DaemonStopEvent stopEvent : stopEvents) {
                DaemonStopEvent.SERIALIZER.write(encoder, stopEvent);
            }
        }

        this.logLevelSerializer = logLevelSerializer;
        this.throwableSerializer = throwableSerializer;
    }

    @Override
    public void write(Encoder encoder, LogEvent event) throws Exception {
        encoder.writeLong(event.getTimestamp());
        encoder.writeString(event.getCategory());
        logLevelSerializer.write(encoder, event.getLogLevel());
        encoder.writeNullableString(event.getMessage());

) : AbstractTransformStepNodeCodec<TransformStepNode.InitialTransformStepNode>() {

    override suspend fun WriteContext.doEncode(value: TransformStepNode.InitialTransformStepNode) {
        writeLong(value.transformStepNodeId)
        write(value.targetComponentVariant)
        write(value.sourceAttributes)
        write(unpackTransformStep(value))
        write(value.inputArtifact)
    }

            encoder.writeByte(MIXIN_CLASSLOADER_SPEC);
        } else {
            encoder.writeByte(VISITABLE_URL_CLASSLOADER_SPEC);
        }

        encoder.writeString(spec.getName());
        encoder.writeInt(spec.getClasspath().size());
        for (URL url : spec.getClasspath()) {
            encoder.writeString(url.toString());
        }
    }

    @Override

            valueMap.put(key, value);
        }
        return valueMap;
    }

    @Override
    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Utility methods and classes for I/O; for example input streams, output streams, readers, writers,
 * and files.
 *
 * <p>At the core of this package are the Source/Sink types: {@link ByteSource ByteSource}, {@link
 * CharSource CharSource}, {@link ByteSink ByteSink} and {@link CharSink CharSink}. They are

  fun inflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      inflater.reset()
    }

    deflatedBytes.writeAll(buffer)
    deflatedBytes.writeInt(OCTETS_TO_ADD_BEFORE_INFLATION)

    val totalBytesToRead = inflater.bytesRead + deflatedBytes.size

    // We cannot read all, as the source does not close.

        encodeStrings(encoder, spec.getResourcePrefixes());
    }

    private void encodeStrings(Encoder encoder, Set<String> strings) throws Exception {
        encoder.writeInt(strings.size());
        for (String string : strings) {
            encoder.writeString(string);
        }
    }

    @Override
    public FilteringClassLoader.Spec read(Decoder decoder) throws Exception {

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOutput = new DataOutputStream(out);
        try {
            dataOutput.writeByte(PROTOCOL_VERSION);
            dataOutput.writeLong(lockId);
            dataOutput.writeByte(type.ordinal());
            dataOutput.flush();
        } catch (IOException e) {

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = Type(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Type) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt(int(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Type) MarshalMsg(b []byte) (o []byte, err error) {