tech.ydb.proto.coordination.v1.CoordinationServiceGrpc Maven / Gradle / Ivy
package tech.ydb.proto.coordination.v1;
import static io.grpc.MethodDescriptor.generateFullMethodName;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.59.1)",
comments = "Source: ydb_coordination_v1.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class CoordinationServiceGrpc {
private CoordinationServiceGrpc() {}
public static final java.lang.String SERVICE_NAME = "Ydb.Coordination.V1.CoordinationService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getSessionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "Session",
requestType = tech.ydb.proto.coordination.SessionRequest.class,
responseType = tech.ydb.proto.coordination.SessionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
public static io.grpc.MethodDescriptor getSessionMethod() {
io.grpc.MethodDescriptor getSessionMethod;
if ((getSessionMethod = CoordinationServiceGrpc.getSessionMethod) == null) {
synchronized (CoordinationServiceGrpc.class) {
if ((getSessionMethod = CoordinationServiceGrpc.getSessionMethod) == null) {
CoordinationServiceGrpc.getSessionMethod = getSessionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "Session"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.SessionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.SessionResponse.getDefaultInstance()))
.setSchemaDescriptor(new CoordinationServiceMethodDescriptorSupplier("Session"))
.build();
}
}
}
return getSessionMethod;
}
private static volatile io.grpc.MethodDescriptor getCreateNodeMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CreateNode",
requestType = tech.ydb.proto.coordination.CreateNodeRequest.class,
responseType = tech.ydb.proto.coordination.CreateNodeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCreateNodeMethod() {
io.grpc.MethodDescriptor getCreateNodeMethod;
if ((getCreateNodeMethod = CoordinationServiceGrpc.getCreateNodeMethod) == null) {
synchronized (CoordinationServiceGrpc.class) {
if ((getCreateNodeMethod = CoordinationServiceGrpc.getCreateNodeMethod) == null) {
CoordinationServiceGrpc.getCreateNodeMethod = getCreateNodeMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateNode"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.CreateNodeRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.CreateNodeResponse.getDefaultInstance()))
.setSchemaDescriptor(new CoordinationServiceMethodDescriptorSupplier("CreateNode"))
.build();
}
}
}
return getCreateNodeMethod;
}
private static volatile io.grpc.MethodDescriptor getAlterNodeMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "AlterNode",
requestType = tech.ydb.proto.coordination.AlterNodeRequest.class,
responseType = tech.ydb.proto.coordination.AlterNodeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getAlterNodeMethod() {
io.grpc.MethodDescriptor getAlterNodeMethod;
if ((getAlterNodeMethod = CoordinationServiceGrpc.getAlterNodeMethod) == null) {
synchronized (CoordinationServiceGrpc.class) {
if ((getAlterNodeMethod = CoordinationServiceGrpc.getAlterNodeMethod) == null) {
CoordinationServiceGrpc.getAlterNodeMethod = getAlterNodeMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "AlterNode"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.AlterNodeRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.AlterNodeResponse.getDefaultInstance()))
.setSchemaDescriptor(new CoordinationServiceMethodDescriptorSupplier("AlterNode"))
.build();
}
}
}
return getAlterNodeMethod;
}
private static volatile io.grpc.MethodDescriptor getDropNodeMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DropNode",
requestType = tech.ydb.proto.coordination.DropNodeRequest.class,
responseType = tech.ydb.proto.coordination.DropNodeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDropNodeMethod() {
io.grpc.MethodDescriptor getDropNodeMethod;
if ((getDropNodeMethod = CoordinationServiceGrpc.getDropNodeMethod) == null) {
synchronized (CoordinationServiceGrpc.class) {
if ((getDropNodeMethod = CoordinationServiceGrpc.getDropNodeMethod) == null) {
CoordinationServiceGrpc.getDropNodeMethod = getDropNodeMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DropNode"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.DropNodeRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.DropNodeResponse.getDefaultInstance()))
.setSchemaDescriptor(new CoordinationServiceMethodDescriptorSupplier("DropNode"))
.build();
}
}
}
return getDropNodeMethod;
}
private static volatile io.grpc.MethodDescriptor getDescribeNodeMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DescribeNode",
requestType = tech.ydb.proto.coordination.DescribeNodeRequest.class,
responseType = tech.ydb.proto.coordination.DescribeNodeResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDescribeNodeMethod() {
io.grpc.MethodDescriptor getDescribeNodeMethod;
if ((getDescribeNodeMethod = CoordinationServiceGrpc.getDescribeNodeMethod) == null) {
synchronized (CoordinationServiceGrpc.class) {
if ((getDescribeNodeMethod = CoordinationServiceGrpc.getDescribeNodeMethod) == null) {
CoordinationServiceGrpc.getDescribeNodeMethod = getDescribeNodeMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DescribeNode"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.DescribeNodeRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.coordination.DescribeNodeResponse.getDefaultInstance()))
.setSchemaDescriptor(new CoordinationServiceMethodDescriptorSupplier("DescribeNode"))
.build();
}
}
}
return getDescribeNodeMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static CoordinationServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CoordinationServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceStub(channel, callOptions);
}
};
return CoordinationServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static CoordinationServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CoordinationServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceBlockingStub(channel, callOptions);
}
};
return CoordinationServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static CoordinationServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CoordinationServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceFutureStub(channel, callOptions);
}
};
return CoordinationServiceFutureStub.newStub(factory, channel);
}
/**
*/
public interface AsyncService {
/**
*
**
* Bidirectional stream used to establish a session with a coordination node
* Relevant APIs for managing semaphores, distributed locking, creating or
* restoring a previously established session are described using nested
* messages in SessionRequest and SessionResponse. Session is established
* with a specific coordination node (previously created using CreateNode
* below) and semaphores are local to that coordination node.
*
*/
default io.grpc.stub.StreamObserver session(
io.grpc.stub.StreamObserver responseObserver) {
return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getSessionMethod(), responseObserver);
}
/**
*
* Creates a new coordination node
*
*/
default void createNode(tech.ydb.proto.coordination.CreateNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateNodeMethod(), responseObserver);
}
/**
*
* Modifies settings of a coordination node
*
*/
default void alterNode(tech.ydb.proto.coordination.AlterNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAlterNodeMethod(), responseObserver);
}
/**
*
* Drops a coordination node
*
*/
default void dropNode(tech.ydb.proto.coordination.DropNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDropNodeMethod(), responseObserver);
}
/**
*
* Describes a coordination node
*
*/
default void describeNode(tech.ydb.proto.coordination.DescribeNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDescribeNodeMethod(), responseObserver);
}
}
/**
* Base class for the server implementation of the service CoordinationService.
*/
public static abstract class CoordinationServiceImplBase
implements io.grpc.BindableService, AsyncService {
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return CoordinationServiceGrpc.bindService(this);
}
}
/**
* A stub to allow clients to do asynchronous rpc calls to service CoordinationService.
*/
public static final class CoordinationServiceStub
extends io.grpc.stub.AbstractAsyncStub {
private CoordinationServiceStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CoordinationServiceStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceStub(channel, callOptions);
}
/**
*
**
* Bidirectional stream used to establish a session with a coordination node
* Relevant APIs for managing semaphores, distributed locking, creating or
* restoring a previously established session are described using nested
* messages in SessionRequest and SessionResponse. Session is established
* with a specific coordination node (previously created using CreateNode
* below) and semaphores are local to that coordination node.
*
*/
public io.grpc.stub.StreamObserver session(
io.grpc.stub.StreamObserver responseObserver) {
return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
getChannel().newCall(getSessionMethod(), getCallOptions()), responseObserver);
}
/**
*
* Creates a new coordination node
*
*/
public void createNode(tech.ydb.proto.coordination.CreateNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getCreateNodeMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Modifies settings of a coordination node
*
*/
public void alterNode(tech.ydb.proto.coordination.AlterNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getAlterNodeMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Drops a coordination node
*
*/
public void dropNode(tech.ydb.proto.coordination.DropNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getDropNodeMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Describes a coordination node
*
*/
public void describeNode(tech.ydb.proto.coordination.DescribeNodeRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getDescribeNodeMethod(), getCallOptions()), request, responseObserver);
}
}
/**
* A stub to allow clients to do synchronous rpc calls to service CoordinationService.
*/
public static final class CoordinationServiceBlockingStub
extends io.grpc.stub.AbstractBlockingStub {
private CoordinationServiceBlockingStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CoordinationServiceBlockingStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceBlockingStub(channel, callOptions);
}
/**
*
* Creates a new coordination node
*
*/
public tech.ydb.proto.coordination.CreateNodeResponse createNode(tech.ydb.proto.coordination.CreateNodeRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getCreateNodeMethod(), getCallOptions(), request);
}
/**
*
* Modifies settings of a coordination node
*
*/
public tech.ydb.proto.coordination.AlterNodeResponse alterNode(tech.ydb.proto.coordination.AlterNodeRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getAlterNodeMethod(), getCallOptions(), request);
}
/**
*
* Drops a coordination node
*
*/
public tech.ydb.proto.coordination.DropNodeResponse dropNode(tech.ydb.proto.coordination.DropNodeRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getDropNodeMethod(), getCallOptions(), request);
}
/**
*
* Describes a coordination node
*
*/
public tech.ydb.proto.coordination.DescribeNodeResponse describeNode(tech.ydb.proto.coordination.DescribeNodeRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getDescribeNodeMethod(), getCallOptions(), request);
}
}
/**
* A stub to allow clients to do ListenableFuture-style rpc calls to service CoordinationService.
*/
public static final class CoordinationServiceFutureStub
extends io.grpc.stub.AbstractFutureStub {
private CoordinationServiceFutureStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CoordinationServiceFutureStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CoordinationServiceFutureStub(channel, callOptions);
}
/**
*
* Creates a new coordination node
*
*/
public com.google.common.util.concurrent.ListenableFuture createNode(
tech.ydb.proto.coordination.CreateNodeRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getCreateNodeMethod(), getCallOptions()), request);
}
/**
*
* Modifies settings of a coordination node
*
*/
public com.google.common.util.concurrent.ListenableFuture alterNode(
tech.ydb.proto.coordination.AlterNodeRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getAlterNodeMethod(), getCallOptions()), request);
}
/**
*
* Drops a coordination node
*
*/
public com.google.common.util.concurrent.ListenableFuture dropNode(
tech.ydb.proto.coordination.DropNodeRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getDropNodeMethod(), getCallOptions()), request);
}
/**
*
* Describes a coordination node
*
*/
public com.google.common.util.concurrent.ListenableFuture describeNode(
tech.ydb.proto.coordination.DescribeNodeRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getDescribeNodeMethod(), getCallOptions()), request);
}
}
private static final int METHODID_CREATE_NODE = 0;
private static final int METHODID_ALTER_NODE = 1;
private static final int METHODID_DROP_NODE = 2;
private static final int METHODID_DESCRIBE_NODE = 3;
private static final int METHODID_SESSION = 4;
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 AsyncService serviceImpl;
private final int methodId;
MethodHandlers(AsyncService 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_CREATE_NODE:
serviceImpl.createNode((tech.ydb.proto.coordination.CreateNodeRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_ALTER_NODE:
serviceImpl.alterNode((tech.ydb.proto.coordination.AlterNodeRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_DROP_NODE:
serviceImpl.dropNode((tech.ydb.proto.coordination.DropNodeRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_DESCRIBE_NODE:
serviceImpl.describeNode((tech.ydb.proto.coordination.DescribeNodeRequest) 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) {
case METHODID_SESSION:
return (io.grpc.stub.StreamObserver) serviceImpl.session(
(io.grpc.stub.StreamObserver) responseObserver);
default:
throw new AssertionError();
}
}
}
public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getSessionMethod(),
io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
new MethodHandlers<
tech.ydb.proto.coordination.SessionRequest,
tech.ydb.proto.coordination.SessionResponse>(
service, METHODID_SESSION)))
.addMethod(
getCreateNodeMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.coordination.CreateNodeRequest,
tech.ydb.proto.coordination.CreateNodeResponse>(
service, METHODID_CREATE_NODE)))
.addMethod(
getAlterNodeMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.coordination.AlterNodeRequest,
tech.ydb.proto.coordination.AlterNodeResponse>(
service, METHODID_ALTER_NODE)))
.addMethod(
getDropNodeMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.coordination.DropNodeRequest,
tech.ydb.proto.coordination.DropNodeResponse>(
service, METHODID_DROP_NODE)))
.addMethod(
getDescribeNodeMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.coordination.DescribeNodeRequest,
tech.ydb.proto.coordination.DescribeNodeResponse>(
service, METHODID_DESCRIBE_NODE)))
.build();
}
private static abstract class CoordinationServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
CoordinationServiceBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return tech.ydb.proto.coordination.v1.CoordinationGrpc.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("CoordinationService");
}
}
private static final class CoordinationServiceFileDescriptorSupplier
extends CoordinationServiceBaseDescriptorSupplier {
CoordinationServiceFileDescriptorSupplier() {}
}
private static final class CoordinationServiceMethodDescriptorSupplier
extends CoordinationServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final java.lang.String methodName;
CoordinationServiceMethodDescriptorSupplier(java.lang.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 (CoordinationServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new CoordinationServiceFileDescriptorSupplier())
.addMethod(getSessionMethod())
.addMethod(getCreateNodeMethod())
.addMethod(getAlterNodeMethod())
.addMethod(getDropNodeMethod())
.addMethod(getDescribeNodeMethod())
.build();
}
}
}
return result;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy