if gvk != oldGVK {
		kind.SetGroupVersionKind(gvk)
		defer kind.SetGroupVersionKind(oldGVK)
	}

	return e.Encoder.Encode(obj, stream)
}

// WithoutVersionDecoder clears the group version kind of a deserialized object.
type WithoutVersionDecoder struct {
	Decoder
}

// Decode does not do conversion. It removes the gvk during deserialization.

        when:
        def deserializedMetadata = deserialize(bytes).asImmutable()
        def originMetadata = metadata.asImmutable()

        then:
        deserializedMetadata == originMetadata

        where:
        sample << sampleFiles()

    }

    private MutableModuleComponentResolveMetadata deserialize(byte[] serializedForm) {

    }

    private Isolatable<?> deserialize(byte[] bytes) {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        KryoBackedDecoder decoder = new KryoBackedDecoder(inputStream);
        try {
            return serializerRegistry.readIsolatable(decoder);
        } catch (Exception e) {
            throw new WorkSerializationException("Could not deserialize unit of work.", e);
        }
    }

      `dst_saved_model_path`.

      The user should pass a serialized `QuantizationOptions` for the
      `quantization_options_serialized` argument, and a signature key ->
      serialized `SignatureDef` mapping for the `signature_def_map_serialized`
      argument.

      `representative_dataset_file_map_serialized` is a signature key ->
      `RepresentativeDatasetFile` (serialized) mapping for running the

        this.fileAccess = fileAccess;
        this.serializer = serializer;
        this.chmod = chmod;
    }

    @Override
    public T get() {
        return fileAccess.readFile((Supplier<T>) this::deserialize);
    }

    @Override
    public void set(final T newValue) {
        fileAccess.writeFile(() -> serialize(newValue));
    }

    @Override
    public T update(final UpdateAction<T> updateAction) {

     * reason) will be replaced by a {@link PlaceholderException}.
     *
     * @param inputSteam stream to read the object from
     * @param classLoader loader used to load exception classes
     * @return the de-serialized object
     */

        synchronized (lock) {
            return cache.load(() -> {
                try {
                    return binaryData.read(decoder -> deserialize(decoder, graphResults, artifactResults, buildOperationProcessor));
                } finally {
                    try {
                        binaryData.close();
                    } catch (IOException e) {

  TFE_Context* ctx = TFE_NewContext(opts, status);
  EXPECT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);
  TFE_DeleteContextOptions(opts);

  TFE_ContextSetServerDef(ctx, 0, serialized.data(), serialized.size(), status);
  EXPECT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  const char task0_name[] = "/job:localhost/replica:0/task:0/device:CPU:0";

            return Result.nothing();
        }

        ClientProvidedBuildAction clientProvidedBuildAction = (ClientProvidedBuildAction) action;

        Object clientAction = payloadSerializer.deserialize(clientProvidedBuildAction.getAction());

        return runClientAction(new ClientActionImpl(clientAction, action), buildController);
    }

    private static class ClientActionImpl implements ClientAction {

// CHECK-LABEL: func @derived_attrs
func.func @derived_attrs(
  %serialized: tensor<?x!tf_type.string>,
  %names: tensor<0x!tf_type.string>,
  %sparse_keys: tensor<0x!tf_type.string>,
  %dense_keys: tensor<1x!tf_type.string>,
  %ragged_keys: tensor<0x!tf_type.string>,
  %dense_default: tensor<0xi64>) -> tensor<?xi64> {

  %dense_value =
    "tf.ParseExampleV2"(%serialized, %names, %sparse_keys, %dense_keys, %ragged_keys, %dense_default)