@Override void validate(FieldDescriptor fieldDescriptor) { checkArgument( !fieldDescriptor.isMapField(), "%s is a map field; it has no order", fieldDescriptor); checkArgument( fieldDescriptor.isRepeated(), "%s is not a repeated field; it has no order", fieldDescriptor); } },
for (Map.Entry<Descriptors.FieldDescriptor, Object> field : fieldsMap.entrySet()) { if (sameField(fieldName, field.getKey().getName())) { if (field.getKey().isMapField()) {
} else if (descriptor.isMapField()) { if (!compareMapField(value1, value2)) { return false;
private static AccessType get(FieldDescriptor desc) { if (desc.isMapField()) { // Check map first because proto map fields are represented as repeated in the descriptor // even though map fields cannot have a "repeated" qualifier in the proto language. return MAP; } else if (desc.isRepeated()) { return REPEATED; } else { return SINGULAR; } } }
private static String fieldSuffix(FieldDescriptor field) { if (field.isMapField()) { return "Map"; } else if (field.isRepeated()) { return "List"; } else { return ""; } }
/** Returns the {@link MethodRef} for the generated put method for proto map. */ private static MethodRef getPutMethod(FieldDescriptor descriptor) { Preconditions.checkState(descriptor.isMapField()); List<FieldDescriptor> mapFields = descriptor.getMessageType().getFields(); TypeInfo builder = builderRuntimeType(descriptor.getContainingType()); return MethodRef.createInstanceMethod( builder, new Method( "put" + getFieldName(descriptor, true), builder.type(), new Type[] {getRuntimeType(mapFields.get(0)), getRuntimeType(mapFields.get(1))})); }
/** Returns true if fieldDescriptor holds a map where the values are a sanitized proto type. */ public static boolean isSanitizedContentMap(FieldDescriptor fieldDescriptor) { if (!fieldDescriptor.isMapField()) { return false; } Descriptor valueDesc = getMapValueMessageType(fieldDescriptor); if (valueDesc == null) { return false; } return SAFE_PROTO_TYPES.contains(valueDesc.getFullName()); }
@Override public boolean supports(Descriptors.FieldDescriptor fieldDescriptor) { if (!fieldDescriptor.isMapField()) { return false; } Descriptors.FieldDescriptor keyFd = fieldDescriptor.getMessageType().findFieldByName("key"); Descriptors.FieldDescriptor valFd = fieldDescriptor.getMessageType().findFieldByName("value"); return basicTypeFieldResolver.supports(keyFd) && basicTypeFieldResolver.supports(valFd); }
/** Returns the {@link MethodRef} for the generated put method for proto map. */ private static MethodRef getPutMethod(FieldDescriptor descriptor) { Preconditions.checkState(descriptor.isMapField()); List<FieldDescriptor> mapFields = descriptor.getMessageType().getFields(); TypeInfo builder = builderRuntimeType(descriptor.getContainingType()); return MethodRef.createInstanceMethod( builder, new Method( "put" + getFieldName(descriptor, true), builder.type(), new Type[] {getRuntimeType(mapFields.get(0)), getRuntimeType(mapFields.get(1))})); }
/** Returns true if fieldDescriptor holds a map where the values are a sanitized proto type. */ public static boolean isSanitizedContentMap(FieldDescriptor fieldDescriptor) { if (!fieldDescriptor.isMapField()) { return false; } Descriptor valueDesc = getMapValueMessageType(fieldDescriptor); if (valueDesc == null) { return false; } return SAFE_PROTO_TYPES.contains(valueDesc.getFullName()); }
if (fieldDescriptor.isMapField()) { Map<Object, Object> actualMap = toProtoMap(actualFields.get(fieldDescriptor)); Map<Object, Object> expectedMap = toProtoMap(expectedFields.get(fieldDescriptor));
@VisibleForTesting static TypeSignature newFieldTypeInfo(FieldDescriptor fieldDescriptor) { if (fieldDescriptor.isMapField()) { return TypeSignature.ofMap( newFieldTypeInfo(fieldDescriptor.getMessageType().findFieldByNumber(1)),
if (field.isMapField() && isMapFieldEnabled(field)) { fields[i] = new MapFieldAccessor( field, camelCaseNames[i], messageClass, builderClass);
if (field.isMapField()) { fields[i] = new MapFieldAccessor( field, camelCaseNames[i], messageClass, builderClass);
/** * {@inheritDoc} */ @Override public void setPropertyValue(Object bean, Object value, FieldMap fieldMap) { if (!(bean instanceof ProtoBeanBuilder)) { throw new MappingException("Expected a ProtoBeanBuilder instance, but got " + bean.getClass().getCanonicalName()); } ProtoBeanBuilder builder = (ProtoBeanBuilder)bean; value = ProtoUtils.wrapEnums(value); if (value != null) { if (getFieldDescriptor().isMapField()) { // Capitalize the first letter of the string; String propertyName = Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1); String methodName = String.format("putAll%s", propertyName); try { Method mapSetterMethod = builder.internalProtoBuilder().getClass().getMethod(methodName, Map.class); mapSetterMethod.invoke(builder.internalProtoBuilder(), value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) { throw new MappingException("Could not call map setter method " + methodName, ex); } } else { builder.internalProtoBuilder().setField(getFieldDescriptor(), value); } } else { builder.internalProtoBuilder().clearField(getFieldDescriptor()); } }
/** Get a hash code for given fields and values, using the given seed. */ @SuppressWarnings("unchecked") protected static int hashFields(int hash, Map<FieldDescriptor, Object> map) { for (Map.Entry<FieldDescriptor, Object> entry : map.entrySet()) { FieldDescriptor field = entry.getKey(); Object value = entry.getValue(); hash = (37 * hash) + field.getNumber(); if (field.isMapField()) { hash = (53 * hash) + hashMapField(value); } else if (field.getType() != FieldDescriptor.Type.ENUM){ hash = (53 * hash) + value.hashCode(); } else if (field.isRepeated()) { List<? extends EnumLite> list = (List<? extends EnumLite>) value; hash = (53 * hash) + Internal.hashEnumList(list); } else { hash = (53 * hash) + Internal.hashEnum((EnumLite) value); } } return hash; }
/** * Gets the class type of the {@link Descriptors.FieldDescriptor} * * @param descriptor {@link Descriptors.FieldDescriptor} instance * @param beanContainer {@link BeanContainer} instance * @return class type of the {@link Descriptors.FieldDescriptor} */ public static Class<?> getJavaClass(final Descriptors.FieldDescriptor descriptor, BeanContainer beanContainer) { if (descriptor.isMapField()) { return Map.class; } if (descriptor.isRepeated()) { return List.class; } return getJavaClassIgnoreRepeated(descriptor, beanContainer); }
private static void writeMessage(Message message, JsonWriter writer) { MessageType type = MessageType.of(message); for (Descriptors.FieldDescriptor fieldDescriptor : type.fieldDescriptors) { if (fieldDescriptor.isRepeated()) { writer.name(fieldDescriptor.getName()); if (fieldDescriptor.isMapField()) { writeMap((Collection<MapEntry>) message.getField(fieldDescriptor), writer); } else { writeArray(writer, fieldDescriptor, (Collection) message.getField(fieldDescriptor)); } } else if (message.hasField(fieldDescriptor)) { writer.name(fieldDescriptor.getName()); Object fieldValue = message.getField(fieldDescriptor); writeFieldValue(fieldDescriptor, fieldValue, writer); } } }
private static void writeMessageValue(Message message, JsonWriter writer) { MessageType messageType = MessageType.of(message); if (messageType.doesWrapRepeated) { Descriptors.FieldDescriptor repeatedDescriptor = messageType.fieldDescriptors[0]; if (repeatedDescriptor.isMapField()) { writeMap((Collection<MapEntry>) message.getField(repeatedDescriptor), writer); } else { writeArray(writer, repeatedDescriptor, (Collection) message.getField(repeatedDescriptor)); } } else { writer.beginObject(); writeMessage(message, writer); writer.endObject(); } } }
@JRubyMethod(name = {"to_h", "to_hash"}) public IRubyObject toHash(ThreadContext context) { Ruby runtime = context.runtime; RubyHash ret = RubyHash.newHash(runtime); for (Descriptors.FieldDescriptor fdef : this.descriptor.getFields()) { IRubyObject value = getField(context, fdef); if (!value.isNil()) { if (fdef.isRepeated() && !fdef.isMapField()) { if (fdef.getType() != Descriptors.FieldDescriptor.Type.MESSAGE) { value = Helpers.invoke(context, value, "to_a"); } else { RubyArray ary = value.convertToArray(); for (int i = 0; i < ary.size(); i++) { IRubyObject submsg = Helpers.invoke(context, ary.eltInternal(i), "to_h"); ary.eltInternalSet(i, submsg); } value = ary.to_ary(); } } else if (value.respondsTo("to_h")) { value = Helpers.invoke(context, value, "to_h"); } else if (value.respondsTo("to_a")) { value = Helpers.invoke(context, value, "to_a"); } } ret.fastASet(runtime.newSymbol(fdef.getName()), value); } return ret; }