public ImmutableList<Field> getRequiredFields() { ImmutableList.Builder<Field> required = ImmutableList.builder(); for (Field field : fieldsAndOneOfFields()) { if (field.isRequired()) { required.add(field); } } return required.build(); }
private MethodSpec builderNoArgsConstructor(NameAllocator nameAllocator, MessageType type) { MethodSpec.Builder result = MethodSpec.constructorBuilder().addModifiers(PUBLIC); for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); CodeBlock initialValue = initialValue(field); if (initialValue != null) { result.addStatement("$L = $L", fieldName, initialValue); } } return result.build(); }
private MethodSpec messageAdapterEncode(NameAllocator nameAllocator, MessageType type, TypeName javaType, boolean useBuilder) { MethodSpec.Builder result = MethodSpec.methodBuilder("encode") .addAnnotation(Override.class) .addModifiers(PUBLIC) .addParameter(ProtoWriter.class, "writer") .addParameter(javaType, "value") .addException(IOException.class); for (Field field : type.fieldsAndOneOfFields()) { int fieldTag = field.tag(); CodeBlock adapter = adapterFor(field); result.addCode("$L.encodeWithTag(writer, $L, ", adapter, fieldTag) .addCode((useBuilder ? "value.$L" : "$L(value)"), nameAllocator.get(field)) .addCode(");\n"); } if (useBuilder) { result.addStatement("writer.writeBytes(value.unknownFields())"); } return result.build(); }
private MethodSpec newBuilder(NameAllocator nameAllocator, MessageType message) { NameAllocator localNameAllocator = nameAllocator.clone(); String builderName = localNameAllocator.newName("builder"); ClassName javaType = (ClassName) typeName(message.type()); ClassName builderJavaType = javaType.nestedClass("Builder"); MethodSpec.Builder result = MethodSpec.methodBuilder("newBuilder") .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(builderJavaType) .addStatement("$1T $2L = new $1T()", builderJavaType, builderName); List<Field> fields = message.fieldsAndOneOfFields(); for (Field field : fields) { String fieldName = localNameAllocator.get(field); if (field.isRepeated() || field.type().isMap()) { result.addStatement("$1L.$2L = $3T.copyOf($2S, $2L)", builderName, fieldName, Internal.class); } else { result.addStatement("$1L.$2L = $2L", builderName, fieldName); } } result.addStatement("$L.addUnknownFields(unknownFields())", builderName); result.addStatement("return $L", builderName); return result.build(); }
void validate(Linker linker) { linker = linker.withContext(this); linker.validateFields(fieldsAndOneOfFields(), reserveds); linker.validateEnumConstantNameUniqueness(nestedTypes); for (Field field : fieldsAndOneOfFields()) { field.validate(linker); } for (Type type : nestedTypes) { type.validate(linker); } for (Extensions extensions : extensionsList) { extensions.validate(linker); } }
private MethodSpec messageHashCode(NameAllocator nameAllocator, MessageType type) { NameAllocator localNameAllocator = nameAllocator.clone(); String resultName = localNameAllocator.newName("result"); MethodSpec.Builder result = MethodSpec.methodBuilder("hashCode") .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(int.class); List<Field> fields = type.fieldsAndOneOfFields(); if (fields.isEmpty()) { result.addStatement("return unknownFields().hashCode()"); return result.build(); } result.addStatement("int $N = super.hashCode", resultName); result.beginControlFlow("if ($N == 0)", resultName); result.addStatement("$N = unknownFields().hashCode()", resultName); for (Field field : fields) { String fieldName = localNameAllocator.get(field); result.addCode("$1N = $1N * 37 + ", resultName); if (field.isRepeated() || field.isRequired() || field.type().isMap()) { result.addStatement("$L.hashCode()", fieldName); } else { result.addStatement("($1L != null ? $1L.hashCode() : 0)", fieldName); } } result.addStatement("super.hashCode = $N", resultName); result.endControlFlow(); result.addStatement("return $N", resultName); return result.build(); }
private MethodSpec messageAdapterEncodedSize(NameAllocator nameAllocator, MessageType type, TypeName javaType, boolean useBuilder) { MethodSpec.Builder result = MethodSpec.methodBuilder("encodedSize") .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(int.class) .addParameter(javaType, "value"); result.addCode("$["); String leading = "return"; for (Field field : type.fieldsAndOneOfFields()) { int fieldTag = field.tag(); String fieldName = nameAllocator.get(field); CodeBlock adapter = adapterFor(field); result.addCode("$L $L.encodedSizeWithTag($L, ", leading, adapter, fieldTag) .addCode((useBuilder ? "value.$L" : "$L(value)"), fieldName) .addCode(")"); leading = "\n+"; } if (useBuilder) { result.addCode("$L value.unknownFields().size()", leading); } result.addCode(";$]\n", leading); return result.build(); }
private MethodSpec messageEquals(NameAllocator nameAllocator, MessageType type) { NameAllocator localNameAllocator = nameAllocator.clone(); String otherName = localNameAllocator.newName("other"); String oName = localNameAllocator.newName("o"); TypeName javaType = typeName(type.type()); MethodSpec.Builder result = MethodSpec.methodBuilder("equals") .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(boolean.class) .addParameter(Object.class, otherName); List<Field> fields = type.fieldsAndOneOfFields(); if (fields.isEmpty()) { result.addStatement("return $N instanceof $T", otherName, javaType); return result.build(); } result.addStatement("if ($N == this) return true", otherName); result.addStatement("if (!($N instanceof $T)) return false", otherName, javaType); result.addStatement("$T $N = ($T) $N", javaType, oName, javaType, otherName); result.addCode("$[return unknownFields().equals($N.unknownFields())", oName); for (Field field : fields) { String fieldName = localNameAllocator.get(field); if (field.isRequired() || field.isRepeated() || field.type().isMap()) { result.addCode("\n&& $1L.equals($2N.$1L)", fieldName, oName); } else { result.addCode("\n&& $1T.equals($2L, $3N.$2L)", Internal.class, fieldName, oName); } } result.addCode(";\n$]"); return result.build(); }
private MethodSpec messageFieldsConstructor(NameAllocator nameAllocator, MessageType type) { MethodSpec.Builder result = MethodSpec.constructorBuilder(); result.addModifiers(PUBLIC); result.addCode("this("); for (Field field : type.fieldsAndOneOfFields()) { TypeName javaType = fieldType(field); String fieldName = nameAllocator.get(field); ParameterSpec.Builder param = ParameterSpec.builder(javaType, fieldName); if (emitAndroidAnnotations && field.isOptional()) { param.addAnnotation(NULLABLE); } result.addParameter(param.build()); result.addCode("$L, ", fieldName); } result.addCode("$T.EMPTY);\n", BYTE_STRING); return result.build(); }
private TypeSpec builder(NameAllocator nameAllocator, MessageType type, ClassName javaType, ClassName builderType) { TypeSpec.Builder result = TypeSpec.classBuilder("Builder") .addModifiers(PUBLIC, STATIC, FINAL); result.superclass(builderOf(javaType, builderType)); for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); result.addField(fieldType(field), fieldName, PUBLIC); } result.addMethod(builderNoArgsConstructor(nameAllocator, type)); for (Field field : type.fields()) { result.addMethod(setter(nameAllocator, builderType, null, field)); } for (OneOf oneOf : type.oneOfs()) { for (Field field : oneOf.fields()) { result.addMethod(setter(nameAllocator, builderType, oneOf, field)); } } result.addMethod(builderBuild(nameAllocator, type, javaType)); return result.build(); }
.returns(javaType); for (Field field : type.fieldsAndOneOfFields()) { TypeName fieldType = fieldType(field); String fieldName = nameAllocator.get(field); adapter.addMethod(messageAdapterRedact(nameAllocator, type, javaType, useBuilder, builderType)); for (Field field : type.fieldsAndOneOfFields()) { if (field.type().isMap()) { TypeName adapterType = adapterOf(fieldType(field));
private MethodSpec messageToString(NameAllocator nameAllocator, MessageType type) { NameAllocator localNameAllocator = nameAllocator.clone(); MethodSpec.Builder result = MethodSpec.methodBuilder("toString") .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(String.class); String builderName = localNameAllocator.newName("builder"); result.addStatement("$1T $2N = new $1T()", StringBuilder.class, builderName); for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); if (field.isRepeated() || field.type().isMap()) { result.addCode("if (!$N.isEmpty()) ", fieldName); } else if (!field.isRequired()) { result.addCode("if ($N != null) ", fieldName); } if (field.isRedacted()) { result.addStatement("$N.append(\", $N=██\")", builderName, field.name()); } else { result.addStatement("$N.append(\", $N=\").append($L)", builderName, field.name(), fieldName); } } result.addStatement("return builder.replace(0, 2, \"$L{\").append('}').toString()", type.type().simpleName()); return result.build(); }
for (Field field : type.fieldsAndOneOfFields()) { if (field.isRedacted()) { redactedFieldCount++; for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); if (field.isRedacted()) {
.addException(IOException.class); List<Field> fields = TAG_ORDERING.sortedCopy(type.fieldsAndOneOfFields()); result.addCode("return fromProto("); boolean first = true; for (Field field : type.fieldsAndOneOfFields()) { if (!first) result.addCode(", "); result.addCode("$N", nameAllocator.get(field));
for (Field field : message.fieldsAndOneOfFields()) { result.addCode("$L, ", nameAllocator.get(field));
private void markRoots(Type type) { ProtoType protoType = type.type(); if (identifierSet.includes(protoType)) { marks.root(protoType); queue.add(protoType); } else { if (type instanceof MessageType) { for (Field field : ((MessageType) type).fieldsAndOneOfFields()) { markRoots(ProtoMember.get(protoType, field.name())); } } else if (type instanceof EnumType) { for (EnumConstant enumConstant : ((EnumType) type).constants()) { markRoots(ProtoMember.get(protoType, enumConstant.name())); } } else { throw new AssertionError(); } } for (Type nested : type.nestedTypes()) { markRoots(nested); } }
result.endControlFlow(); for (Field field : type.fieldsAndOneOfFields()) { TypeName javaType = fieldType(field); String fieldName = localNameAllocator.get(field);
@Override public NameAllocator load(Type type) throws Exception { NameAllocator nameAllocator = new NameAllocator(); if (type instanceof MessageType) { nameAllocator.newName("serialVersionUID", "serialVersionUID"); nameAllocator.newName("ADAPTER", "ADAPTER"); nameAllocator.newName("MESSAGE_OPTIONS", "MESSAGE_OPTIONS"); if (emitAndroid) { nameAllocator.newName("CREATOR", "CREATOR"); } ImmutableList<Field> fieldsAndOneOfFields = ((MessageType) type).fieldsAndOneOfFields(); Set<String> collidingNames = collidingFieldNames(fieldsAndOneOfFields); for (Field field : fieldsAndOneOfFields) { String suggestion = collidingNames.contains(field.name()) ? field.qualifiedName() : field.name(); nameAllocator.newName(suggestion, field); } } else if (type instanceof EnumType) { nameAllocator.newName("value", "value"); nameAllocator.newName("i", "i"); nameAllocator.newName("reader", "reader"); nameAllocator.newName("writer", "writer"); for (EnumConstant constant : ((EnumType) type).constants()) { nameAllocator.newName(constant.name(), constant); } } return nameAllocator; } });
for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); String optionsFieldName = "FIELD_OPTIONS_" + fieldName.toUpperCase(Locale.US); for (Field field : type.fieldsAndOneOfFields()) { TypeName fieldJavaType = fieldType(field);
private MethodSpec builderNoArgsConstructor(NameAllocator nameAllocator, MessageType type) { MethodSpec.Builder result = MethodSpec.constructorBuilder().addModifiers(PUBLIC); for (Field field : type.fieldsAndOneOfFields()) { String fieldName = nameAllocator.get(field); if (field.isPacked() || field.isRepeated()) { result.addStatement("$L = $T.newMutableList()", fieldName, Internal.class); } else if (field.type().isMap()) { result.addStatement("$L = $T.newMutableMap()", fieldName, Internal.class); } } return result.build(); }