All Downloads are FREE. Search and download functionalities are using the official Maven repository.

main.grpc.com.streamlayer.sdkSettings.organization.branch.BranchGrpc Maven / Gradle / Ivy

There is a newer version: 5.133.1
Show newest version
package com.streamlayer.sdkSettings.organization.branch;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.65.1)",
    comments = "Source: streamlayer/sdkSettings/organization/branch/organization.branch.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class BranchGrpc {

  private BranchGrpc() {}

  public static final java.lang.String SERVICE_NAME = "streamlayer.sdkSettings.organization.branch.Branch";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor getRegisterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Register",
      requestType = com.streamlayer.sdkSettings.organization.branch.RegisterRequest.class,
      responseType = com.streamlayer.sdkSettings.organization.branch.RegisterResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRegisterMethod() {
    io.grpc.MethodDescriptor getRegisterMethod;
    if ((getRegisterMethod = BranchGrpc.getRegisterMethod) == null) {
      synchronized (BranchGrpc.class) {
        if ((getRegisterMethod = BranchGrpc.getRegisterMethod) == null) {
          BranchGrpc.getRegisterMethod = getRegisterMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Register"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.RegisterRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.RegisterResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getRegisterMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Get",
      requestType = com.streamlayer.sdkSettings.organization.branch.GetRequest.class,
      responseType = com.streamlayer.sdkSettings.organization.branch.GetResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetMethod() {
    io.grpc.MethodDescriptor getGetMethod;
    if ((getGetMethod = BranchGrpc.getGetMethod) == null) {
      synchronized (BranchGrpc.class) {
        if ((getGetMethod = BranchGrpc.getGetMethod) == null) {
          BranchGrpc.getGetMethod = getGetMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Get"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.GetRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.GetResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getGetMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetOrganizationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetOrganization",
      requestType = com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest.class,
      responseType = com.streamlayer.sdkSettings.organization.branch.GetOrganizationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetOrganizationMethod() {
    io.grpc.MethodDescriptor getGetOrganizationMethod;
    if ((getGetOrganizationMethod = BranchGrpc.getGetOrganizationMethod) == null) {
      synchronized (BranchGrpc.class) {
        if ((getGetOrganizationMethod = BranchGrpc.getGetOrganizationMethod) == null) {
          BranchGrpc.getGetOrganizationMethod = getGetOrganizationMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetOrganization"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.GetOrganizationResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getGetOrganizationMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRemoveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Remove",
      requestType = com.streamlayer.sdkSettings.organization.branch.RemoveRequest.class,
      responseType = com.streamlayer.sdkSettings.organization.branch.RemoveResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRemoveMethod() {
    io.grpc.MethodDescriptor getRemoveMethod;
    if ((getRemoveMethod = BranchGrpc.getRemoveMethod) == null) {
      synchronized (BranchGrpc.class) {
        if ((getRemoveMethod = BranchGrpc.getRemoveMethod) == null) {
          BranchGrpc.getRemoveMethod = getRemoveMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Remove"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.RemoveRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.RemoveResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getRemoveMethod;
  }

  private static volatile io.grpc.MethodDescriptor getUpdateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Update",
      requestType = com.streamlayer.sdkSettings.organization.branch.UpdateRequest.class,
      responseType = com.streamlayer.sdkSettings.organization.branch.UpdateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getUpdateMethod() {
    io.grpc.MethodDescriptor getUpdateMethod;
    if ((getUpdateMethod = BranchGrpc.getUpdateMethod) == null) {
      synchronized (BranchGrpc.class) {
        if ((getUpdateMethod = BranchGrpc.getUpdateMethod) == null) {
          BranchGrpc.getUpdateMethod = getUpdateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Update"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.UpdateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.sdkSettings.organization.branch.UpdateResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getUpdateMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static BranchStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BranchStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BranchStub(channel, callOptions);
        }
      };
    return BranchStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static BranchBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BranchBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BranchBlockingStub(channel, callOptions);
        }
      };
    return BranchBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static BranchFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BranchFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BranchFutureStub(channel, callOptions);
        }
      };
    return BranchFutureStub.newStub(factory, channel);
  }

  /**
   */
  public interface AsyncService {

    /**
     */
    default void register(com.streamlayer.sdkSettings.organization.branch.RegisterRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRegisterMethod(), responseObserver);
    }

    /**
     */
    default void get(com.streamlayer.sdkSettings.organization.branch.GetRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetMethod(), responseObserver);
    }

    /**
     */
    default void getOrganization(com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetOrganizationMethod(), responseObserver);
    }

    /**
     */
    default void remove(com.streamlayer.sdkSettings.organization.branch.RemoveRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRemoveMethod(), responseObserver);
    }

    /**
     */
    default void update(com.streamlayer.sdkSettings.organization.branch.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateMethod(), responseObserver);
    }
  }

  /**
   * Base class for the server implementation of the service Branch.
   */
  public static abstract class BranchImplBase
      implements io.grpc.BindableService, AsyncService {

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return BranchGrpc.bindService(this);
    }
  }

  /**
   * A stub to allow clients to do asynchronous rpc calls to service Branch.
   */
  public static final class BranchStub
      extends io.grpc.stub.AbstractAsyncStub {
    private BranchStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BranchStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BranchStub(channel, callOptions);
    }

    /**
     */
    public void register(com.streamlayer.sdkSettings.organization.branch.RegisterRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRegisterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void get(com.streamlayer.sdkSettings.organization.branch.GetRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getOrganization(com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetOrganizationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void remove(com.streamlayer.sdkSettings.organization.branch.RemoveRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRemoveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void update(com.streamlayer.sdkSettings.organization.branch.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * A stub to allow clients to do synchronous rpc calls to service Branch.
   */
  public static final class BranchBlockingStub
      extends io.grpc.stub.AbstractBlockingStub {
    private BranchBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BranchBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BranchBlockingStub(channel, callOptions);
    }

    /**
     */
    public com.streamlayer.sdkSettings.organization.branch.RegisterResponse register(com.streamlayer.sdkSettings.organization.branch.RegisterRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRegisterMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.sdkSettings.organization.branch.GetResponse get(com.streamlayer.sdkSettings.organization.branch.GetRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.sdkSettings.organization.branch.GetOrganizationResponse getOrganization(com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetOrganizationMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.sdkSettings.organization.branch.RemoveResponse remove(com.streamlayer.sdkSettings.organization.branch.RemoveRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRemoveMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.sdkSettings.organization.branch.UpdateResponse update(com.streamlayer.sdkSettings.organization.branch.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateMethod(), getCallOptions(), request);
    }
  }

  /**
   * A stub to allow clients to do ListenableFuture-style rpc calls to service Branch.
   */
  public static final class BranchFutureStub
      extends io.grpc.stub.AbstractFutureStub {
    private BranchFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BranchFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BranchFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture register(
        com.streamlayer.sdkSettings.organization.branch.RegisterRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRegisterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture get(
        com.streamlayer.sdkSettings.organization.branch.GetRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture getOrganization(
        com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetOrganizationMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture remove(
        com.streamlayer.sdkSettings.organization.branch.RemoveRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRemoveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture update(
        com.streamlayer.sdkSettings.organization.branch.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_REGISTER = 0;
  private static final int METHODID_GET = 1;
  private static final int METHODID_GET_ORGANIZATION = 2;
  private static final int METHODID_REMOVE = 3;
  private static final int METHODID_UPDATE = 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_REGISTER:
          serviceImpl.register((com.streamlayer.sdkSettings.organization.branch.RegisterRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET:
          serviceImpl.get((com.streamlayer.sdkSettings.organization.branch.GetRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ORGANIZATION:
          serviceImpl.getOrganization((com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_REMOVE:
          serviceImpl.remove((com.streamlayer.sdkSettings.organization.branch.RemoveRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE:
          serviceImpl.update((com.streamlayer.sdkSettings.organization.branch.UpdateRequest) 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();
      }
    }
  }

  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          getRegisterMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.sdkSettings.organization.branch.RegisterRequest,
              com.streamlayer.sdkSettings.organization.branch.RegisterResponse>(
                service, METHODID_REGISTER)))
        .addMethod(
          getGetMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.sdkSettings.organization.branch.GetRequest,
              com.streamlayer.sdkSettings.organization.branch.GetResponse>(
                service, METHODID_GET)))
        .addMethod(
          getGetOrganizationMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.sdkSettings.organization.branch.GetOrganizationRequest,
              com.streamlayer.sdkSettings.organization.branch.GetOrganizationResponse>(
                service, METHODID_GET_ORGANIZATION)))
        .addMethod(
          getRemoveMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.sdkSettings.organization.branch.RemoveRequest,
              com.streamlayer.sdkSettings.organization.branch.RemoveResponse>(
                service, METHODID_REMOVE)))
        .addMethod(
          getUpdateMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.sdkSettings.organization.branch.UpdateRequest,
              com.streamlayer.sdkSettings.organization.branch.UpdateResponse>(
                service, METHODID_UPDATE)))
        .build();
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (BranchGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .addMethod(getRegisterMethod())
              .addMethod(getGetMethod())
              .addMethod(getGetOrganizationMethod())
              .addMethod(getRemoveMethod())
              .addMethod(getUpdateMethod())
              .build();
        }
      }
    }
    return result;
  }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy