@Test
public void addBasicBinding() {
  StatementBindings statementBindings = new StatementBindings();
  statementBindings.createBind("name", "John");
  statementBindings.createBind("age", 50);
  statementBindings.createBind("array", new String[]{"a", "b"});
  statementBindings.completeBinding();

  assertThat(statementBindings.getTypes())
      .containsExactly(
        entry("array", Type.newBuilder().setCode(TypeCode.ARRAY)
            .setArrayElementType(Type.newBuilder().setCode(TypeCode.STRING).build()).build()),
        entry("name", Type.newBuilder().setCode(TypeCode.STRING).build()),
        entry("age", Type.newBuilder().setCode(TypeCode.INT64).build())
      );

  assertThat(statementBindings.getBindings())
      .containsExactly(
          Struct.newBuilder()
              .putFields("name", Value.newBuilder().setStringValue("John").build())
              .putFields("age", Value.newBuilder().setStringValue("50").build())
              .putFields("array", Value.newBuilder().setListValue(
                  ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("a").build())
                      .addValues(Value.newBuilder().setStringValue("b").build()).build()).build())
              .build());
}
 

@Query("sayHello")
HelloReply sayHello(
    HelloRequest request,
    StreamingGreeterGrpc.StreamingGreeterStub client,
    DataFetchingEnvironment dataFetchingEnvironment) {
  client.sayHelloStreaming(
      request,
      new GraphQlStreamObserver<HelloReply, GraphQlResponse>(dataFetchingEnvironment) {
        @Override
        protected GraphQlResponse getData(HelloReply value, ListValue path) {
          // TODO: how can this be improved?
          QueryType data =
              QueryType.newBuilder()
                  .setHelloReply(
                      io.grpc.examples.graphql.HelloReply.newBuilder()
                          .setMessage(value.getMessage())
                          .build())
                  .build();

          return GraphQlResponse.newBuilder().setPath(path).setData(data).build();
        }
      });

  return null;
}
 

@Override
public void doMerge(JsonParser parser, int currentDepth, Message.Builder messageBuilder)
    throws IOException {
  Value.Builder builder = (Value.Builder) messageBuilder;
  JsonToken token = parser.currentToken();
  if (token.isBoolean()) {
    builder.setBoolValue(ParseSupport.parseBool(parser));
  } else if (token.isNumeric()) {
    builder.setNumberValue(ParseSupport.parseDouble(parser));
  } else if (token == JsonToken.VALUE_NULL) {
    builder.setNullValue(NullValue.NULL_VALUE);
  } else if (token.isScalarValue()) {
    builder.setStringValue(ParseSupport.parseString(parser));
  } else if (token == JsonToken.START_OBJECT) {
    Struct.Builder structBuilder = builder.getStructValueBuilder();
    StructMarshaller.INSTANCE.mergeValue(parser, currentDepth + 1, structBuilder);
  } else if (token == JsonToken.START_ARRAY) {
    ListValue.Builder listValueBuilder = builder.getListValueBuilder();
    ListValueMarshaller.INSTANCE.mergeValue(parser, currentDepth + 1, listValueBuilder);
  } else {
    throw new IllegalStateException("Unexpected json data: " + parser.getText());
  }
}
 

@Test
public void anyInMaps() throws Exception {
  TestAny.Builder testAny = TestAny.newBuilder();
  testAny.putAnyMap("int32_wrapper", Any.pack(Int32Value.newBuilder().setValue(123).build()));
  testAny.putAnyMap("int64_wrapper", Any.pack(Int64Value.newBuilder().setValue(456).build()));
  testAny.putAnyMap("timestamp", Any.pack(Timestamps.parse("1969-12-31T23:59:59Z")));
  testAny.putAnyMap("duration", Any.pack(Durations.parse("12345.1s")));
  testAny.putAnyMap("field_mask", Any.pack(FieldMaskUtil.fromString("foo.bar,baz")));
  Value numberValue = Value.newBuilder().setNumberValue(1.125).build();
  Struct.Builder struct = Struct.newBuilder();
  struct.putFields("number", numberValue);
  testAny.putAnyMap("struct", Any.pack(struct.build()));
  Value nullValue = Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build();
  testAny.putAnyMap(
      "list_value",
      Any.pack(ListValue.newBuilder().addValues(numberValue).addValues(nullValue).build()));
  testAny.putAnyMap("number_value", Any.pack(numberValue));
  testAny.putAnyMap("any_value_number", Any.pack(Any.pack(numberValue)));
  testAny.putAnyMap("any_value_default", Any.pack(Any.getDefaultInstance()));
  testAny.putAnyMap("default", Any.getDefaultInstance());

  assertMatchesUpstream(testAny.build(), TestAllTypes.getDefaultInstance());
}
 

private static boolean parseInlineGenotypeFields(String field, VariantCall.Builder vcBuilder,
    ListValue.Builder lvBuilder, IntGenotypeFieldAccessors.Accessor accessor, Genotype g) {

  final int[] intValues = accessor.getValues(g);
  if (intValues == null || intValues.length == 0) {
    return false;
  }

  if (field.equals(VCFConstants.GENOTYPE_PL_KEY)) {
    // HTSJDK folds GL's into PL's. We only use PL's to store genotype likelihood.
    for (int i = 0; i < intValues.length; i++) {
      // We add 0.0 to remove the possiblity of getting -0.0.
      vcBuilder.addGenotypeLikelihood(-(double) intValues[i] / 10.0 + 0.0);
    }
    return false;
  }

  for (int i = 0; i < intValues.length; i++) {
    lvBuilder.addValues(Value.newBuilder().setNumberValue(intValues[i]));
  }
  return true;
}
 

private static VariantCall makeVariantCall(
    String name, int[] g, double[] gl, boolean isPhased, Map<String, ListValue> info) {
  VariantCall.Builder vcBuilder = VariantCall.newBuilder().setCallSetName(name);
  if (g != null) {
    for (int i = 0; i < g.length; i++) {
      vcBuilder.addGenotype(g[i]);
    }
    if (isPhased && g.length > 1) {
      vcBuilder.setPhaseset("*");
    }
  }
  if (gl != null) {
    for (int i = 0; i < gl.length; i++) {
      vcBuilder.addGenotypeLikelihood(gl[i]);
    }
  }
  if (info != null) {
    vcBuilder.getMutableInfo().putAll(info);
  }

  return vcBuilder.build();
}
 

@ProcessElement
public void processElement(ProcessContext c) throws Exception {
  ListValue lv = c.element().getInfo().get("AF");
  if (lv != null && lv.getValuesCount() > 0) {
    Position position = Position.newBuilder()
        .setPosition(c.element().getStart())
        .setReferenceName(c.element().getReferenceName())
        .build();
    AlleleFreq af = new AlleleFreq();
    af.setRefFreq(Double.parseDouble(lv.getValues(0).getStringValue()));
    af.setAltBases(c.element().getAlternateBasesList());
    af.setRefBases(c.element().getReferenceBases());
    c.output(KV.of(position, af));
  } else {
    // AF field wasn't populated in info, so we don't have frequency information
    // for this Variant.
    // TODO instead of straight throwing an exception, log a warning.  If at the end of this
    // step the number of AlleleFreqs retrieved is below a given threshold, then throw an
    // exception.
    throw new IllegalArgumentException("Variant " + c.element().getId() + " does not have "
       + "allele frequency information stored in INFO field AF.");
  }
}
 

@Test
public void testGetAlleleFreq() throws Exception {
  DoFnTester<Variant, KV<Position, AlleleFreq>> getAlleleFreq = DoFnTester.of(
      new GetAlleleFreq());
  Position pos = Position.newBuilder()
      .setReferenceName("1")
      .setPosition(123L)
      .build();
  Variant.Builder vBuild = Variant.newBuilder()
      .setReferenceName("1")
      .setStart(123L)
      .setReferenceBases("C")
      .addAlternateBases("T");
  vBuild.getMutableInfo().put("AF", ListValue.newBuilder()
      .addValues(Value.newBuilder().setStringValue("0.25").build()).build());
  AlleleFreq af = new AlleleFreq();
  af.setAltBases(Lists.newArrayList("T"));
  af.setRefBases("C");
  af.setRefFreq(0.25);
  Assert.assertThat(getAlleleFreq.processBundle(vBuild.build()),
      CoreMatchers.hasItems(KV.of(pos, af)));
}
 

@Test
public void itReadsAllStructValueTypes() throws IOException {
  String json = "{\"struct\":{\"null\":null,\"number\":1.5,\"string\":\"test\",\"boolean\":true,\"struct\":{\"key\":\"nested\"},\"list\":[\"nested\"]}}";
  HasStruct message = camelCase().readValue(json, HasStruct.class);
  assertThat(message.hasStruct()).isTrue();

  Map<String, Value> map = message.getStruct().getFieldsMap();
  Value nested = Value.newBuilder().setStringValue("nested").build();
  Struct nestedStruct = Struct.newBuilder().putFields("key", nested).build();
  ListValue list = ListValue.newBuilder().addValues(nested).build();

  assertThat(map.size()).isEqualTo(6);
  assertThat(map.get("null")).isEqualTo(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
  assertThat(map.get("number")).isEqualTo(Value.newBuilder().setNumberValue(1.5).build());
  assertThat(map.get("string")).isEqualTo(Value.newBuilder().setStringValue("test").build());
  assertThat(map.get("boolean")).isEqualTo(Value.newBuilder().setBoolValue(true).build());
  assertThat(map.get("struct")).isEqualTo(Value.newBuilder().setStructValue(nestedStruct).build());
  assertThat(map.get("list")).isEqualTo(Value.newBuilder().setListValue(list).build());
}
 

@Test
public void itWritesMixedListValue() throws IOException {
  Value nestedValue = Value.newBuilder().setStringValue("nested").build();
  Struct struct = Struct.newBuilder().putFields("key", nestedValue).build();
  ListValue nestedList = ListValue.newBuilder().addValues(nestedValue).build();
  ListValue list = ListValue
          .newBuilder()
          .addValues(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build())
          .addValues(Value.newBuilder().setNumberValue(1.5d).build())
          .addValues(Value.newBuilder().setStringValue("test").build())
          .addValues(Value.newBuilder().setBoolValue(true).build())
          .addValues(Value.newBuilder().setStructValue(struct).build())
          .addValues(Value.newBuilder().setListValue(nestedList).build())
          .build();
  HasValue message = HasValue
          .newBuilder()
          .setValue(Value.newBuilder().setListValue(list).build())
          .build();
  String json = camelCase().writeValueAsString(message);
  assertThat(json).isEqualTo("{\"value\":[null,1.5,\"test\",true,{\"key\":\"nested\"},[\"nested\"]]}");
}
 

@Test
public void itReadsListValue() throws IOException {
  String json = "{\"value\":[\"test\"]}";
  HasValue valueWrapper = camelCase().readValue(json, HasValue.class);
  assertThat(valueWrapper.hasValue()).isTrue();

  Value value = valueWrapper.getValue();
  ListValue list = ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("test").build()).build();
  switch (value.getKindCase()) {
    case LIST_VALUE:
      assertThat(value.getListValue()).isEqualTo(list);
      break;
    default:
      fail("Unexpected value kind: " + value.getKindCase());
  }
}
 

@Test
public void itReadsMixedStruct() throws IOException {
  String json = "{\"value\":{\"null\":null,\"number\":1.5,\"string\":\"test\",\"boolean\":true,\"struct\":{\"key\":\"nested\"},\"list\":[\"nested\"]}}";
  HasValue message = camelCase().readValue(json, HasValue.class);
  assertThat(message.hasValue()).isTrue();
  Value value = message.getValue();
  switch (value.getKindCase()) {
    case STRUCT_VALUE:
      Map<String, Value> map = value.getStructValue().getFieldsMap();
      Value nested = Value.newBuilder().setStringValue("nested").build();
      Struct nestedStruct = Struct.newBuilder().putFields("key", nested).build();
      ListValue list = ListValue.newBuilder().addValues(nested).build();
      assertThat(map.size()).isEqualTo(6);
      assertThat(map.get("null")).isEqualTo(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
      assertThat(map.get("number")).isEqualTo(Value.newBuilder().setNumberValue(1.5).build());
      assertThat(map.get("string")).isEqualTo(Value.newBuilder().setStringValue("test").build());
      assertThat(map.get("boolean")).isEqualTo(Value.newBuilder().setBoolValue(true).build());
      assertThat(map.get("struct")).isEqualTo(Value.newBuilder().setStructValue(nestedStruct).build());
      assertThat(map.get("list")).isEqualTo(Value.newBuilder().setListValue(list).build());
      break;
    default:
      fail("Unexpected value kind: " + value.getKindCase());
  }
}
 

@Test
public void itReadsMixedListValue() throws IOException {
  String json = "{\"value\":[null,1.5,\"test\",true,{\"key\":\"nested\"},[\"nested\"]]}";
  HasValue message = camelCase().readValue(json, HasValue.class);
  assertThat(message.hasValue()).isTrue();
  Value value = message.getValue();
  switch (value.getKindCase()) {
    case LIST_VALUE:
      ListValue list = value.getListValue();
      Value nested = Value.newBuilder().setStringValue("nested").build();
      Struct struct = Struct.newBuilder().putFields("key", nested).build();
      ListValue nestedList = ListValue.newBuilder().addValues(nested).build();
      assertThat(list.getValuesCount()).isEqualTo(6);
      assertThat(list.getValues(0)).isEqualTo(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
      assertThat(list.getValues(1)).isEqualTo(Value.newBuilder().setNumberValue(1.5).build());
      assertThat(list.getValues(2)).isEqualTo(Value.newBuilder().setStringValue("test").build());
      assertThat(list.getValues(3)).isEqualTo(Value.newBuilder().setBoolValue(true).build());
      assertThat(list.getValues(4)).isEqualTo(Value.newBuilder().setStructValue(struct).build());
      assertThat(list.getValues(5)).isEqualTo(Value.newBuilder().setListValue(nestedList).build());
      break;
    default:
      fail("Unexpected value kind: " + value.getKindCase());
  }
}
 

@Test
public void itReadsNestedListValues() throws IOException {
  String json = "{\"listValue\":[[\"nested\"]]}";
  HasListValue message = camelCase().readValue(json, HasListValue.class);
  assertThat(message.hasListValue()).isTrue();
  assertThat(message.getListValue().getValuesList()).hasSize(1);
  Value value = message.getListValue().getValues(0);
  ListValue list = ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("nested")).build();
  switch (value.getKindCase()) {
    case LIST_VALUE:
      assertThat(value.getListValue()).isEqualToComparingFieldByField(list);
      break;
    default:
      fail("Unexpected value kind: " + value.getKindCase());
  }
}
 

@Test
public void itReadsMixedTypeValues() throws IOException {
  String json = "{\"listValue\":[null,1.5,\"test\",true,{\"key\":\"value\"},[\"nested\"]]}";
  HasListValue message = camelCase().readValue(json, HasListValue.class);
  Struct struct = Struct.newBuilder().putFields("key", Value.newBuilder().setStringValue("value").build()).build();
  ListValue list = ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("nested")).build();
  ListValue expected = ListValue
          .newBuilder()
          .addValues(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build())
          .addValues(Value.newBuilder().setNumberValue(1.5d).build())
          .addValues(Value.newBuilder().setStringValue("test").build())
          .addValues(Value.newBuilder().setBoolValue(true).build())
          .addValues(Value.newBuilder().setStructValue(struct).build())
          .addValues(Value.newBuilder().setListValue(list).build())
          .build();
  assertThat(message.hasListValue()).isTrue();
  assertThat(message.getListValue()).isEqualTo(expected);
}
 

@Override
Value doEncode(A[] value) {
  Builder builder = ListValue.newBuilder();
  for (A val : value) {
    builder.addValues(this.codecs.encode(val));
  }
  return Value.newBuilder().setListValue(builder.build()).build();
}
 

static Object decodeValue(Type fieldType, com.google.protobuf.Value proto) {
  if (proto.getKindCase() == KindCase.NULL_VALUE) {
    return null;
  }
  switch (fieldType.getCode()) {
    case BOOL:
      checkType(fieldType, proto, KindCase.BOOL_VALUE);
      return parseBoolean(proto);
    case INT64:
      checkType(fieldType, proto, KindCase.STRING_VALUE);
      return parseLong(proto);
    case FLOAT64:
      return valueProtoToFloat64(proto);
    case STRING:
      checkType(fieldType, proto, KindCase.STRING_VALUE);
      return proto.getStringValue();
    case BYTES:
      checkType(fieldType, proto, KindCase.STRING_VALUE);
      return parseBytes(proto);
    case TIMESTAMP:
      checkType(fieldType, proto, KindCase.STRING_VALUE);
      return parseTimestamp(proto);
    case DATE:
      checkType(fieldType, proto, KindCase.STRING_VALUE);
      return parseDate(proto);
    case ARRAY:
      checkType(fieldType, proto, KindCase.LIST_VALUE);
      ListValue listValue = proto.getListValue();
      return decodeArrayValue(fieldType.getArrayElementType(), listValue);
    default:
      throw new AssertionError("Unhandled type code: " + fieldType.getCode());
  }
}
 

