func()

in codegen/type_converter.go [267:438]

• 154 lines of code
• 20 McCabe index (conditional complexity)

func (c *TypeConverter) genConverterForList(
	toField toFieldParam,
	fromField fromFieldParam,
	overriddenField overriddenFieldParam,
	indent string,
) error {
	toFieldType := toField.Type.(*compile.ListSpec)

	typeName, err := c.getGoTypeName(toFieldType.ValueSpec)
	if err != nil {
		return err
	}

	valueStruct, isStruct := compile.RootTypeSpec(toFieldType.ValueSpec).(*compile.StructSpec)
	valueList, isList := compile.RootTypeSpec(toFieldType.ValueSpec).(*compile.ListSpec)
	valueMap, isMap := compile.RootTypeSpec(toFieldType.ValueSpec).(*compile.MapSpec)
	sourceIdentifier := fromField.ValueIdentifier
	checkOverride := false

	sourceListID := ""
	isOverriddenID := ""

	if overriddenField.Identifier != "" {
		sourceListID = c.makeUniqIdentifier("sourceList")
		isOverriddenID = c.makeUniqIdentifier("isOverridden")

		// Determine which map (from or overrride) to use
		c.appendf("%s := %s", sourceListID, overriddenField.Identifier)
		if isStruct {
			c.appendf("%s := false", isOverriddenID)
		}
		// TODO(sindelar): Verify how optional thrift lists are defined.
		c.appendf("if %s != nil {", fromField.Identifier)

		c.appendf("\t%s = %s", sourceListID, fromField.Identifier)
		if isStruct {
			c.appendf("\t%s = true", isOverriddenID)
		}
		c.append("}")

		sourceIdentifier = sourceListID
		checkOverride = true
	}

	if isStruct {
		c.appendf(
			"%s = make([]*%s, len(%s))",
			toField.Identifier, typeName, sourceIdentifier,
		)
	} else {
		c.appendf(
			"%s = make([]%s, len(%s))",
			toField.Identifier, typeName, sourceIdentifier,
		)
	}

	indexID := c.makeUniqIdentifier("index")
	valID := c.makeUniqIdentifier("value")
	c.appendf(
		"for %s, %s := range %s {",
		indexID, valID, sourceIdentifier,
	)

	if isStruct || isList || isMap {
		nestedIndent := "\t" + indent

		fromFieldListType, ok := compile.RootTypeSpec(fromField.Type).(*compile.ListSpec)
		if !ok {
			return errors.Errorf(
				"Could not convert field (%s): type is not list",
				fromField.Name,
			)
		}

		if isStruct {
			if checkOverride {
				nestedIndent = "\t" + nestedIndent
				c.appendf("\tif %s {", isOverriddenID)
			}

			err = c.genConverterForStruct(
				toField.Name,
				valueStruct,
				toField.Required,
				fromFieldListType.ValueSpec,
				valID,
				trimAnyPrefix(toField.Identifier, "out.", "outOriginal.")+"["+indexID+"]",
				trimAnyPrefix(fromField.Identifier, "in.", "inOriginal.")+"["+indexID+"]",
				nestedIndent,
				nil,
				nil,
			)
			if err != nil {
				return err
			}
			if checkOverride {
				c.append("\t", "} else {")

				overriddenFieldListType, ok := overriddenField.Type.(*compile.ListSpec)
				if !ok {
					return errors.Errorf(
						"Could not convert field (%s): type is not list",
						overriddenField.Name,
					)
				}

				err = c.genConverterForStruct(
					toField.Name,
					valueStruct,
					toField.Required,
					overriddenFieldListType.ValueSpec,
					valID,
					trimAnyPrefix(toField.Identifier, "out.", "outOriginal.")+"["+indexID+"]",
					trimAnyPrefix(overriddenField.Identifier, "in.", "inOriginal.")+"["+indexID+"]",
					nestedIndent,
					nil,
					nil,
				)
				if err != nil {
					return err
				}
				c.append("\t", "}")
			}
		} else if isList {
			err = c.genConverterForList(
				toFieldParam{
					valueList,
					toField.Name,
					toField.Required,
					toField.Identifier + "[" + indexID + "]",
				},
				fromFieldParam{
					fromFieldListType.ValueSpec,
					fromField.Name,
					fromField.Identifier + "[" + indexID + "]",
					valID,
				},
				overriddenField,
				nestedIndent)
			if err != nil {
				return err
			}
		} else if isMap {
			err = c.genConverterForMap(
				toFieldParam{
					valueMap,
					toField.Name,
					toField.Required,
					toField.Identifier + "[" + indexID + "]",
				},
				fromFieldParam{
					fromFieldListType.ValueSpec,
					fromField.Name,
					fromField.Identifier + "[" + indexID + "]",
					valID,
				},
				overriddenField,
				nestedIndent)
			if err != nil {
				return err
			}
		}
	} else {
		c.appendf(
			"\t%s[%s] = %s(%s)",
			toField.Identifier, indexID, typeName, valID,
		)
	}

	c.append("}")
	return nil
}