Java Code Examples for com.google.protobuf.UnknownFieldSet#Field

public static UnknownFieldSet getEmployeeUnknownFields() {
  // add unknown fields
  UnknownFieldSet.Field unknownStringField = UnknownFieldSet.Field.newBuilder()
    .addLengthDelimited(ByteString.copyFromUtf8("Hello San FRancisco!"))
    .build();
  UnknownFieldSet.Field unknownVarIntField = UnknownFieldSet.Field.newBuilder()
    .addVarint(123456789)
    .build();

  UnknownFieldSet employeeUnknownFields = UnknownFieldSet.newBuilder()
    .addField(345, unknownStringField)
    .addField(456, unknownVarIntField)
    .build();

  return employeeUnknownFields;
}
 

private static FieldNumberTree fromUnknownFieldSet(UnknownFieldSet unknownFieldSet) {
  FieldNumberTree tree = new FieldNumberTree();
  for (int fieldNumber : unknownFieldSet.asMap().keySet()) {
    UnknownFieldSet.Field unknownField = unknownFieldSet.asMap().get(fieldNumber);
    for (UnknownFieldDescriptor unknownFieldDescriptor :
        UnknownFieldDescriptor.descriptors(fieldNumber, unknownField)) {
      Key key = Key.unknown(unknownFieldDescriptor);
      FieldNumberTree childTree = new FieldNumberTree();
      tree.children.put(key, childTree);

      if (unknownFieldDescriptor.type() == UnknownFieldDescriptor.Type.GROUP) {
        for (Object group : unknownFieldDescriptor.type().getValues(unknownField)) {
          childTree.merge(fromUnknownFieldSet((UnknownFieldSet) group));
        }
      }
    }
  }

  return tree;
}
 

private Object convertUnknownFieldValue(
    Descriptors.FieldDescriptor fieldDescriptor, UnknownFieldSet.Field field) {

  if (field.getLengthDelimitedList().size() > 0) {
    if (field.getLengthDelimitedList().size() > 1) {
      throw new RuntimeException(
          "Single value should not contrain more then 1 value in the unknown field");
    }
    return convertFieldValue(fieldDescriptor, field.getLengthDelimitedList().get(0));
  }
  if (field.getFixed32List().size() > 0) {
    if (field.getFixed32List().size() > 1) {
      throw new RuntimeException(
          "Single value should not contrain more then 1 value in the unknown field");
    }
    return convertFieldValue(fieldDescriptor, field.getFixed32List().get(0));
  }
  if (field.getFixed64List().size() > 0) {
    if (field.getFixed64List().size() > 1) {
      throw new RuntimeException(
          "Single value should not contrain more then 1 value in the unknown field");
    }
    return convertFieldValue(fieldDescriptor, field.getFixed64List().get(0));
  }
  if (field.getVarintList().size() > 0) {
    if (field.getVarintList().size() > 1) {
      throw new RuntimeException(
          "Single value should not contrain more then 1 value in the unknown field");
    }
    return convertFieldValue(fieldDescriptor, field.getVarintList().get(0));
  }
  if (field.getGroupList().size() > 0) {
    throw new RuntimeException("Groups are not implemented");
  }
  return null;
}
 

static ImmutableList<UnknownFieldDescriptor> descriptors(
    int fieldNumber, UnknownFieldSet.Field field) {
  ImmutableList.Builder<UnknownFieldDescriptor> builder = ImmutableList.builder();
  for (Type type : Type.all()) {
    if (!type.getValues(field).isEmpty()) {
      builder.add(create(fieldNumber, type));
    }
  }
  return builder.build();
}
 

public static UnknownFieldSet getPersonUnknownFields() throws IOException {
  // add unknown fields
  UnknownFieldSet.Field unknownIntField = UnknownFieldSet.Field.newBuilder()
    .addFixed32(1234)
    .build();
  UnknownFieldSet.Field unknownLongField = UnknownFieldSet.Field.newBuilder()
    .addFixed64(12345678)
    .build();
  UnknownFieldSet unknownFieldSet = UnknownFieldSet.newBuilder()
    .addField(123, unknownIntField)
    .addField(234, unknownLongField)
    .build();

  return unknownFieldSet;
}
 

@Nonnull
protected DynamicMessage deserializeUnion(@Nonnull final Descriptors.Descriptor unionDescriptor,
                                          @Nonnull final Tuple primaryKey,
                                          @Nonnull final byte[] serialized,
                                          int metaDataVersion) {
    final DynamicMessage unionMessage = deserializeFromBytes(unionDescriptor, serialized);
    final Map<Descriptors.FieldDescriptor, Object> allFields = unionMessage.getAllFields();
    final Map<Integer, UnknownFieldSet.Field> unknownFields = unionMessage.getUnknownFields().asMap();
    if (!(allFields.size() == 1 && unknownFields.isEmpty())) {
        final String detailedMessage;
        if (!unknownFields.isEmpty()) {
            detailedMessage = " because there are unknown fields";
        } else if (allFields.size() > 1) {
            detailedMessage = " because there are extra known fields";
        } else {
            detailedMessage = " because there are no fields";
        }
        final String message = "Could not deserialize union message" + detailedMessage;
        final RecordSerializationException ex = new RecordSerializationException(message)
                .addLogInfo("unknownFields", unknownFields.keySet())
                .addLogInfo("fields", getFieldNames(allFields.keySet()))
                .addLogInfo("primaryKey", primaryKey)
                .addLogInfo("metaDataVersion", metaDataVersion);
        throw ex;
    }
    return unionMessage;
}
 

private ByteString serializeUnknownField(int optionNumber, UnknownFieldSet.Field field) {
  ByteBuffer byteBuffer = ByteBuffer.allocate(field.getSerializedSize(optionNumber));
  CodedOutputStream stream = CodedOutputStream.newInstance(byteBuffer);
  try {
    field.writeTo(optionNumber, stream);
  } catch (IOException e) {
    throw new RuntimeException(
        "failed to serialize unknown field with number " + optionNumber, e);
  }
  return ByteString.copyFrom(byteBuffer);
}
 

/**
 * https://developers.google.com/protocol-buffers/docs/encoding#structure
 *
 * @param fieldDescriptor
 * @param field
 * @return
 */
private Object convertUnknownFieldList(
    Descriptors.FieldDescriptor fieldDescriptor, UnknownFieldSet.Field field) {
  List list = new ArrayList();
  if (field.getLengthDelimitedList().size() > 0) {
    field
        .getLengthDelimitedList()
        .forEach(value -> list.add(convertFieldValue(fieldDescriptor, value)));
  }
  if (field.getFixed32List().size() > 0) {
    field
        .getFixed32List()
        .forEach(value -> list.add(convertFieldValue(fieldDescriptor, value)));
  }
  if (field.getFixed64List().size() > 0) {
    field
        .getFixed64List()
        .forEach(value -> list.add(convertFieldValue(fieldDescriptor, value)));
  }
  if (field.getVarintList().size() > 0) {
    field.getVarintList().forEach(value -> list.add(convertFieldValue(fieldDescriptor, value)));
  }
  if (field.getGroupList().size() > 0) {
    throw new RuntimeException("Groups are not implemented");
  }
  return list;
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getFixed32List();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getFixed64List();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getLengthDelimitedList();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getGroupList();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getVarintList();
}
 

private UnknownFieldSetDiff diffUnknowns(
    UnknownFieldSet actual, UnknownFieldSet expected, FluentEqualityConfig config) {
  UnknownFieldSetDiff.Builder builder = UnknownFieldSetDiff.newBuilder();

  Map<Integer, UnknownFieldSet.Field> actualFields = actual.asMap();
  Map<Integer, UnknownFieldSet.Field> expectedFields = expected.asMap();
  for (int fieldNumber : Sets.union(actualFields.keySet(), expectedFields.keySet())) {
    @NullableDecl UnknownFieldSet.Field actualField = actualFields.get(fieldNumber);
    @NullableDecl UnknownFieldSet.Field expectedField = expectedFields.get(fieldNumber);
    for (UnknownFieldDescriptor.Type type : UnknownFieldDescriptor.Type.all()) {
      List<?> actualValues =
          actualField != null ? type.getValues(actualField) : Collections.emptyList();
      List<?> expectedValues =
          expectedField != null ? type.getValues(expectedField) : Collections.emptyList();
      if (actualValues.isEmpty() && expectedValues.isEmpty()) {
        continue;
      }

      UnknownFieldDescriptor unknownFieldDescriptor =
          UnknownFieldDescriptor.create(fieldNumber, type);
      FieldDescriptorOrUnknown fieldDescriptorOrUnknown =
          FieldDescriptorOrUnknown.fromUnknown(unknownFieldDescriptor);
      FieldScopeResult compareFields =
          config.compareFieldsScope().policyFor(rootDescriptor, fieldDescriptorOrUnknown);
      if (compareFields == FieldScopeResult.EXCLUDED_RECURSIVELY) {
        builder.addSingularField(
            fieldNumber, SingularField.ignored(name(unknownFieldDescriptor)));
        continue;
      }

      builder.addAllSingularFields(
          fieldNumber,
          compareUnknownFieldList(
              actualValues,
              expectedValues,
              compareFields == FieldScopeResult.EXCLUDED_NONRECURSIVELY,
              unknownFieldDescriptor,
              config.subScope(rootDescriptor, fieldDescriptorOrUnknown)));
    }
  }

  return builder.build();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getVarintList();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getFixed32List();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getFixed64List();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getLengthDelimitedList();
}
 

@Override
public List<?> getValues(UnknownFieldSet.Field field) {
  return field.getGroupList();
}
 

/** Returns the corresponding values from the given field. */
abstract List<?> getValues(UnknownFieldSet.Field field);