private static Object decodeArrayValue(Type elementType, ListValue listValue) {
  switch (elementType.getCode()) {
    case BOOL:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseBoolean)
          .toArray(Boolean[]::new);
    case INT64:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseLong)
          .toArray(Long[]::new);
    case FLOAT64:
      return listValue.getValuesList().stream()
          .map(ValueUtils::valueProtoToFloat64)
          .toArray(Double[]::new);
    case STRING:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseString)
          .toArray(String[]::new);
    case BYTES:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseBytes)
          .toArray(ByteBuffer[]::new);
    case TIMESTAMP:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseTimestamp)
          .toArray(LocalDateTime[]::new);
    case DATE:
      return listValue.getValuesList().stream()
          .map(ValueUtils::parseDate)
          .toArray(LocalDate[]::new);

    default:
      throw new AssertionError("Unhandled type code: " + elementType.getCode());
  }
}
 

private void emitCompleteFirstValue(PartialResultSet partialResultSet, List<SpannerRow> rows) {
  Value val = this.prevIsChunk ? this.incompletePieceKind == KindCase.STRING_VALUE
      ? Value.newBuilder().setStringValue((String) this.incompletePiece)
      .build()
      : Value.newBuilder()
          .setListValue(
              ListValue.newBuilder()
                  .addAllValues((List<Value>) this.incompletePiece))
          .build()
      : partialResultSet.getValues(0);
  appendToRow(val, rows);
  this.prevIsChunk = false;
}
 

/**
 * Used to merge List-column value chunks. From Client lib.
 */
private void concatLists(List<com.google.protobuf.Value> a, List<com.google.protobuf.Value> b) {
  if (a.size() == 0 || b.size() == 0) {
    a.addAll(b);
  } else {
    com.google.protobuf.Value last = a.get(a.size() - 1);
    com.google.protobuf.Value first = b.get(0);
    KindCase lastKind = last.getKindCase();
    KindCase firstKind = first.getKindCase();
    if (isMergeable(lastKind) && lastKind == firstKind) {
      com.google.protobuf.Value merged = null;
      if (lastKind == KindCase.STRING_VALUE) {
        String lastStr = last.getStringValue();
        String firstStr = first.getStringValue();
        merged =
            com.google.protobuf.Value.newBuilder().setStringValue(lastStr + firstStr).build();
      } else { // List
        List<Value> mergedList = new ArrayList<>(last.getListValue().getValuesList());
        concatLists(mergedList, first.getListValue().getValuesList());
        merged =
            com.google.protobuf.Value.newBuilder()
                .setListValue(ListValue.newBuilder().addAllValues(mergedList))
                .build();
      }
      a.set(a.size() - 1, merged);
      a.addAll(b.subList(1, b.size()));
    } else {
      a.addAll(b);
    }
  }
}
 

@Override
public void onNext(T value) {
  List<Value> path =
      dataFetchingEnvironment
          .getExecutionStepInfo()
          .getPath()
          .toList()
          .stream()
          .map(
              p ->
                  p instanceof Number
                      ? Value.newBuilder()
                          .setNumberValue(Double.parseDouble(p.toString()))
                          .build()
                      : Value.newBuilder().setStringValue(p.toString()).build())
          .collect(ImmutableList.toImmutableList());

  ListValue pathListVale =
      ListValue.newBuilder()
          .addAllValues(path)
          .addValues(Value.newBuilder().setNumberValue(pathIndex.incrementAndGet()))
          .build();

  R graphQlResponse = getData(value, pathListVale);

  rejoinerStreamingContext.responseStreamObserver().onNext(graphQlResponse);

  try {
    System.out.println(
        "Streaming response as Json: " + JsonFormat.printer().print(graphQlResponse));
  } catch (InvalidProtocolBufferException e) {
    throw new RuntimeException(e);
  }
}
 

private static ImmutableList<Object> toList(ListValue listValue) {
  return listValue
      .getValuesList()
      .stream()
      .map(
          value ->
              Value.KindCase.STRUCT_VALUE.equals(value.getKindCase())
                  ? toMap(value.getStructValue())
                  : getScalarValue(value))
      .collect(ImmutableList.toImmutableList());
}
 

