Java Code Examples for com.google.protobuf.DescriptorProtos.MethodDescriptorProto#getServerStreaming()

private String generateMethod(MethodDescriptorProto method, String inPutType, String outPutType,
    String methodName, String inputValue) {
  String methodStr =
      "public " + outPutType + " " + methodName + "(" + inPutType + " " + inputValue + ");";
  boolean isClientStream = !method.getServerStreaming() && method.getClientStreaming();
  boolean isBidiStream = method.getServerStreaming() && method.getClientStreaming();
  boolean isServerStream = method.getServerStreaming() && !method.getClientStreaming();
  if (isClientStream || isBidiStream) {
    methodStr =
        "public " + inPutType + " " + methodName + "(" + outPutType + " responseObserver);";
  } else if (isServerStream) {
    methodStr = "public void " + methodName + "(" + inPutType + " " + inputValue + ","
        + outPutType + " responseObserver);";
  }
  return methodStr;
}
 

private static ClassName routeInterfaceClass(final MethodDescriptorProto methodProto, final boolean blocking) {
    return methodProto.getClientStreaming() ?
            (methodProto.getServerStreaming() ? blocking ? BlockingStreamingRoute : StreamingRoute :
                    blocking ? BlockingRequestStreamingRoute : RequestStreamingRoute) :
            (methodProto.getServerStreaming() ? blocking ? BlockingResponseStreamingRoute : ResponseStreamingRoute
                    : blocking ? BlockingRoute : Route);
}
 

private static ClassName clientCallClass(final MethodDescriptorProto methodProto, final boolean blocking) {
    if (!blocking) {
        return methodProto.getClientStreaming() ?
                (methodProto.getServerStreaming() ? StreamingClientCall : RequestStreamingClientCall) :
                (methodProto.getServerStreaming() ? ResponseStreamingClientCall : ClientCall);
    }

    return methodProto.getClientStreaming() ?
            (methodProto.getServerStreaming() ? BlockingStreamingClientCall : BlockingRequestStreamingClientCall) :
            (methodProto.getServerStreaming() ? BlockingResponseStreamingClientCall : BlockingClientCall);
}
 

private MethodContext buildMethodContext(MethodDescriptorProto methodProto, ProtoTypeMap typeMap, List<Location> locations, int methodNumber) {
    MethodContext methodContext = new MethodContext();
    methodContext.methodName = lowerCaseFirst(methodProto.getName());
    methodContext.inputType = typeMap.toJavaTypeName(methodProto.getInputType());
    methodContext.outputType = typeMap.toJavaTypeName(methodProto.getOutputType());
    methodContext.deprecated = methodProto.getOptions() != null && methodProto.getOptions().getDeprecated();
    methodContext.isManyInput = methodProto.getClientStreaming();
    methodContext.isManyOutput = methodProto.getServerStreaming();
    methodContext.methodNumber = methodNumber;

    Location methodLocation = locations.stream()
            .filter(location ->
                location.getPathCount() == METHOD_NUMBER_OF_PATHS &&
                    location.getPath(METHOD_NUMBER_OF_PATHS - 1) == methodNumber
            )
            .findFirst()
            .orElseGet(Location::getDefaultInstance);
    methodContext.javaDoc = getJavaDoc(getComments(methodLocation), getMethodJavaDocPrefix());

    if (!methodProto.getClientStreaming() && !methodProto.getServerStreaming()) {
        methodContext.reactiveCallsMethodName = "oneToOne";
        methodContext.grpcCallsMethodName = "asyncUnaryCall";
    }
    if (!methodProto.getClientStreaming() && methodProto.getServerStreaming()) {
        methodContext.reactiveCallsMethodName = "oneToMany";
        methodContext.grpcCallsMethodName = "asyncServerStreamingCall";
    }
    if (methodProto.getClientStreaming() && !methodProto.getServerStreaming()) {
        methodContext.reactiveCallsMethodName = "manyToOne";
        methodContext.grpcCallsMethodName = "asyncClientStreamingCall";
    }
    if (methodProto.getClientStreaming() && methodProto.getServerStreaming()) {
        methodContext.reactiveCallsMethodName = "manyToMany";
        methodContext.grpcCallsMethodName = "asyncBidiStreamingCall";
    }
    return methodContext;
}
 

@Override
protected List<String> collectFileData() {
  String className = super.getClassName();
  String packageName = super.getSourcePackageName().toLowerCase();
  List<String> fileData = Lists.newArrayList();
  fileData.add("package " + packageName + ";");
  fileData.add("public interface " + className + "{");
  for (MethodDescriptorProto method : serviceMethods) {
    String outPutType = method.getOutputType();
    String inPutType = method.getInputType();
    String methodName = method.getName();
    inPutType = CommonUtils.findPojoTypeFromCache(inPutType, pojoTypeCache);
    outPutType = CommonUtils.findPojoTypeFromCache(outPutType, pojoTypeCache);
    String stream = generateGrpcStream(method, inPutType, outPutType);
    if (method.getServerStreaming() || method.getClientStreaming()) {
      outPutType = "io.grpc.stub.StreamObserver<" + outPutType + ">";
    }
    String inputValue = CommonUtils.findNotIncludePackageType(inPutType).toLowerCase();
    if (method.getClientStreaming()) {
      inPutType = "io.grpc.stub.StreamObserver<" + inPutType + ">";
    }
    if (stream != null)
      fileData.add(stream);
    String methodStr = generateMethod(method, inPutType, outPutType, methodName, inputValue);
    fileData.add(methodStr);
  }
  fileData.add("}");
  return fileData;
}
 

private Method(Interface parent, MethodDescriptorProto proto, String path) {
  super(parent, proto.getName(), path);
  this.isDeprecated = proto.getOptions().getDeprecated();
  this.descriptor = new MethodDescriptor(proto);
  this.requestStreaming = proto.getClientStreaming();
  this.responseStreaming = proto.getServerStreaming();
}
 

private MethodSpec newRpcMethodSpec(final MethodDescriptorProto methodProto, final EnumSet<NewRpcMethodFlag> flags,
                                    final BiFunction<String, MethodSpec.Builder, MethodSpec.Builder>
                                            methodBuilderCustomizer) {

    final ClassName inClass = messageTypesMap.get(methodProto.getInputType());
    final ClassName outClass = messageTypesMap.get(methodProto.getOutputType());

    final String name = routeName(methodProto);

    final MethodSpec.Builder methodSpecBuilder = methodBuilderCustomizer.apply(name, methodBuilder(name))
            .addModifiers(PUBLIC);

    final Modifier[] mods = flags.contains(INTERFACE) ? new Modifier[0] : new Modifier[]{FINAL};

    if (flags.contains(BLOCKING)) {
        methodSpecBuilder.addException(Exception.class);

        if (methodProto.getClientStreaming()) {
            if (flags.contains(CLIENT)) {
                methodSpecBuilder.addParameter(ParameterizedTypeName.get(ClassName.get(Iterable.class),
                        inClass), request, mods);
            } else {
                methodSpecBuilder.addParameter(ParameterizedTypeName.get(BlockingIterable, inClass), request,
                        mods);
            }
        } else {
            methodSpecBuilder.addParameter(inClass, request, mods);
        }

        if (methodProto.getServerStreaming()) {
            if (flags.contains(CLIENT)) {
                methodSpecBuilder.returns(ParameterizedTypeName.get(BlockingIterable, outClass));
            } else {
                methodSpecBuilder.addParameter(ParameterizedTypeName.get(GrpcPayloadWriter, outClass),
                        "responseWriter", mods);
            }
        } else {
            methodSpecBuilder.returns(outClass);
        }
    } else {
        if (methodProto.getClientStreaming()) {
            methodSpecBuilder.addParameter(ParameterizedTypeName.get(Publisher, inClass), request, mods);
        } else {
            methodSpecBuilder.addParameter(inClass, request, mods);
        }

        if (methodProto.getServerStreaming()) {
            methodSpecBuilder.returns(ParameterizedTypeName.get(Publisher, outClass));
        } else {
            methodSpecBuilder.returns(ParameterizedTypeName.get(Single, outClass));
        }
    }

    return methodSpecBuilder.build();
}
 

private static ClassName routeInterfaceClass(final MethodDescriptorProto methodProto) {
    return methodProto.getClientStreaming() ?
            (methodProto.getServerStreaming() ? StreamingRoute : RequestStreamingRoute) :
            (methodProto.getServerStreaming() ? ResponseStreamingRoute : Route);
}
 

private static String routeFactoryMethodName(final MethodDescriptorProto methodProto) {
    return (methodProto.getClientStreaming() ?
            (methodProto.getServerStreaming() ? "streamingR" : "requestStreamingR") :
            (methodProto.getServerStreaming() ? "responseStreamingR" : "r")) +
            "outeFor";
}
 

private static String streamingNameModifier(final MethodDescriptorProto methodProto) {
    return methodProto.getClientStreaming() ?
            (methodProto.getServerStreaming() ? "Streaming" : "RequestStreaming") :
            (methodProto.getServerStreaming() ? "ResponseStreaming" : "");
}
 

private MethodContext buildMethodContext(MethodDescriptorProto methodProto, ProtoTypeMap typeMap, List<Location> locations,
                                         int methodNumber) {
    MethodContext methodContext = new MethodContext();
    methodContext.setMethodName(lowerCaseFirst(methodProto.getName()));
    methodContext.setInputType(typeMap.toJavaTypeName(methodProto.getInputType()));
    methodContext.setOutputType(typeMap.toJavaTypeName(methodProto.getOutputType()));
    methodContext.setDeprecated(methodProto.getOptions() != null && methodProto.getOptions().getDeprecated());
    methodContext.setManyInput(methodProto.getClientStreaming());
    methodContext.setManyOutput(methodProto.getServerStreaming());
    methodContext.setMethodNumber(methodNumber);

    Optional<Location> found = Optional.empty();
    for (Location location : locations) {
        if (location.getPathCount() == METHOD_NUMBER_OF_PATHS &&
                location.getPath(METHOD_NUMBER_OF_PATHS - 1) == methodNumber) {
            found = Optional.of(location);
            break;
        }
    }
    Location methodLocation = found
            .orElseGet(Location::getDefaultInstance);
    methodContext.setJavaDoc(getJavaDoc(getComments(methodLocation), getMethodJavaDocPrefix()));

    if (!methodProto.getClientStreaming() && !methodProto.getServerStreaming()) {
        methodContext.setReactiveCallsMethodName("oneToOne");
        methodContext.setGrpcCallsMethodName("asyncUnaryCall");
    }
    if (!methodProto.getClientStreaming() && methodProto.getServerStreaming()) {
        methodContext.setReactiveCallsMethodName("oneToMany");
        methodContext.setGrpcCallsMethodName("asyncServerStreamingCall");
    }
    if (methodProto.getClientStreaming() && !methodProto.getServerStreaming()) {
        methodContext.setReactiveCallsMethodName("manyToOne");
        methodContext.setGrpcCallsMethodName("asyncClientStreamingCall");
    }
    if (methodProto.getClientStreaming() && methodProto.getServerStreaming()) {
        methodContext.setReactiveCallsMethodName("manyToMany");
        methodContext.setGrpcCallsMethodName("asyncBidiStreamingCall");
    }
    return methodContext;
}