Java Code Examples for com.google.protobuf.Value#getStringValue()

private static Object getScalarValue(Value value) {
  switch (value.getKindCase()) {
    case STRUCT_VALUE:
    case LIST_VALUE:
      throw new AssertionError("value should be scalar");
    case BOOL_VALUE:
      return value.getBoolValue();
    case NUMBER_VALUE:
      // Note: this assumes all numbers are doubles. Downstream code that have access to the
      // schema can convert this number to the correct number type.
      return value.getNumberValue();
    case STRING_VALUE:
      return value.getStringValue();
    default:
      break;
  }
  return value;
}
 

private static LocalDateTime parseTimestamp(Value proto) {
  if (proto.getKindCase() == KindCase.NULL_VALUE || proto.getStringValue() == null) {
    return null;
  }
  TemporalAccessor temporalAccessor = TIMESTAMP_FORMATTER.parse(proto.getStringValue());
  return LocalDateTime.ofInstant(Instant.from(temporalAccessor), ZoneOffset.UTC);
}
 

private static LocalDate parseDate(Value proto) {
  String date = proto.getStringValue();
  if (proto.getKindCase() == KindCase.NULL_VALUE || date == null) {
    return null;
  }
  Matcher matcher = FORMAT_REGEXP.matcher(date);
  if (!matcher.matches()) {
    throw new IllegalArgumentException("Invalid date: " + date);
  } else {
    int year = Integer.parseInt(matcher.group(1));
    int month = Integer.parseInt(matcher.group(2));
    int dayOfMonth = Integer.parseInt(matcher.group(3));
    return LocalDate.of(year, month, dayOfMonth);
  }
}
 

private void concatFirstIncompletePiece(PartialResultSet partialResultSet) {
  Value firstPiece = partialResultSet.getValues(0);
  // Concat code from client lib
  if (this.incompletePieceKind == KindCase.STRING_VALUE) {
    this.incompletePiece = this.incompletePiece + firstPiece.getStringValue();
  } else {
    concatLists((List<Value>) this.incompletePiece,
        firstPiece.getListValue().getValuesList());
  }
}
 

private static Object parseObject(String key, Value in, VCFHeaderLineType type) {
  // Case on type
  switch (in.getKindCase()) {
      case NULL_VALUE: throw new IllegalStateException(String.format("field %s contained "
          + "a null value", key));
      case NUMBER_VALUE: return getNumberValue(in.getNumberValue(), type);
      case STRING_VALUE: return in.getStringValue();
      case BOOL_VALUE: return (Boolean) in.getBoolValue();
      default: throw new IllegalStateException(String.format("field %s contained a %s type, which"
          + " is not supported by VariantToVcf", key, getKind(in.getKindCase())));
  }
}
 

@VisibleForTesting
static ChannelInfo extractChannelInfo(ConfigSource configSource) {
  checkNotNull(configSource, "configSource");
  checkArgument(
      configSource.hasApiConfigSource(), "only configSource with ApiConfigSource supported");
  ApiConfigSource apiConfigSource = configSource.getApiConfigSource();
  checkArgument(
      ApiType.GRPC.equals(apiConfigSource.getApiType()),
      "only GRPC ApiConfigSource type supported");
  checkArgument(
      apiConfigSource.getGrpcServicesCount() == 1,
      "expecting exactly 1 GrpcService in ApiConfigSource");
  GrpcService grpcService = apiConfigSource.getGrpcServices(0);
  checkArgument(
      grpcService.hasGoogleGrpc() && !grpcService.hasEnvoyGrpc(),
      "only GoogleGrpc expected in GrpcService");
  GoogleGrpc googleGrpc = grpcService.getGoogleGrpc();
  CallCredentials callCredentials = getVerifiedCredentials(googleGrpc);
  String targetUri = googleGrpc.getTargetUri();
  String channelType = null;
  if (googleGrpc.hasConfig()) {
    Struct struct = googleGrpc.getConfig();
    Value value = struct.getFieldsMap().get("channelType");
    channelType = value.getStringValue();
  }
  checkArgument(!Strings.isNullOrEmpty(targetUri), "targetUri in GoogleGrpc is empty!");
  return new ChannelInfo(targetUri, channelType, callCredentials);
}
 

private static String parseString(Value input) {
  return input.getKindCase() == KindCase.NULL_VALUE ? null : input.getStringValue();
}
 

private static ByteBuffer parseBytes(Value value) {
  if (value.getKindCase() == KindCase.NULL_VALUE || value.getStringValue() == null) {
    return null;
  }
  return ByteBuffer.wrap(value.getStringValueBytes().toByteArray());
}
 

private void initializeIncompletePiece(Value lastVal) {
  this.incompletePieceKind = lastVal.getKindCase();
  this.incompletePiece =
          lastVal.getKindCase() == KindCase.STRING_VALUE ? lastVal.getStringValue() :
                  new ArrayList<>(lastVal.getListValue().getValuesList());
}