@Override
public void doMerge(JsonParser parser, int currentDepth, Message.Builder messageBuilder)
    throws IOException {
  JsonToken token = parser.currentToken();
  if (token != JsonToken.START_ARRAY) {
    throw new InvalidProtocolBufferException("Expect an array but found: " + parser.getText());
  }
  ListValue.Builder builder = (ListValue.Builder) messageBuilder;
  while (parser.nextValue() != JsonToken.END_ARRAY) {
    Value.Builder valueBuilder = builder.addValuesBuilder();
    ValueMarshaller.INSTANCE.mergeValue(parser, currentDepth + 1, valueBuilder);
  }
}
 

@Override
public void doWrite(ListValue message, JsonGenerator gen) throws IOException {
  List<Value> values = message.getValuesList();
  int numElements = values.size();
  gen.writeStartArray(numElements);
  for (int i = 0; i < numElements; i++) {
    ValueMarshaller.INSTANCE.writeValue(values.get(i), gen);
  }
  gen.writeEndArray();
}
 

@Test
public void struct() throws Exception {
  // Build a struct with all possible values.
  TestStruct.Builder builder = TestStruct.newBuilder();
  Struct.Builder structBuilder = builder.getStructValueBuilder();
  structBuilder.putFields("null_value", Value.newBuilder().setNullValueValue(0).build());
  structBuilder.putFields("number_value", Value.newBuilder().setNumberValue(1.25).build());
  structBuilder.putFields("string_value", Value.newBuilder().setStringValue("hello").build());
  Struct.Builder subStructBuilder = Struct.newBuilder();
  subStructBuilder.putFields("number_value", Value.newBuilder().setNumberValue(1234).build());
  structBuilder.putFields(
      "struct_value", Value.newBuilder().setStructValue(subStructBuilder.build()).build());
  ListValue.Builder listBuilder = ListValue.newBuilder();
  listBuilder.addValues(Value.newBuilder().setNumberValue(1.125).build());
  listBuilder.addValues(Value.newBuilder().setNullValueValue(0).build());
  structBuilder.putFields(
      "list_value", Value.newBuilder().setListValue(listBuilder.build()).build());
  TestStruct message = builder.build();
  assertMatchesUpstream(message);

  builder = TestStruct.newBuilder();
  builder.setValue(Value.newBuilder().setNullValueValue(0).build());
  message = builder.build();
  assertMatchesUpstream(message);

  builder = TestStruct.newBuilder();
  listBuilder = builder.getListValueBuilder();
  listBuilder.addValues(Value.newBuilder().setNumberValue(31831.125).build());
  listBuilder.addValues(Value.newBuilder().setNullValueValue(0).build());
  message = builder.build();
  assertMatchesUpstream(message);
}
 

/**
 * Creates additional types (Value, Struct and ListValue) to be added to the Service config.
 * TODO (guptasu): Fix this hack. Find a better way to add the predefined types.
 * TODO (guptasu): Add them only when required and not in all cases.
 */

static Iterable<Type> createAdditionalServiceTypes() {
  Map<String, DescriptorProto> additionalMessages = Maps.newHashMap();
  additionalMessages.put(Struct.getDescriptor().getFullName(),
      Struct.getDescriptor().toProto());
  additionalMessages.put(Value.getDescriptor().getFullName(),
      Value.getDescriptor().toProto());
  additionalMessages.put(ListValue.getDescriptor().getFullName(),
      ListValue.getDescriptor().toProto());
  additionalMessages.put(Empty.getDescriptor().getFullName(),
      Empty.getDescriptor().toProto());
  additionalMessages.put(Int32Value.getDescriptor().getFullName(),
      Int32Value.getDescriptor().toProto());
  additionalMessages.put(DoubleValue.getDescriptor().getFullName(),
      DoubleValue.getDescriptor().toProto());
  additionalMessages.put(BoolValue.getDescriptor().getFullName(),
      BoolValue.getDescriptor().toProto());
  additionalMessages.put(StringValue.getDescriptor().getFullName(),
      StringValue.getDescriptor().toProto());

  for (Descriptor descriptor : Struct.getDescriptor().getNestedTypes()) {
    additionalMessages.put(descriptor.getFullName(), descriptor.toProto());
  }

  // TODO (guptasu): Remove this hard coding. Without this, creation of Model from Service throws.
  // Needs investigation.
  String fileName = "struct.proto";
  List<Type> additionalTypes = Lists.newArrayList();
  for (String typeName : additionalMessages.keySet()) {
    additionalTypes.add(TypesBuilderFromDescriptor.createType(typeName,
        additionalMessages.get(typeName), fileName));
  }
  return additionalTypes;
}
 

