/**
* Converts a tupleField string to its corresponding protobuf enum type if necessary, otherwise
* returns the tupleField as is.
*
* @param fieldDescriptor the FieldDescriptor for the given tuple field
* @param tupleField the tupleField being converted to a protobuf field
* @return the protobuf type for the given tupleField. This will be the tupleField itself unless
* it's an enum, in which case this will return the enum type for the field.
*/
public Object tupleFieldToSingleField(FieldDescriptor fieldDescriptor, Object tupleField) {
if (fieldDescriptor.getType() == FieldDescriptor.Type.ENUM) {
// Convert tupleField to the enum value.
return fieldDescriptor.getEnumType().findValueByName((String) tupleField);
} else {
return tupleField;
}
}
/** Verifies that the value is EnumValueDescriptor and matchs Enum Type. */
private void verifyEnumType(FieldDescriptor field, Object value) {
if (value == null) {
throw new NullPointerException();
}
if (!(value instanceof EnumValueDescriptor)) {
throw new IllegalArgumentException(
"DynamicMessage should use EnumValueDescriptor to set Enum Value.");
}
if (field.getEnumType() != ((EnumValueDescriptor) value).getType()) {
throw new IllegalArgumentException("EnumValueDescriptor doesn't much Enum Field.");
}
}
private static Object readSingleFieldNoTag(
CodedInputStream input, FieldDescriptor fd, Builder enclosingBuilder) throws IOException {
switch (fd.getType()) {
case DOUBLE:
return input.readDouble();
case FLOAT:
return input.readFloat();
case INT64:
case UINT64:
return input.readInt64();
case INT32:
return input.readInt32();
case FIXED64:
return input.readFixed64();
case FIXED32:
return input.readFixed32();
case BOOL:
return input.readBool();
case STRING:
return input.readString();
case GROUP:
case MESSAGE:
Builder fieldBuilder = enclosingBuilder.newBuilderForField(fd);
input.readMessage(fieldBuilder, null);
return fieldBuilder.build();
case BYTES:
return input.readBytes();
case UINT32:
return input.readUInt32();
case ENUM:
EnumValueDescriptor eVal = fd.getEnumType().findValueByNumber(input.readEnum());
// ideally if a given enum does not exist, we should search
// unknown fields. but we don't have access to that here. return default
return eVal != null ? eVal : fd.getDefaultValue();
case SFIXED32:
return input.readSFixed32();
case SFIXED64:
return input.readSFixed64();
case SINT32:
return input.readSInt32();
case SINT64:
return input.readSInt64();
default:
throw new IllegalArgumentException(
"Unknown type " + fd.getType() + " for " + fd.getFullName());
}
}
private static Object toJavaObj(
final Builder builder, final FieldDescriptor fieldDesc, final JsonNode node) {
Object value;
switch (fieldDesc.getJavaType()) {
case MESSAGE:
final Builder subBuilder = builder.newBuilderForField(fieldDesc);
value = toProto(subBuilder, node).build();
break;
case BOOLEAN:
value = Boolean.valueOf(node.getBooleanValue());
break;
case BYTE_STRING:
try {
value = node.getBinaryValue();
} catch (IOException e) {
throw new RuntimeException(e);
}
break;
case DOUBLE:
value = Double.valueOf(node.getDoubleValue());
break;
case FLOAT:
value = Float.valueOf(Double.valueOf(node.getDoubleValue()).floatValue());
break;
case ENUM:
value = fieldDesc.getEnumType().findValueByName(node.getTextValue());
break;
case INT:
value = Integer.valueOf(node.getIntValue());
break;
case LONG:
value = Long.valueOf(node.getLongValue());
break;
case STRING:
value = node.getTextValue();
break;
default:
throw new IllegalArgumentException();
}
return value;
}
/**
* Like {@link #mergeFrom(CodedInputStream, ExtensionRegistryLite)}, but parses a single field.
*
* <p>When {@code builder} is not null, the method will parse and merge the field into {@code
* builder}. Otherwise, it will try to parse the field into {@code extensions}, when it's called
* by the parsing constructor in generated classes.
*
* <p>Package-private because it is used by GeneratedMessage.ExtendableMessage.
*
* @param tag The tag, which should have already been read.
* @return {@code true} unless the tag is an end-group tag.
*/
static boolean mergeFieldFrom(
CodedInputStream input,
UnknownFieldSet.Builder unknownFields,
ExtensionRegistryLite extensionRegistry,
Descriptor type,
Message.Builder builder,
FieldSet<FieldDescriptor> extensions,
int tag)
throws IOException {
if (type.getOptions().getMessageSetWireFormat() && tag == WireFormat.MESSAGE_SET_ITEM_TAG) {
mergeMessageSetExtensionFromCodedStream(
input, unknownFields, extensionRegistry, type, builder, extensions);
return true;
}
final int wireType = WireFormat.getTagWireType(tag);
final int fieldNumber = WireFormat.getTagFieldNumber(tag);
final FieldDescriptor field;
Message defaultInstance = null;
if (type.isExtensionNumber(fieldNumber)) {
// extensionRegistry may be either ExtensionRegistry or
// ExtensionRegistryLite. Since the type we are parsing is a full
// message, only a full ExtensionRegistry could possibly contain
// extensions of it. Otherwise we will treat the registry as if it
// were empty.
if (extensionRegistry instanceof ExtensionRegistry) {
final ExtensionRegistry.ExtensionInfo extension =
((ExtensionRegistry) extensionRegistry).findExtensionByNumber(type, fieldNumber);
if (extension == null) {
field = null;
} else {
field = extension.descriptor;
defaultInstance = extension.defaultInstance;
if (defaultInstance == null
&& field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
throw new IllegalStateException(
"Message-typed extension lacked default instance: " + field.getFullName());
}
}
} else {
field = null;
}
} else if (builder != null) {
field = type.findFieldByNumber(fieldNumber);
} else {
field = null;
}
boolean unknown = false;
boolean packed = false;
if (field == null) {
unknown = true; // Unknown field.
} else if (wireType
== FieldSet.getWireFormatForFieldType(field.getLiteType(), false /* isPacked */)) {
packed = false;
} else if (field.isPackable()
&& wireType
== FieldSet.getWireFormatForFieldType(field.getLiteType(), true /* isPacked */)) {
packed = true;
} else {
unknown = true; // Unknown wire type.
}
if (unknown) { // Unknown field or wrong wire type. Skip.
return unknownFields.mergeFieldFrom(tag, input);
}
if (packed) {
final int length = input.readRawVarint32();
final int limit = input.pushLimit(length);
if (field.getLiteType() == WireFormat.FieldType.ENUM) {
while (input.getBytesUntilLimit() > 0) {
final int rawValue = input.readEnum();
final Object value = field.getEnumType().findValueByNumber(rawValue);
if (value == null) {
// If the number isn't recognized as a valid value for this
// enum, drop it (don't even add it to unknownFields).
return true;
}
addRepeatedField(builder, extensions, field, value);
}
} else {
while (input.getBytesUntilLimit() > 0) {
final Object value = FieldSet.readPrimitiveField(input, field.getLiteType());
addRepeatedField(builder, extensions, field, value);
}
}
input.popLimit(limit);
} else {
final Object value;
switch (field.getType()) {
case GROUP:
{
final Message.Builder subBuilder;
if (defaultInstance != null) {
subBuilder = defaultInstance.newBuilderForType();
} else {
subBuilder = builder.newBuilderForField(field);
}
if (!field.isRepeated()) {
mergeOriginalMessage(builder, extensions, field, subBuilder);
}
input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
value = subBuilder.buildPartial();
break;
}
case MESSAGE:
{
final Message.Builder subBuilder;
if (defaultInstance != null) {
subBuilder = defaultInstance.newBuilderForType();
} else {
subBuilder = builder.newBuilderForField(field);
}
if (!field.isRepeated()) {
mergeOriginalMessage(builder, extensions, field, subBuilder);
}
input.readMessage(subBuilder, extensionRegistry);
value = subBuilder.buildPartial();
break;
}
case ENUM:
final int rawValue = input.readEnum();
value = field.getEnumType().findValueByNumber(rawValue);
// If the number isn't recognized as a valid value for this enum,
// drop it.
if (value == null) {
unknownFields.mergeVarintField(fieldNumber, rawValue);
return true;
}
break;
default:
value = FieldSet.readPrimitiveField(input, field.getLiteType());
break;
}
if (field.isRepeated()) {
addRepeatedField(builder, extensions, field, value);
} else {
setField(builder, extensions, field, value);
}
}
return true;
}
/**
* Like {@link #mergeFrom(CodedInputStream, UnknownFieldSet.Builder, ExtensionRegistryLite,
* Message.Builder)}, but parses a single field. Package-private because it is used by
* GeneratedMessage.ExtendableMessage.
*
* @param tag The tag, which should have already been read.
* @return {@code true} unless the tag is an end-group tag.
*/
@SuppressWarnings("unchecked")
static boolean mergeFieldFrom(
final CodedInputStream input,
final UnknownFieldSet.Builder unknownFields,
final ExtensionRegistryLite extensionRegistry,
final Message.Builder builder,
final int tag)
throws IOException {
final Descriptor type = builder.getDescriptorForType();
if (type.getOptions().getMessageSetWireFormat() && tag == WireFormat.MESSAGE_SET_ITEM_TAG) {
mergeMessageSetExtensionFromCodedStream(input, unknownFields, extensionRegistry, builder);
return true;
}
final int wireType = WireFormat.getTagWireType(tag);
final int fieldNumber = WireFormat.getTagFieldNumber(tag);
final FieldDescriptor field;
Message defaultInstance = null;
if (type.isExtensionNumber(fieldNumber)) {
// extensionRegistry may be either ExtensionRegistry or
// ExtensionRegistryLite. Since the type we are parsing is a full
// message, only a full ExtensionRegistry could possibly contain
// extensions of it. Otherwise we will treat the registry as if it
// were empty.
if (extensionRegistry instanceof ExtensionRegistry) {
final ExtensionRegistry.ExtensionInfo extension =
((ExtensionRegistry) extensionRegistry).findExtensionByNumber(type, fieldNumber);
if (extension == null) {
field = null;
} else {
field = extension.descriptor;
defaultInstance = extension.defaultInstance;
}
} else {
field = null;
}
} else {
field = type.findFieldByNumber(fieldNumber);
}
if (field == null
|| wireType
!= FieldSet.getWireFormatForFieldType(
field.getLiteType(), field.getOptions().getPacked())) {
// Unknown field or wrong wire type. Skip.
return unknownFields.mergeFieldFrom(tag, input);
}
if (field.getOptions().getPacked()) {
final int length = input.readRawVarint32();
final int limit = input.pushLimit(length);
if (field.getLiteType() == WireFormat.FieldType.ENUM) {
while (input.getBytesUntilLimit() > 0) {
final int rawValue = input.readEnum();
final Object value = field.getEnumType().findValueByNumber(rawValue);
if (value == null) {
// If the number isn't recognized as a valid value for this
// enum, drop it (don't even add it to unknownFields).
return true;
}
builder.addRepeatedField(field, value);
}
} else {
while (input.getBytesUntilLimit() > 0) {
final Object value = FieldSet.readPrimitiveField(input, field.getLiteType());
builder.addRepeatedField(field, value);
}
}
input.popLimit(limit);
} else {
final Object value;
switch (field.getType()) {
case GROUP:
{
final Message.Builder subBuilder;
if (defaultInstance != null) {
subBuilder = defaultInstance.newBuilderForType();
} else {
subBuilder = builder.newBuilderForField(field);
}
if (!field.isRepeated()) {
subBuilder.mergeFrom((Message) builder.getField(field));
}
input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
value = subBuilder.build();
break;
}
case MESSAGE:
{
final Message.Builder subBuilder;
if (defaultInstance != null) {
subBuilder = defaultInstance.newBuilderForType();
} else {
subBuilder = builder.newBuilderForField(field);
}
if (!field.isRepeated()) {
subBuilder.mergeFrom((Message) builder.getField(field));
}
input.readMessage(subBuilder, extensionRegistry);
value = subBuilder.build();
break;
}
case ENUM:
final int rawValue = input.readEnum();
value = field.getEnumType().findValueByNumber(rawValue);
// If the number isn't recognized as a valid value for this enum,
// drop it.
if (value == null) {
unknownFields.mergeVarintField(fieldNumber, rawValue);
return true;
}
break;
default:
value = FieldSet.readPrimitiveField(input, field.getLiteType());
break;
}
if (field.isRepeated()) {
builder.addRepeatedField(field, value);
} else {
builder.setField(field, value);
}
}
return true;
}
