func (*Address) ProtoMessage() {}

func (x *Address) ProtoReflect() protoreflect.Message {
	mi := &file_workloadapi_workload_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Address.ProtoReflect.Descriptor instead.

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

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "The messages and types sent between client and daemon"

dependencies {
    api(libs.jsr305)
    api(project(":base-services"))
    api(project(":logging-api"))
    api(project(":serialization"))
    api(project(":logging"))

}

description = """A problems description API
    |
    |This project provides base classes to describe problems and their
    |solutions, in a way that enforces the creation of good error messages.
    |
    |It's a stripped down version of the original code available
    |at https://github.com/melix/jdoctor/
""".trimMargin()

gradlebuildJava.usedInWorkers()

dependencies {

        throwWhen(new IOException("Could not dispatch a message to the daemon.", new IOException("An existing connection was forcibly closed by the remote host")), iteration == 1)

        then:
        IOException ioe = thrown()
        ioe.message == "Could not dispatch a message to the daemon."
    }

    private static void throwWhen(Throwable throwable, boolean condition) {

public class GradleException extends RuntimeException {
    public GradleException() {
        super();
    }

    public GradleException(String message) {
        super(message);
    }

    public GradleException(String message, @Nullable Throwable cause) {
        super(message, cause);
    }

			cniLog{
				Level:     "info",
				Time:      *wantT,
				Msg:       "my message",
				Arbitrary: nil,
			},
		},
		{
			"with keys",
			`{"level":"info","time":"2020-01-01T00:00:00.356374Z","msg":"my message","key":"string value","bar":2}`,
			cniLog{
				Level: "info",
				Time:  *wantT,
				Msg:   "my message",
				Arbitrary: map[string]any{

|:----------------------------------|:----------------------------------------------------------|
| `minio_audit_failed_messages`     | Total number of messages that failed to send since start. |
| `minio_audit_target_queue_length` | Number of unsent messages in queue for target.            |
| `minio_audit_total_messages`      | Total number of messages sent since start.                |

## Cluster Capacity Metrics

                            + (message != null ? ": " + message : ""));
                }
            }
        }

        if (logger.isDebugEnabled()) {
            node.accept(new DependencyGraphDumper(logger::debug));
        }

        try {

  Status status = tensorflow::tf2xla::v2::ConvertMlirToGraph(
      module_in, confs, &graph, &flib_def, &control_ret_nodes);
  if (!status.ok()) {
    mlir::emitError(mlir::UnknownLoc::get(&ctx)) << status.message();
    return signalPassFailure();
  }

  // Run each of the passes that were selected.
  GraphConstructorOptions opts;
  opts.allow_internal_ops = true;
  opts.expect_device_spec = false;

  if (failed(pm.run(module.get()))) {
    LOG(ERROR) << "Failed to sparsify: "
               << statusHandler.ConsumeStatus().message();
    return absl::InternalError(absl::StrCat(
        "Failed to sparsify: ", statusHandler.ConsumeStatus().message()));
  }

  // Export the results to the builder
  std::string result;
  tflite::FlatbufferExportOptions options;