in scrooge-generator/src/main/scala/com/twitter/scrooge/backend/StructTemplate.scala [356:521]
def fieldsToDict(
fields: Seq[Field],
blacklist: Seq[String],
namespace: Option[Identifier] = None
): Seq[Dictionary] = {
fields.zipWithIndex map {
case (field, index) =>
val valueVariableID = field.sid.append("_item")
val fieldName = genID(field.sid)
val camelCaseFieldName =
if (fieldName.toString.indexOf('_') >= 0)
genID(field.sid.toCamelCase)
else
NoValue
Dictionary(
"index" -> v(index.toString),
"indexP1" -> v((index + 1).toString),
"_fieldName" -> genID(field.sid.prepend("_")), // for Java and Scala only
"unsetName" -> genID(field.sid.toTitleCase.prepend("unset")),
"readName" -> genID(field.sid.toTitleCase.prepend("read")),
"getBlobName" -> genID(field.sid.toTitleCase.prepend("get").append("Blob")),
"readBlobName" -> genID(field.sid.toTitleCase.prepend("read").append("Blob")),
"getName" -> genID(field.sid.toTitleCase.prepend("get")), // for Java only
"isSetName" -> genID(field.sid.toTitleCase.prepend("isSet")), // for Java only
"fieldName" -> fieldName,
"docstring" -> v(field.docstring.getOrElse("")),
"fieldNameForWire" -> v(field.originalName),
"fieldNameCamelCase" -> camelCaseFieldName,
"setName" -> genID(field.sid.toCamelCase.prepend("set_")), // for Scala only
"delegateName" -> genID(field.sid.toCamelCase.prepend("delegated_")), // for Scala only
"memberName" -> genID(field.sid.toCamelCase.prepend("m_")), // for Scala only
"newFieldName" -> genID(field.sid.toTitleCase.prepend("new")),
"FieldName" -> genID(field.sid.toTitleCase),
"FIELD_NAME" -> genID(field.sid.toUpperCase),
"gotName" -> genID(field.sid.prepend("_got_")),
"id" -> v(field.index.toString),
"fieldConst" -> genID(field.sid.toTitleCase.append("Field")),
"constType" -> genConstType(field.fieldType),
"isPrimitive" -> v(isPrimitive(field.fieldType)),
"isLazyReadEnabled" -> v(
isLazyReadEnabled(field.fieldType, field.requiredness.isOptional)
),
"primitiveFieldType" -> genPrimitiveType(field.fieldType),
"fieldType" -> genType(field.fieldType),
"fieldKeyType" -> v(field.fieldType match {
case MapType(keyType, _, _) => Some(genType(keyType))
case _ => None
}),
"fieldValueType" -> v(field.fieldType match {
case MapType(_, valueType, _) => Some(genType(valueType))
case ListType(valueType, _) => Some(genType(valueType))
case SetType(valueType, _) => Some(genType(valueType))
case _ => None
}),
"fieldTypeAnnotations" -> TemplateGenerator.renderPairs(field.typeAnnotations),
"fieldFieldAnnotations" -> TemplateGenerator.renderPairs(field.fieldAnnotations),
"isImported" -> v(field.fieldType match {
case n: NamedType => n.scopePrefix.isDefined
case _ => false
}),
"isNamedType" -> v(field.fieldType.isInstanceOf[NamedType]),
"hasPassthroughFields" -> v(!canCallWithoutPassthroughFields(field.fieldType)),
"passthroughFields" -> {
val insides = buildPassthroughFields(field.fieldType)
if (field.requiredness.isOptional) {
v(
Dictionary(
"ptIter" -> insides
)
)
} else {
insides
}
},
"isEnum" -> v(field.fieldType.isInstanceOf[EnumType]),
"isStruct" -> v(field.fieldType.isInstanceOf[StructType]),
// "qualifiedFieldType" is used to generate qualified type name even if it's not
// imported, in case other same-named entities are generated in the same file.
"qualifiedFieldType" -> v(templates("qualifiedFieldType")),
"hasDefaultValue" -> v(genDefaultFieldValue(field).isDefined),
"defaultFieldValue" -> genDefaultFieldValue(field).getOrElse(NoValue),
// these two alternate default values are for constructors that do not accept Options for
// construction required fields.
"hasAlternateDefaultValue" -> v(
genDefaultFieldValue(field, forAlternateConstructor = true).isDefined
),
"alternateDefaultFieldValue" -> genDefaultFieldValue(
field,
forAlternateConstructor = true
).getOrElse(NoValue),
"hasDefaultFieldValueForFieldInfo" -> v(
genDefaultFieldValueForFieldInfo(field).isDefined
),
"defaultFieldValueForFieldInfo" -> genDefaultFieldValueForFieldInfo(field)
.getOrElse(NoValue),
"defaultReadValue" -> genDefaultReadValue(field),
"unsafeEmptyReadValue" -> genUnsafeEmptyReadValue(field),
"hasGetter" -> v(!blacklist.contains(field.sid.name)),
"hasIsDefined" -> v(
field.requiredness.isOptional || (!field.requiredness.isRequired && !isPrimitive(
field.fieldType
))
),
"required" -> v(field.requiredness.isRequired),
"optional" -> v(field.requiredness.isOptional),
"nullable" -> v(isNullableType(field)),
"nullValid" -> v(isNullValid(field)),
"constructionOptional" -> v(
!isConstructionRequiredField(field) && field.requiredness.isOptional
),
"constructionRequired" -> v(
isConstructionRequiredField(field)
),
"collection" -> v {
(field.fieldType match {
case ListType(eltType, _) => List(genType(eltType))
case SetType(eltType, _) => List(genType(eltType))
case MapType(keyType, valueType, _) =>
List(v("(" + genType(keyType).toData + ", " + genType(valueType).toData + ")"))
case _ => Nil
}) map { t => Dictionary("elementType" -> t) }
},
"readFieldValue" -> genReadValue(field.fieldType, "_iprot"),
"readFieldValueOrMethod" -> genReadValueOrMethod(field.sid, field.fieldType, "_iprot"),
"readFieldValueName" -> genID(field.sid.toTitleCase.prepend("read").append("Value")),
"writeFieldName" -> genID(field.sid.toTitleCase.prepend("write").append("Field")),
"writeFieldValueName" -> genID(field.sid.toTitleCase.prepend("write").append("Value")),
"writeFieldValue" -> genWriteValue(v("_value"), field.fieldType, "_oprot"),
"writeValueOrMethod" -> genWriteValueOrMethod(
genID(field.sid),
field.fieldType,
field.requiredness.isOptional,
"_oprot"),
"readField" -> v(templates("readField")),
"decodeProtocol" -> genDecodeProtocolMethod(field.fieldType),
"offsetSkipProtocol" -> genOffsetSkipProtocolMethod(field.fieldType),
"readUnionField" -> v(templates("readUnionField")),
"readLazyField" -> v(templates("readLazyField")),
"readAdaptField" -> v(templates("readAdaptField")),
"readValue" -> v(templates("readValue")),
"skipValue" -> v(templates("skipValue")),
"writeField" -> v(templates("writeField")),
"writeValue" -> v(templates("writeValue")),
"writeList" -> v(templates("writeList")),
"writeSet" -> v(templates("writeSet")),
"writeMap" -> v(templates("writeMap")),
"writeStruct" -> v(templates("writeStruct")),
"writeEnum" -> v(templates("writeEnum")),
"writeBase" -> v(templates("writeBase")),
"readList" -> v(templates("readList")),
"readSet" -> v(templates("readSet")),
"readMap" -> v(templates("readMap")),
"readStruct" -> v(templates("readStruct")),
"readEnum" -> v(templates("readEnum")),
"readBase" -> v(templates("readBase")),
"optionalType" -> v(templates("optionalType")),
"constructionOptionalType" -> v(templates("constructionOptionalType")),
"withoutPassthrough" -> v(templates("withoutPassthrough")),
"readWriteInfo" -> v(readWriteInfo(valueVariableID, field.fieldType)),
"valueVariableName" -> genID(valueVariableID),
"first" -> v(fields.head.index == field.index),
"last" -> v(fields.last.index == field.index)
)
}
}