@VisibleForTesting
static Map<String, ListValue> getInfo(VariantContext vc, VCFHeader header) {
  Map<String, ListValue> toReturn = new HashMap<>();

  for (Map.Entry<String, Object> entry : vc.getAttributes().entrySet()) {
    String currKey = entry.getKey();
    VCFInfoHeaderLine metaData = header.getInfoHeaderLine(currKey);

    // All info fields must have a corresponding header field.
    if (metaData == null) {
      logger.log(Level.WARNING, String.format("Could not find matching VCF header field, "
          + "skipping info field %s", currKey));
      continue;
    }

    Object currObject = entry.getValue();
    ListValue.Builder listValueBuilder = ListValue.newBuilder();

    VCFHeaderLineType type = metaData.getType();
    if (!(currObject instanceof List)) {
      toReturn.put(currKey,
          listValueBuilder.addValues(createTypedValue(type, currObject)).build());
      continue;
    }

    List<Object> currObjectList = (List<Object>) currObject;
    for (Object currObj : currObjectList) {
      listValueBuilder.addValues(createTypedValue(type, currObj));
    }
    toReturn.put(currKey, listValueBuilder.build());
  }

  return toReturn;
}
 

private static ListValue listFromObject(Object obj) {
  ListValue.Builder lvBuilder = ListValue.newBuilder();
  if (!(obj instanceof List)) {
    lvBuilder.addValues(valueFromObject(obj));
  } else {
    List<Object> objList = (List<Object>) obj;

    for (int i = 0; i < objList.size(); i++) {
      lvBuilder.addValues(valueFromObject(objList.get(i)));
    }
  }

  return lvBuilder.build();
}
 

@Test
public void testGetInfo() throws Exception {
  File vcfFile =
      new File(VcfToVariant.class.getClassLoader().getResource(VALID_VCF_4_1).getFile());
  VCFFileReader vcfReader = new VCFFileReader(vcfFile, false);
  VCFHeader vcfHeader = vcfReader.getFileHeader();
  int currVariant = 0;

  for (final VariantContext vc : vcfReader) {
    Map<String, ListValue> info = VcfToVariant.getInfo(vc, vcfHeader);
    assertEquals(info, TRUTH.get(currVariant).getInfo());
    currVariant++;
  }
}
 

/**
 * Converts Java representation of the given JSON value to protobuf's {@link
 * com.google.protobuf.Value} representation.
 *
 * <p>The given {@code rawObject} must be a valid JSON value in Java representation, which is
 * either a {@code Map<String, ?>}, {@code List<?>}, {@code String}, {@code Double},
 * {@code Boolean}, or {@code null}.
 */
private static Value convertToValue(Object rawObject) {
  Value.Builder valueBuilder = Value.newBuilder();
  if (rawObject == null) {
    valueBuilder.setNullValue(NullValue.NULL_VALUE);
  } else if (rawObject instanceof Double) {
    valueBuilder.setNumberValue((Double) rawObject);
  } else if (rawObject instanceof String) {
    valueBuilder.setStringValue((String) rawObject);
  } else if (rawObject instanceof Boolean) {
    valueBuilder.setBoolValue((Boolean) rawObject);
  } else if (rawObject instanceof Map) {
    Struct.Builder structBuilder = Struct.newBuilder();
    @SuppressWarnings("unchecked")
    Map<String, ?> map = (Map<String, ?>) rawObject;
    for (Map.Entry<String, ?> entry : map.entrySet()) {
      structBuilder.putFields(entry.getKey(), convertToValue(entry.getValue()));
    }
    valueBuilder.setStructValue(structBuilder);
  } else if (rawObject instanceof List) {
    ListValue.Builder listBuilder = ListValue.newBuilder();
    List<?> list = (List<?>) rawObject;
    for (Object obj : list) {
      listBuilder.addValues(convertToValue(obj));
    }
    valueBuilder.setListValue(listBuilder);
  }
  return valueBuilder.build();
}