Map<String, String> targetAttributes = AttributesToMapConverter.convertToMap(targetComponentVariant.getAttributes());
        List<Capability> capabilities = targetComponentVariant.getCapabilities().asSet().stream()
            .map(TransformStepNode::convertCapability)
            .collect(Collectors.toList());

        return new DefaultPlannedTransformStepIdentity(
            consumerBuildPath,

    }

    void forEachCapability(CapabilitiesConflictHandler capabilitiesConflictHandler, Action<? super Capability> action) {
        ImmutableSet<ImmutableCapability> capabilities = metadata.getCapabilities().asSet();
        // If there's more than one node selected for the same component, we need to add
        // the implicit capability to the list, in order to make sure we can discover conflicts

    private static void writeCapabilities(Encoder encoder, ImmutableCapabilities capabilities) throws IOException {
        ImmutableSet<ImmutableCapability> capabilitiesSet = capabilities.asSet();
        encoder.writeSmallInt(capabilitiesSet.size());
        for (Capability capability : capabilitiesSet) {
            boolean shadowed = capability instanceof ShadowedCapability;
            if (shadowed) {

      ctx, module_op));

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      quant::ConvertAssetArgs(module_op);
  if (failed(asset_file_defs)) {
    return absl::InternalError("Failed to convert asset args.");
  }

  return *asset_file_defs;
}

   * #incidentNodes(Object)}). If this network does not {@link #allowsParallelEdges() allow parallel
   * edges}, the resulting set will contain at most one edge (equivalent to {@code
   * edgeConnecting(nodeU, nodeV).asSet()}).
   *
   * <p>If either {@code nodeU} or {@code nodeV} are removed from the network after this method is
   * called, the {@code Set} {@code view} returned by this method will be invalidated, and will

   * #incidentNodes(Object)}). If this network does not {@link #allowsParallelEdges() allow parallel
   * edges}, the resulting set will contain at most one edge (equivalent to {@code
   * edgeConnecting(nodeU, nodeV).asSet()}).
   *
   * <p>If either {@code nodeU} or {@code nodeV} are removed from the network after this method is
   * called, the {@code Set} {@code view} returned by this method will be invalidated, and will

  EXPECT_EQ(TF_NumDims(result), 0);
  tensorflow::tstring* output_value =
      static_cast<tensorflow::tstring*>(TF_TensorData(result));
  std::string file_contents(*output_value);
  EXPECT_NE(file_contents.find("TEST ASSET FILE CONTENTS"), std::string::npos);

  TF_DeleteTensor(result);
  TFE_DeleteTensorHandle(read_file_fn_outputs[0]);
  TFE_DeleteOp(read_file_op);
  TF_DeleteSavedModel(saved_model);
  TF_DeleteStatus(status);

                }
            }

            private boolean doesNotDeclareExplicitCapability(NodeState nodeState) {
                return nodeState.getMetadata().getCapabilities().asSet().isEmpty();
            }
        });
    }

    private boolean resolveEdges(
        final NodeState node,
        final List<EdgeState> dependencies,
        final Spec<EdgeState> dependencyFilter,

            }
        }

        private void writeVariantCapabilities(ImmutableCapabilities capabilities) throws IOException {
            ImmutableSet<ImmutableCapability> capabilitySet = capabilities.asSet();
            encoder.writeSmallInt(capabilitySet.size());
            for (Capability capability : capabilitySet) {
                boolean shadowed = capability instanceof ShadowedCapability;
                if (shadowed) {

cloud.google.com/go/area120 v0.8.1 h1:wiOq3KDpdqXmaHzvZwKdpoM+3lDcqsI2Lwhyac7stss=
cloud.google.com/go/artifactregistry v1.14.1 h1:k6hNqab2CubhWlGcSzunJ7kfxC7UzpAfQ1UPb9PDCKI=
cloud.google.com/go/asset v1.14.1 h1:vlHdznX70eYW4V1y1PxocvF6tEwxJTTarwIGwOhFF3U=
cloud.google.com/go/assuredworkloads v1.11.1 h1:yaO0kwS+SnhVSTF7BqTyVGt3DTocI6Jqo+S3hHmCwNk=
cloud.google.com/go/automl v1.13.1 h1:iP9iQurb0qbz+YOOMfKSEjhONA/WcoOIjt6/m+6pIgo=