CODEWITHSUNDEEP
javaprotocol-buffers
mindas
mindas

Reputation: 26713

Copy fields across objects of different type in gRPC

Suppose I have two proto buffer types:

message MessageType1 {
  SomeType1 field1 = 1;
  SomeType2 field2 = 2;
  SomeType3 field3 = 3;
}

message MessageType2 {
  SomeType1 field1 = 1;
  SomeType2 field2 = 2;
  SomeType4 field4 = 3;
}

Then in Java I would like to be able to use one object as a template to another:

MessageType1 message1 = ...;
MessageType2 message2 = MessageType2.newBuilder()
    .usingTemplate(message1)  // sets field1 & field2 only
    .setField4(someValue)
    .build()

instead of

MessageType1 message1 = ...;
MessageType2 message2 = MessageType2.newBuilder()
    .setField1(message1.getField1())
    .setField2(message1.getField2())
    .setField4(someValue)
    .build()

Why do I need this? My gRPC service is designed to take incoming data of one type (message1) which is almost identical to another message of a different type (message2) -- which needs to be sent out. The amount of identical fields is huge and copy code is mundane. Manual solution also has a disadvantage of a miss if a new field gets added.

There exists a template method (object.newBuilder(template)) which allows templating object of the same type, but how about templating between different types?

I could, of course, write a small reflection utility which inspects all members (methods?) and manually copies data over, but generated code looks discouraging and ugly for this sort of quest.

Is there any good approach to tackle this?

Upvotes: 1

Views: 2204

Answers (2)

mindas
mindas

Reputation: 26713

It turned out to be not so complicated. I wrote a small utility which would evaluate and match FieldDescriptors (something that gRPC generates). In my world it is enough to match them by name and type. Full solution here:

/**
 * Copies fields from source to dest. Only copies fields if they are set, have matching name and type as their counterparts in dest.
 */
public static void copyCommonFields(@Nonnull GeneratedMessageV3 source, @Nonnull com.google.protobuf.GeneratedMessageV3.Builder<?> destBuilder) {
    Map<FieldDescriptorKeyElements, Descriptors.FieldDescriptor> elementsInSource = Maps.uniqueIndex(source.getDescriptorForType().getFields(), FieldDescriptorKeyElements::new);
    Map<FieldDescriptorKeyElements, Descriptors.FieldDescriptor> elementsInDest = Maps.uniqueIndex(destBuilder.getDescriptorForType().getFields(), FieldDescriptorKeyElements::new);
    // those two above could even be cached if necessary as this is static info

    Set<FieldDescriptorKeyElements> elementsInBoth = Sets.intersection(elementsInSource.keySet(), elementsInDest.keySet());

    for (Map.Entry<Descriptors.FieldDescriptor, Object> entry : source.getAllFields().entrySet()) {
        Descriptors.FieldDescriptor descriptor = entry.getKey();
        FieldDescriptorKeyElements keyElements = new FieldDescriptorKeyElements(descriptor);
        if (entry.getValue() != null && elementsInBoth.contains(keyElements)) {
            destBuilder.setField(elementsInDest.get(keyElements), entry.getValue());
        }
    }
}

// used for convenient/quick lookups in a Set
private static final class FieldDescriptorKeyElements {
    final String fieldName;
    final Descriptors.FieldDescriptor.JavaType javaType;
    final boolean isRepeated;

    private FieldDescriptorKeyElements(Descriptors.FieldDescriptor fieldDescriptor) {
        this.fieldName = fieldDescriptor.getName();
        this.javaType = fieldDescriptor.getJavaType();
        this.isRepeated = fieldDescriptor.isRepeated();
    }

    @Override
    public int hashCode() {
        return Objects.hash(fieldName, javaType, isRepeated);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null || !(obj instanceof FieldDescriptorKeyElements)) {
            return false;
        }
        FieldDescriptorKeyElements other = (FieldDescriptorKeyElements) obj;
        return Objects.equals(this.fieldName, other.fieldName) &&
                Objects.equals(this.javaType, other.javaType) &&
                Objects.equals(this.isRepeated, other.isRepeated);
    }
}

Upvotes: 3

Carl Mastrangelo
Carl Mastrangelo

Reputation: 6628

Answering your specific question: no, there is no template based way to do this. However, there are some other ways to get the same effect:

  • If you don't care about performance and the field numbers are the same between the messages, you can serialize the first message to bytes and deserialize them back as the new message. This requires that all the fields in the first message must match the type and id number of those in the second message (though, the second message can have other fields). This is probably not a good idea.

  • Extract the common fields to another message, and share that message. For example:

proto: 

message Common {
  SomeType1 field1 = 1;
  SomeType2 field2 = 2;
  SomeType3 field3 = 3;
} 

message MessageType1 {
  Common common = 1;
  // ...
}

message MessageType2 {
  Common common = 1;
  // ...
}

Then, you can share the messages in code:

MessageType1 message1 = ...;
MessageType2 message2 = MessageType2.newBuilder()
    .setCommon(message1.getCommon())
    .build();

This is the probably the better solution.

  • Lastly, as you mentioned, you could resort to reflection. This is probably the most verbose and slowest way, but it would allow you the most control (aside from manually copying over the fields). Not recommended.

Upvotes: 1

Related Questions