com.daml.ledger.api.v2.UpdateServiceGrpc Maven / Gradle / Ivy
package com.daml.ledger.api.v2;
import static io.grpc.MethodDescriptor.generateFullMethodName;
/**
*
* Allows clients to read updates (transactions and reassignments) from the ledger.
* ``GetUpdates`` and ``GetUpdateTrees`` provide a comprehensive stream of updates/changes
* which happened on the virtual shared ledger. These streams are indexed with ledger
* offsets, which are strictly increasing.
* The virtual shared ledger consist of changes happening on multiple domains which are
* connected to the serving participant. Each update belongs to one domain, this is
* provided in the result (the ``domain_id`` field in ``Transaction`` and ``TransactionTree``
* for transactions, the ``source`` field in ``UnassignedEvent`` and the ``target`` field in ``AssignedEvent``).
* Consumers can rely on strong causal guarantees on the virtual shared ledger for a single
* domain: updates which have greater offsets are happened after than updates with smaller
* offsets for the same domain. Across different domains this is not guaranteed.
*
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler",
comments = "Source: com/daml/ledger/api/v2/update_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class UpdateServiceGrpc {
private UpdateServiceGrpc() {}
public static final String SERVICE_NAME = "com.daml.ledger.api.v2.UpdateService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getGetUpdatesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetUpdates",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
public static io.grpc.MethodDescriptor getGetUpdatesMethod() {
io.grpc.MethodDescriptor getGetUpdatesMethod;
if ((getGetUpdatesMethod = UpdateServiceGrpc.getGetUpdatesMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetUpdatesMethod = UpdateServiceGrpc.getGetUpdatesMethod) == null) {
UpdateServiceGrpc.getGetUpdatesMethod = getGetUpdatesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetUpdates"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetUpdates"))
.build();
}
}
}
return getGetUpdatesMethod;
}
private static volatile io.grpc.MethodDescriptor getGetUpdateTreesMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetUpdateTrees",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdateTreesResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
public static io.grpc.MethodDescriptor getGetUpdateTreesMethod() {
io.grpc.MethodDescriptor getGetUpdateTreesMethod;
if ((getGetUpdateTreesMethod = UpdateServiceGrpc.getGetUpdateTreesMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetUpdateTreesMethod = UpdateServiceGrpc.getGetUpdateTreesMethod) == null) {
UpdateServiceGrpc.getGetUpdateTreesMethod = getGetUpdateTreesMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetUpdateTrees"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdateTreesResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetUpdateTrees"))
.build();
}
}
}
return getGetUpdateTreesMethod;
}
private static volatile io.grpc.MethodDescriptor getGetTransactionTreeByEventIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetTransactionTreeByEventId",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetTransactionTreeByEventIdMethod() {
io.grpc.MethodDescriptor getGetTransactionTreeByEventIdMethod;
if ((getGetTransactionTreeByEventIdMethod = UpdateServiceGrpc.getGetTransactionTreeByEventIdMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetTransactionTreeByEventIdMethod = UpdateServiceGrpc.getGetTransactionTreeByEventIdMethod) == null) {
UpdateServiceGrpc.getGetTransactionTreeByEventIdMethod = getGetTransactionTreeByEventIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTransactionTreeByEventId"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetTransactionTreeByEventId"))
.build();
}
}
}
return getGetTransactionTreeByEventIdMethod;
}
private static volatile io.grpc.MethodDescriptor getGetTransactionTreeByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetTransactionTreeById",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetTransactionTreeByIdMethod() {
io.grpc.MethodDescriptor getGetTransactionTreeByIdMethod;
if ((getGetTransactionTreeByIdMethod = UpdateServiceGrpc.getGetTransactionTreeByIdMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetTransactionTreeByIdMethod = UpdateServiceGrpc.getGetTransactionTreeByIdMethod) == null) {
UpdateServiceGrpc.getGetTransactionTreeByIdMethod = getGetTransactionTreeByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTransactionTreeById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetTransactionTreeById"))
.build();
}
}
}
return getGetTransactionTreeByIdMethod;
}
private static volatile io.grpc.MethodDescriptor getGetTransactionByEventIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetTransactionByEventId",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetTransactionByEventIdMethod() {
io.grpc.MethodDescriptor getGetTransactionByEventIdMethod;
if ((getGetTransactionByEventIdMethod = UpdateServiceGrpc.getGetTransactionByEventIdMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetTransactionByEventIdMethod = UpdateServiceGrpc.getGetTransactionByEventIdMethod) == null) {
UpdateServiceGrpc.getGetTransactionByEventIdMethod = getGetTransactionByEventIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTransactionByEventId"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetTransactionByEventId"))
.build();
}
}
}
return getGetTransactionByEventIdMethod;
}
private static volatile io.grpc.MethodDescriptor getGetTransactionByIdMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetTransactionById",
requestType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest.class,
responseType = com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetTransactionByIdMethod() {
io.grpc.MethodDescriptor getGetTransactionByIdMethod;
if ((getGetTransactionByIdMethod = UpdateServiceGrpc.getGetTransactionByIdMethod) == null) {
synchronized (UpdateServiceGrpc.class) {
if ((getGetTransactionByIdMethod = UpdateServiceGrpc.getGetTransactionByIdMethod) == null) {
UpdateServiceGrpc.getGetTransactionByIdMethod = getGetTransactionByIdMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTransactionById"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse.getDefaultInstance()))
.setSchemaDescriptor(new UpdateServiceMethodDescriptorSupplier("GetTransactionById"))
.build();
}
}
}
return getGetTransactionByIdMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static UpdateServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public UpdateServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceStub(channel, callOptions);
}
};
return UpdateServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static UpdateServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public UpdateServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceBlockingStub(channel, callOptions);
}
};
return UpdateServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static UpdateServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public UpdateServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceFutureStub(channel, callOptions);
}
};
return UpdateServiceFutureStub.newStub(factory, channel);
}
/**
*
* Allows clients to read updates (transactions and reassignments) from the ledger.
* ``GetUpdates`` and ``GetUpdateTrees`` provide a comprehensive stream of updates/changes
* which happened on the virtual shared ledger. These streams are indexed with ledger
* offsets, which are strictly increasing.
* The virtual shared ledger consist of changes happening on multiple domains which are
* connected to the serving participant. Each update belongs to one domain, this is
* provided in the result (the ``domain_id`` field in ``Transaction`` and ``TransactionTree``
* for transactions, the ``source`` field in ``UnassignedEvent`` and the ``target`` field in ``AssignedEvent``).
* Consumers can rely on strong causal guarantees on the virtual shared ledger for a single
* domain: updates which have greater offsets are happened after than updates with smaller
* offsets for the same domain. Across different domains this is not guaranteed.
*
*/
public static abstract class UpdateServiceImplBase implements io.grpc.BindableService {
/**
*
* Read the ledger's filtered transaction stream and related reassignments for a set of parties.
* For transactions it lists only creates and archives, but no other events.
* Omits all events on transient contracts, i.e., contracts that were both created and archived in the same transaction.
*
*/
public void getUpdates(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetUpdatesMethod(), responseObserver);
}
/**
*
* Read the ledger's complete transaction tree stream and related reassignments for a set of parties.
* The stream will be filtered only by the parties as wildcard parties.
* The template/interface filters describe the respective fields in the ``CreatedEvent`` results.
*
*/
public void getUpdateTrees(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetUpdateTreesMethod(), responseObserver);
}
/**
*
* Lookup a transaction tree by the ID of an event that appears within it.
* For looking up a transaction instead of a transaction tree, please see GetTransactionByEventId
*
*/
public void getTransactionTreeByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTransactionTreeByEventIdMethod(), responseObserver);
}
/**
*
* Lookup a transaction tree by its ID.
* For looking up a transaction instead of a transaction tree, please see GetTransactionById
*
*/
public void getTransactionTreeById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTransactionTreeByIdMethod(), responseObserver);
}
/**
*
* Lookup a transaction by the ID of an event that appears within it.
*
*/
public void getTransactionByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTransactionByEventIdMethod(), responseObserver);
}
/**
*
* Lookup a transaction by its ID.
*
*/
public void getTransactionById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTransactionByIdMethod(), responseObserver);
}
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getGetUpdatesMethod(),
io.grpc.stub.ServerCalls.asyncServerStreamingCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesResponse>(
this, METHODID_GET_UPDATES)))
.addMethod(
getGetUpdateTreesMethod(),
io.grpc.stub.ServerCalls.asyncServerStreamingCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdateTreesResponse>(
this, METHODID_GET_UPDATE_TREES)))
.addMethod(
getGetTransactionTreeByEventIdMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse>(
this, METHODID_GET_TRANSACTION_TREE_BY_EVENT_ID)))
.addMethod(
getGetTransactionTreeByIdMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse>(
this, METHODID_GET_TRANSACTION_TREE_BY_ID)))
.addMethod(
getGetTransactionByEventIdMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse>(
this, METHODID_GET_TRANSACTION_BY_EVENT_ID)))
.addMethod(
getGetTransactionByIdMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest,
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse>(
this, METHODID_GET_TRANSACTION_BY_ID)))
.build();
}
}
/**
*
* Allows clients to read updates (transactions and reassignments) from the ledger.
* ``GetUpdates`` and ``GetUpdateTrees`` provide a comprehensive stream of updates/changes
* which happened on the virtual shared ledger. These streams are indexed with ledger
* offsets, which are strictly increasing.
* The virtual shared ledger consist of changes happening on multiple domains which are
* connected to the serving participant. Each update belongs to one domain, this is
* provided in the result (the ``domain_id`` field in ``Transaction`` and ``TransactionTree``
* for transactions, the ``source`` field in ``UnassignedEvent`` and the ``target`` field in ``AssignedEvent``).
* Consumers can rely on strong causal guarantees on the virtual shared ledger for a single
* domain: updates which have greater offsets are happened after than updates with smaller
* offsets for the same domain. Across different domains this is not guaranteed.
*
*/
public static final class UpdateServiceStub extends io.grpc.stub.AbstractAsyncStub {
private UpdateServiceStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected UpdateServiceStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceStub(channel, callOptions);
}
/**
*
* Read the ledger's filtered transaction stream and related reassignments for a set of parties.
* For transactions it lists only creates and archives, but no other events.
* Omits all events on transient contracts, i.e., contracts that were both created and archived in the same transaction.
*
*/
public void getUpdates(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncServerStreamingCall(
getChannel().newCall(getGetUpdatesMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Read the ledger's complete transaction tree stream and related reassignments for a set of parties.
* The stream will be filtered only by the parties as wildcard parties.
* The template/interface filters describe the respective fields in the ``CreatedEvent`` results.
*
*/
public void getUpdateTrees(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncServerStreamingCall(
getChannel().newCall(getGetUpdateTreesMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Lookup a transaction tree by the ID of an event that appears within it.
* For looking up a transaction instead of a transaction tree, please see GetTransactionByEventId
*
*/
public void getTransactionTreeByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetTransactionTreeByEventIdMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Lookup a transaction tree by its ID.
* For looking up a transaction instead of a transaction tree, please see GetTransactionById
*
*/
public void getTransactionTreeById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetTransactionTreeByIdMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Lookup a transaction by the ID of an event that appears within it.
*
*/
public void getTransactionByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetTransactionByEventIdMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Lookup a transaction by its ID.
*
*/
public void getTransactionById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetTransactionByIdMethod(), getCallOptions()), request, responseObserver);
}
}
/**
*
* Allows clients to read updates (transactions and reassignments) from the ledger.
* ``GetUpdates`` and ``GetUpdateTrees`` provide a comprehensive stream of updates/changes
* which happened on the virtual shared ledger. These streams are indexed with ledger
* offsets, which are strictly increasing.
* The virtual shared ledger consist of changes happening on multiple domains which are
* connected to the serving participant. Each update belongs to one domain, this is
* provided in the result (the ``domain_id`` field in ``Transaction`` and ``TransactionTree``
* for transactions, the ``source`` field in ``UnassignedEvent`` and the ``target`` field in ``AssignedEvent``).
* Consumers can rely on strong causal guarantees on the virtual shared ledger for a single
* domain: updates which have greater offsets are happened after than updates with smaller
* offsets for the same domain. Across different domains this is not guaranteed.
*
*/
public static final class UpdateServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
private UpdateServiceBlockingStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected UpdateServiceBlockingStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceBlockingStub(channel, callOptions);
}
/**
*
* Read the ledger's filtered transaction stream and related reassignments for a set of parties.
* For transactions it lists only creates and archives, but no other events.
* Omits all events on transient contracts, i.e., contracts that were both created and archived in the same transaction.
*
*/
public java.util.Iterator getUpdates(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request) {
return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
getChannel(), getGetUpdatesMethod(), getCallOptions(), request);
}
/**
*
* Read the ledger's complete transaction tree stream and related reassignments for a set of parties.
* The stream will be filtered only by the parties as wildcard parties.
* The template/interface filters describe the respective fields in the ``CreatedEvent`` results.
*
*/
public java.util.Iterator getUpdateTrees(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest request) {
return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
getChannel(), getGetUpdateTreesMethod(), getCallOptions(), request);
}
/**
*
* Lookup a transaction tree by the ID of an event that appears within it.
* For looking up a transaction instead of a transaction tree, please see GetTransactionByEventId
*
*/
public com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse getTransactionTreeByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetTransactionTreeByEventIdMethod(), getCallOptions(), request);
}
/**
*
* Lookup a transaction tree by its ID.
* For looking up a transaction instead of a transaction tree, please see GetTransactionById
*
*/
public com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionTreeResponse getTransactionTreeById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetTransactionTreeByIdMethod(), getCallOptions(), request);
}
/**
*
* Lookup a transaction by the ID of an event that appears within it.
*
*/
public com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse getTransactionByEventId(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetTransactionByEventIdMethod(), getCallOptions(), request);
}
/**
*
* Lookup a transaction by its ID.
*
*/
public com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionResponse getTransactionById(com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetTransactionByIdMethod(), getCallOptions(), request);
}
}
/**
*
* Allows clients to read updates (transactions and reassignments) from the ledger.
* ``GetUpdates`` and ``GetUpdateTrees`` provide a comprehensive stream of updates/changes
* which happened on the virtual shared ledger. These streams are indexed with ledger
* offsets, which are strictly increasing.
* The virtual shared ledger consist of changes happening on multiple domains which are
* connected to the serving participant. Each update belongs to one domain, this is
* provided in the result (the ``domain_id`` field in ``Transaction`` and ``TransactionTree``
* for transactions, the ``source`` field in ``UnassignedEvent`` and the ``target`` field in ``AssignedEvent``).
* Consumers can rely on strong causal guarantees on the virtual shared ledger for a single
* domain: updates which have greater offsets are happened after than updates with smaller
* offsets for the same domain. Across different domains this is not guaranteed.
*
*/
public static final class UpdateServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
private UpdateServiceFutureStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected UpdateServiceFutureStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new UpdateServiceFutureStub(channel, callOptions);
}
/**
*
* Lookup a transaction tree by the ID of an event that appears within it.
* For looking up a transaction instead of a transaction tree, please see GetTransactionByEventId
*
*/
public com.google.common.util.concurrent.ListenableFuture getTransactionTreeByEventId(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetTransactionTreeByEventIdMethod(), getCallOptions()), request);
}
/**
*
* Lookup a transaction tree by its ID.
* For looking up a transaction instead of a transaction tree, please see GetTransactionById
*
*/
public com.google.common.util.concurrent.ListenableFuture getTransactionTreeById(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetTransactionTreeByIdMethod(), getCallOptions()), request);
}
/**
*
* Lookup a transaction by the ID of an event that appears within it.
*
*/
public com.google.common.util.concurrent.ListenableFuture getTransactionByEventId(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetTransactionByEventIdMethod(), getCallOptions()), request);
}
/**
*
* Lookup a transaction by its ID.
*
*/
public com.google.common.util.concurrent.ListenableFuture getTransactionById(
com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetTransactionByIdMethod(), getCallOptions()), request);
}
}
private static final int METHODID_GET_UPDATES = 0;
private static final int METHODID_GET_UPDATE_TREES = 1;
private static final int METHODID_GET_TRANSACTION_TREE_BY_EVENT_ID = 2;
private static final int METHODID_GET_TRANSACTION_TREE_BY_ID = 3;
private static final int METHODID_GET_TRANSACTION_BY_EVENT_ID = 4;
private static final int METHODID_GET_TRANSACTION_BY_ID = 5;
private static final class MethodHandlers implements
io.grpc.stub.ServerCalls.UnaryMethod,
io.grpc.stub.ServerCalls.ServerStreamingMethod,
io.grpc.stub.ServerCalls.ClientStreamingMethod,
io.grpc.stub.ServerCalls.BidiStreamingMethod {
private final UpdateServiceImplBase serviceImpl;
private final int methodId;
MethodHandlers(UpdateServiceImplBase serviceImpl, int methodId) {
this.serviceImpl = serviceImpl;
this.methodId = methodId;
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
case METHODID_GET_UPDATES:
serviceImpl.getUpdates((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_UPDATE_TREES:
serviceImpl.getUpdateTrees((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetUpdatesRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_TRANSACTION_TREE_BY_EVENT_ID:
serviceImpl.getTransactionTreeByEventId((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_TRANSACTION_TREE_BY_ID:
serviceImpl.getTransactionTreeById((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_TRANSACTION_BY_EVENT_ID:
serviceImpl.getTransactionByEventId((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByEventIdRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_TRANSACTION_BY_ID:
serviceImpl.getTransactionById((com.daml.ledger.api.v2.UpdateServiceOuterClass.GetTransactionByIdRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
default:
throw new AssertionError();
}
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public io.grpc.stub.StreamObserver invoke(
io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
default:
throw new AssertionError();
}
}
}
private static abstract class UpdateServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
UpdateServiceBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return com.daml.ledger.api.v2.UpdateServiceOuterClass.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("UpdateService");
}
}
private static final class UpdateServiceFileDescriptorSupplier
extends UpdateServiceBaseDescriptorSupplier {
UpdateServiceFileDescriptorSupplier() {}
}
private static final class UpdateServiceMethodDescriptorSupplier
extends UpdateServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final String methodName;
UpdateServiceMethodDescriptorSupplier(String methodName) {
this.methodName = methodName;
}
@java.lang.Override
public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
return getServiceDescriptor().findMethodByName(methodName);
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (UpdateServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new UpdateServiceFileDescriptorSupplier())
.addMethod(getGetUpdatesMethod())
.addMethod(getGetUpdateTreesMethod())
.addMethod(getGetTransactionTreeByEventIdMethod())
.addMethod(getGetTransactionTreeByIdMethod())
.addMethod(getGetTransactionByEventIdMethod())
.addMethod(getGetTransactionByIdMethod())
.build();
}
}
}
return result;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy