static Builder getFieldBuilder(Builder b, FieldDescriptor f) {

        try {
            if(  b instanceof MapEntry.Builder ) {
                 MapEntry.Builder bb = (MapEntry.Builder)b;
                 return bb.newBuilderForField(f);
            }

            String fieldName = f.getName();
            String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1) + "Builder";
            Method method = b.getClass().getDeclaredMethod(methodName, dummyTypes);
            Builder builder = (Builder) method.invoke(b, dummyParameters);
            return builder;
        } catch (Exception e) {
            throw new RuntimeException("getFieldBuilder exception", e);
        }
    }
 

static Builder getFieldBuilder(Builder b, Descriptors.FieldDescriptor f) {
    try {
        if(  b instanceof MapEntry.Builder ) {
            MapEntry.Builder bb = (MapEntry.Builder)b;
            return bb.newBuilderForField(f);
        }

        String fieldName = f.getName();
        String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1) + "Builder";
        Method method = b.getClass().getDeclaredMethod(methodName, dummyTypes);
        Builder builder = (Builder) method.invoke(b, dummyParameters);
        return builder;
    } catch (Exception e) {
        throw new RuntimeException("getFieldBuilder exception", e);
    }
}
 

public void testRemove() throws Exception {
  Descriptor descriptor = MapMsg.Builder.getDescriptor();
  FieldDescriptor stringStringField = descriptor.findFieldByNumber(1);

  MapMsg.Builder builder = getFilledMessage().toBuilder();
  builder.removeStringString("duck");
  assertEquals("default", builder.getStringStringOrDefault("duck", "default"));
  assertEquals(1, builder.getStringStringCount());
  assertEquals("meow", builder.getStringStringOrThrow("cat"));
  Object rawEntry = builder.getRepeatedField(stringStringField, 0);
  assertTrue(rawEntry instanceof MapEntry);
  MapEntry<?, ?> entry = (MapEntry<?, ?>) rawEntry;
  assertEquals("cat", entry.getKey());
  assertEquals("meow", entry.getValue());
}
 

public void testGetAllFields() throws Exception {
  Descriptor descriptor = MapMsg.Builder.getDescriptor();
  Map<FieldDescriptor, Object> allFields = getFilledMessage().getAllFields();

  Object rawField = allFields.get(descriptor.findFieldByNumber(2));
  assertTrue(rawField instanceof List);
  Object rawEntry = ((List<?>) rawField).get(0);
  assertTrue(rawEntry instanceof MapEntry);
  MapEntry<?, ?> entry = (MapEntry<?, ?>) rawEntry;
  assertEquals("triangle", entry.getKey());
  assertEquals(Integer.valueOf(3), entry.getValue());
  rawEntry = ((List<?>) rawField).get(1);
  assertTrue(rawEntry instanceof MapEntry);
  entry = (MapEntry<?, ?>) rawEntry;
  assertEquals("square", entry.getKey());
  assertEquals(Integer.valueOf(4), entry.getValue());

  rawField = allFields.get(descriptor.findFieldByNumber(7));
  assertTrue(rawField instanceof List);
  rawEntry = ((List<?>) rawField).get(0);
  assertTrue(rawEntry instanceof MapEntry);
  entry = (MapEntry<?, ?>) rawEntry;
  assertEquals(Boolean.TRUE, entry.getKey());
  assertEquals(Integer.valueOf(0), entry.getValue());
  rawEntry = ((List<?>) rawField).get(1);
  assertTrue(rawEntry instanceof MapEntry);
  entry = (MapEntry<?, ?>) rawEntry;
  assertEquals(Boolean.FALSE, entry.getKey());
  assertEquals(Integer.valueOf(2), entry.getValue());
}
 

@SuppressWarnings("unchecked")
public void testMixingMapAndListApi() throws Exception {
  Descriptor descriptor = MapMsg.Builder.getDescriptor();
  FieldDescriptor field = descriptor.findFieldByNumber(1);
  MapMsg.Builder builder = getFilledMessage().toBuilder();
  MapEntry<String, String> entry = (MapEntry<String, String>) builder.getRepeatedField(field, 0);
  entry = entry.toBuilder().setKey("cat").setValue("purr").build();
  builder.setRepeatedField(field, 0, entry);
  assertEquals(2, builder.getRepeatedFieldCount(field));
  assertEquals(1, builder.getStringStringCount());
  assertEquals("meow", builder.getStringStringOrThrow("cat"));
}
 

public static <T extends Message> T copy(T entity, Set<String> fields) {
    // Split nested field names
    Map<String, Set<String>> topNames = PropertiesExt.splitNames(fields, 1);

    // Filter
    Message.Builder builder = entity.toBuilder();

    // As we modify the builder, we need to take a snapshot this
    Set<Descriptors.FieldDescriptor> fieldDescriptors = new HashSet<>(builder.getAllFields().keySet());
    for (Descriptors.FieldDescriptor field : fieldDescriptors) {
        if (!topNames.containsKey(field.getName())) {
            builder.clearField(field);
        } else {
            Set<String> nested = topNames.get(field.getName());
            if (nested != null) {
                Object value = builder.getField(field);
                if (value != null) {
                    if (value instanceof Message) {
                        Message messageValue = (Message) value;
                        if (!messageValue.getAllFields().isEmpty()) {
                            builder.setField(field, copy(messageValue, nested));
                        }
                    } else if (value instanceof Collection) {
                        Collection<?> collection = (Collection<?>) value;
                        if (!collection.isEmpty()) {
                            Object first = CollectionsExt.first(collection);
                            if (first instanceof MapEntry) {
                                if (((MapEntry) first).getKey() instanceof String) {
                                    List<?> filteredMap = collection.stream().filter(item -> {
                                        MapEntry<String, Object> entry = (MapEntry<String, Object>) item;
                                        return nested.contains(entry.getKey());
                                    }).collect(Collectors.toList());
                                    builder.setField(field, filteredMap);
                                }
                            } else if (first instanceof Message) {
                                Iterator<?> it = collection.iterator();
                                int size = collection.size();
                                for (int i = 0; i < size; i++) {
                                    builder.setRepeatedField(field, i, copy((Message) it.next(), nested));
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    return (T) builder.build();
}
 

@SuppressWarnings("unchecked")
public void testMapFieldDescriptor() throws Exception {
  Descriptor descriptor = MapMsg.Builder.getDescriptor();
  FieldDescriptor stringStringField = descriptor.findFieldByNumber(1);
  FieldDescriptor boolEnumField = descriptor.findFieldByNumber(7);
  assertEquals(Type.MESSAGE, stringStringField.getType());
  assertTrue(stringStringField.isRepeated());

  Descriptor entryDescriptor = stringStringField.getMessageType();
  assertNotNull(entryDescriptor);
  assertEquals(2, entryDescriptor.getFields().size());

  FieldDescriptor keyFieldDescriptor = entryDescriptor.findFieldByNumber(1);
  FieldDescriptor valueFieldDescriptor = entryDescriptor.findFieldByNumber(2);
  assertEquals("key", keyFieldDescriptor.getName());
  assertEquals(Type.STRING, keyFieldDescriptor.getType());
  assertEquals("value", valueFieldDescriptor.getName());
  assertEquals(Type.STRING, valueFieldDescriptor.getType());

  MapMsg msg = getFilledMessage();
  Object rawValue = msg.getField(stringStringField);
  assertTrue(rawValue instanceof List);
  List<?> list = (List<?>) rawValue;
  assertEquals(2, list.size());
  Object rawEntry = list.get(0);
  assertTrue(rawEntry instanceof MapEntry);
  MapEntry<?, ?> entry = (MapEntry<?, ?>) rawEntry;
  assertEquals("duck", entry.getKey());
  assertEquals("quack", entry.getValue());

  rawEntry = msg.getRepeatedField(stringStringField, 1);
  assertTrue(rawEntry instanceof MapEntry);
  entry = (MapEntry<?, ?>) rawEntry;
  assertEquals("cat", entry.getKey());
  assertEquals("meow", entry.getValue());

  list = (List<?>) msg.getField(boolEnumField);
  entry = (MapEntry<?, ?>) list.get(0);
  assertTrue(entry.getKey() instanceof Boolean);
  assertTrue(entry.getValue() instanceof Integer);
  assertEquals(Boolean.TRUE, entry.getKey());
  assertEquals(Integer.valueOf(0), entry.getValue());
  entry = (MapEntry<?, ?>) msg.getRepeatedField(boolEnumField, 1);
  assertTrue(entry.getKey() instanceof Boolean);
  assertTrue(entry.getValue() instanceof Integer);
  assertEquals(Boolean.FALSE, entry.getKey());
  assertEquals(Integer.valueOf(2), entry.getValue());

  MapMsg.Builder builder = msg.toBuilder();
  MapEntry<String, String> stringStringEntry =
      ((List<MapEntry<String, String>>) msg.getField(stringStringField)).get(0);
  stringStringEntry = stringStringEntry.toBuilder().setValue("neigh").build();
  builder.setRepeatedField(stringStringField, 0, stringStringEntry);
  stringStringEntry = stringStringEntry.toBuilder().setKey("cow").setValue("moo").build();
  builder.addRepeatedField(stringStringField, stringStringEntry);
  assertEquals(3, builder.getStringStringCount());
  assertEquals(3, builder.getRepeatedFieldCount(stringStringField));
  assertEquals("moo", builder.getStringStringOrThrow("cow"));
  builder.clearField(stringStringField);
  assertEquals("default", builder.getStringStringOrDefault("cow", "default"));
  assertEquals(0, builder.getStringStringCount());

  List<MapEntry<String, String>> newStringStringList = new ArrayList<>();
  newStringStringList.add(
      stringStringEntry.toBuilder().setKey("parrot").setValue("squawk").build());
  newStringStringList.add(stringStringEntry.toBuilder().setKey("pig").setValue("oink").build());
  builder.setField(stringStringField, newStringStringList);
  assertEquals("squawk", builder.getStringStringOrThrow("parrot"));
  assertEquals("oink", builder.getStringStringOrThrow("pig"));
}