export function renderImplementation()

in src/objc-renderer.ts [1405:1502]
83 lines of code
5 McCabe index (conditional complexity)

export function renderImplementation(file: Code.File): string | null {
  if (fileHasImplementationCodeToRender(file)) {
    const commentsStr = file.comments.map(toCommentString).join('\n');
    const commentsSection = codeSectionForCodeString(commentsStr);

    const imports = file.imports.filter(isPrivateImport).map(toImportString);
    const importStr = arrayWithDuplicatesRemoved(imports).join('\n');
    const importsSection = codeSectionForCodeString(importStr);

    const diagnosticIgnoresStr = file.diagnosticIgnores
      .map(toDiagnosticIgnoreString)
      .join('\n');
    const diagnosticIgnoresSection =
      diagnosticIgnoreSectionFromStr(diagnosticIgnoresStr);
    const diagnosticIgnoresEndSection =
      diagnosticIgnoreEndSectionFromStr(diagnosticIgnoresStr);

    const macros = fileMacros(file);

    const prefixMacrosSection: string = codeSectionForCodeString(
      macros.map(toPrefixMacroString).join('\n'),
    );

    const staticConstantsStr = file.staticConstants
      .map(toStaticConstantString)
      .join('\n');
    const staticConstantsSection = codeSectionForCodeString(staticConstantsStr);

    const globalVariablesStr = file.globalVariables
      .map(toglobalVariablestring)
      .join('\n');
    const globalVariablesSection = codeSectionForCodeString(globalVariablesStr);

    const enumerationsStr = file.enumerations
      .filter(enumerationIsPublic(false))
      .map(toNSEnumDeclaration)
      .join('\n');
    const enumerationsSection = codeSectionForCodeString(enumerationsStr);

    const blocksStr: string = file.blockTypes
      .filter(blockTypeIsPublic(false))
      .map(toBlockTypeDeclarationWithMacros)
      .join('\n');
    const blocksSection: string = codeSectionForCodeString(blocksStr);

    const macrosStr = file.macros.map(toMacroImplementationString).join('\n\n');
    const macrosSection = codeSectionForCodeString(macrosStr);

    const staticFunctionProtoStr = file.functions
      .filter((func) => !func.isInline && !func.isPublic)
      .map((func) => functionDeclarationForFunction(func) + ';')
      .join('\n');
    const staticFunctionProtoSection = codeSectionForCodeString(
      staticFunctionProtoStr,
    );

    const functionStr = file.functions
      .filter((func) => !(func.isInline && func.isPublic))
      .map(toFunctionImplementationString)
      .join('\n\n');
    const functionsSection = codeSectionForCodeString(functionStr);
    const classesSection = file.classes
      .map(implementationClassSection)
      .join('\n\n');

    var cppClassesStr = file.cppClasses.map(toCppClassDefinition).join('\n\n');
    if (cppClassesStr.length > 0) {
      cppClassesStr += '\n';
    }

    const postfixMacrosSection: string = codeSectionForCodeString(
      macros.map(toPostfixMacroString).join('\n'),
    );

    const contents: string =
      commentsSection +
      arcCompileFlagCheckSection() +
      importsSection +
      diagnosticIgnoresSection +
      prefixMacrosSection +
      staticConstantsSection +
      globalVariablesSection +
      enumerationsSection +
      blocksSection +
      macrosSection +
      staticFunctionProtoSection +
      classesSection +
      '\n' +
      cppClassesStr +
      functionsSection +
      postfixMacrosSection +
      diagnosticIgnoresEndSection;

    return contents.trim() + '\n';
  } else {
    return null;
  }
}