function adaptResponseEnvelope()

in packages/autorest.go/src/m4togocodemodel/clients.ts [200:280]
74 lines of code
33 McCabe index (conditional complexity)

function adaptResponseEnvelope(m4CodeModel: m4.CodeModel, codeModel: go.CodeModel, op: m4.Operation, forMethod: go.Method): go.ResponseEnvelope {
  const respEnvSchema = <m4.ObjectSchema>op.language.go!.responseEnv;
  const respEnv = new go.ResponseEnvelope(respEnvSchema.language.go!.name, {description: respEnvSchema.language.go!.description}, forMethod);

  // add any headers
  for (const prop of values(respEnvSchema.properties)) {
    if (prop.language.go!.fromHeader) {
      let headerResp: go.HeaderResponse | go.HeaderMapResponse;
      if (prop.schema.language.go!.headerCollectionPrefix) {
        const headerType = adaptPossibleType(prop.schema, false);
        if (!go.isMapType(headerType)) {
          throw new Error(`unexpected type ${go.getTypeDeclaration(headerType)} for HeaderMapResponse ${prop.language.go!.name}`);
        }
        headerResp = new go.HeaderMapResponse(prop.language.go!.name, headerType, prop.schema.language.go!.headerCollectionPrefix, prop.language.go!.fromHeader, prop.language.go!.byValue);
      } else {
        headerResp = new go.HeaderResponse(prop.language.go!.name, adaptHeaderType(prop.schema, false), prop.language.go!.fromHeader, prop.language.go!.byValue);
      }
      if (hasDescription(prop.language.go!)) {
        headerResp.docs.description = prop.language.go!.description;
      }
      respEnv.headers.push(headerResp);
    }
  }

  if (!respEnvSchema.language.go!.resultProp) {
    return respEnv;
  }

  // now add the result field
  const resultProp = <m4.Property>respEnvSchema.language.go!.resultProp;
  if (helpers.isMultiRespOperation(op)) {
    respEnv.result = adaptAnyResult(op);
  } else if (resultProp.schema.type === m4.SchemaType.Binary) {
    respEnv.result = new go.BinaryResult(resultProp.language.go!.name, 'binary');
  } else if (m4CodeModel.language.go!.headAsBoolean && op.requests![0].protocol.http!.method === 'head') {
    respEnv.result = new go.HeadAsBooleanResult(resultProp.language.go!.name);
  } else if (!resultProp.language.go!.embeddedType) {
    const resultType = adaptPossibleType(resultProp.schema);
    if (go.isInterfaceType(resultType) || go.isLiteralValue(resultType) || go.isModelType(resultType) || go.isPolymorphicType(resultType) || go.isQualifiedType(resultType)) {
      throw new Error(`invalid monomorphic result type ${go.getTypeDeclaration(resultType)}`);
    }
    respEnv.result = new go.MonomorphicResult(resultProp.language.go!.name, adaptResultFormat(helpers.getSchemaResponse(op)!.protocol), resultType, resultProp.language.go!.byValue);
    respEnv.result.xml = adaptXMLInfo(resultProp.schema);
  } else if (resultProp.isDiscriminator) {
    let ifaceResult: go.InterfaceType | undefined;
    for (const iface of values(codeModel.interfaceTypes)) {
      if (iface.name === resultProp.schema.language.go!.name) {
        ifaceResult = iface;
        break;
      }
    }
    if (!ifaceResult) {
      throw new Error(`didn't find InterfaceType for result property ${resultProp.schema.language.go!.name}`);
    }
    respEnv.result = new go.PolymorphicResult(ifaceResult);
  } else if (helpers.getSchemaResponse(op)) {
    let modelType: go.ModelType | undefined;
    for (const model of codeModel.models) {
      if (model.name === resultProp.schema.language.go!.name) {
        modelType = model;
        break;
      }
    }
    if (!modelType) {
      throw new Error(`didn't find type name ${resultProp.schema.language.go!.name} for response envelope ${respEnv.name}`);
    }
    const resultFormat = adaptResultFormat(helpers.getSchemaResponse(op)!.protocol);
    if (resultFormat !== 'JSON' && resultFormat !== 'XML') {
      throw new Error(`unexpected result format ${resultFormat} for model ${modelType.name}`);
    }
    respEnv.result = new go.ModelResult(modelType, resultFormat);
  } else {
    throw new Error(`unhandled result type for operation ${op.language.go!.name}`);
  }

  if (hasDescription(resultProp.language.go!)) {
    respEnv.result.docs.description = resultProp.language.go!.description;
  }

  return respEnv;
}