private static IEnumerable GetCommandTransforms()

in codegen/src/Azure.Iot.Operations.ProtocolCompiler/EnvoyGenerator/EnvoyTransformFactory.cs [198:344]
123 lines of code
39 McCabe index (conditional complexity)

        private static IEnumerable<ITemplateTransform> GetCommandTransforms(string language, string projectName, CodeName genNamespace, string modelId, CodeName serviceName, string genFormat, string? commandTopic, JsonElement cmdElt, List<CommandEnvoyInfo> cmdEnvoyInfos, string? normalizedVersionSuffix, string? workingPath, bool generateClient, bool generateServer, bool useSharedSubscription)
        {
            bool doesCommandTargetExecutor = DoesTopicReferToExecutor(commandTopic);
            string serializerSubNamespace = formatSerializers[genFormat].SubNamespace;
            string serializerClassName = formatSerializers[genFormat].ClassName;
            EmptyTypeName serializerEmptyType = formatSerializers[genFormat].EmptyType;

            CodeName commandName = new CodeName(cmdElt.GetProperty(AnnexFileProperties.CommandName).GetString()!);

            string? reqSchemaRep = cmdElt.TryGetProperty(AnnexFileProperties.CmdRequestSchema, out JsonElement reqSchemaElt) ? reqSchemaElt.GetString() : null;
            ITypeName? reqSchemaType = reqSchemaRep == null ? null : reqSchemaRep switch
            {
                RawTypeName.Designator => RawTypeName.Instance,
                CustomTypeName.Designator => CustomTypeName.Instance,
                _ => new CodeName(reqSchemaRep),
            };
            CodeName? reqSchemaNamespace = cmdElt.TryGetProperty(AnnexFileProperties.CmdRequestNamespace, out JsonElement reqNamespaceElt) ? new(reqNamespaceElt.GetString()!) : null;

            string? respSchemaRep = cmdElt.TryGetProperty(AnnexFileProperties.CmdResponseSchema, out JsonElement respSchemaElt) ? respSchemaElt.GetString() : null;
            ITypeName? respSchemaType = respSchemaRep == null ? null : reqSchemaRep switch
            {
                RawTypeName.Designator => RawTypeName.Instance,
                CustomTypeName.Designator => CustomTypeName.Instance,
                _ => new CodeName(respSchemaRep),
            };
            CodeName? respSchemaNamespace = cmdElt.TryGetProperty(AnnexFileProperties.CmdResponseNamespace, out JsonElement respNamespaceElt) ? new(respNamespaceElt.GetString()!) : null;

            CodeName? normalResultName = cmdElt.TryGetProperty(AnnexFileProperties.NormalResultName, out JsonElement normalNameElt) ? new(normalNameElt.GetString()!) : null;
            CodeName? normalResultSchema = cmdElt.TryGetProperty(AnnexFileProperties.NormalResultSchema, out JsonElement normalSchemaElt) ? new(normalSchemaElt.GetString()!) : null;
            CodeName? normalResultNamespace = cmdElt.TryGetProperty(AnnexFileProperties.NormalResultNamespace, out JsonElement normalNamespaceElt) ? new(normalNamespaceElt.GetString()!) : null;
            CodeName? errorResultName = cmdElt.TryGetProperty(AnnexFileProperties.ErrorResultName, out JsonElement errorNameElt) ? new(errorNameElt.GetString()!) : null;
            CodeName? errorResultSchema = cmdElt.TryGetProperty(AnnexFileProperties.ErrorResultSchema, out JsonElement errorSchemaElt) ? new(errorSchemaElt.GetString()!) : null;
            CodeName? errorResultNamespace = cmdElt.TryGetProperty(AnnexFileProperties.ErrorResultNamespace, out JsonElement errorNamespaceElt) ? new(errorNamespaceElt.GetString()!) : null;
            bool isRequestNullable = cmdElt.TryGetProperty(AnnexFileProperties.RequestIsNullable, out JsonElement reqNullableElt) ? reqNullableElt.GetBoolean() : false;
            bool isResponseNullable = cmdElt.TryGetProperty(AnnexFileProperties.ResponseIsNullable, out JsonElement respNullableElt) ? respNullableElt.GetBoolean() : false;

            bool isIdempotent = cmdElt.GetProperty(AnnexFileProperties.CmdIsIdempotent).GetBoolean();
            string? cacheability = cmdElt.GetProperty(AnnexFileProperties.Cacheability).GetString();

            switch (language)
            {
                case "csharp":
                    if (generateClient)
                    {
                        yield return new DotNetCommandInvoker(commandName, projectName, genNamespace, modelId, serviceName, serializerSubNamespace, serializerClassName, serializerEmptyType, reqSchemaType, respSchemaType, reqSchemaNamespace, respSchemaNamespace);
                    }

                    if (generateServer)
                    {
                        yield return new DotNetCommandExecutor(commandName, projectName, genNamespace, modelId, serviceName, serializerSubNamespace, serializerClassName, serializerEmptyType, reqSchemaType, respSchemaType, reqSchemaNamespace, respSchemaNamespace, isIdempotent, cacheability);
                    }

                    if (genFormat == PayloadFormat.Avro)
                    {
                        if (reqSchemaType is CodeName dotnetReqSchema)
                        {
                            yield return new DotNetSerialization(projectName, genNamespace, dotnetReqSchema, workingPath);
                        }

                        if (respSchemaType is CodeName dotnetRespSchema)
                        {
                            yield return new DotNetSerialization(projectName, genNamespace, dotnetRespSchema, workingPath);
                        }
                    }

                    break;
                case "go":
                    if (generateClient)
                    {
                        yield return new GoCommandInvoker(commandName, genNamespace, serializerSubNamespace, reqSchemaType, respSchemaType, normalResultName, normalResultSchema, errorResultName, errorResultSchema, isResponseNullable, doesCommandTargetExecutor);
                    }

                    if (generateServer)
                    {
                        yield return new GoCommandExecutor(commandName, genNamespace, serializerSubNamespace, reqSchemaType, respSchemaType, normalResultName, normalResultSchema, errorResultName, errorResultSchema, isResponseNullable, isIdempotent, cacheability);
                    }

                    break;
                case "java":
                    if (generateClient)
                    {
                        yield return new JavaCommandInvoker(commandName, genNamespace, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Java), respSchemaType?.GetTypeName(TargetLanguage.Java));
                    }

                    if (generateServer)
                    {
                        yield return new JavaCommandExecutor(commandName, genNamespace, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Java), respSchemaType?.GetTypeName(TargetLanguage.Java));
                    }

                    break;
                case "python":
                    if (generateClient)
                    {
                        yield return new PythonCommandInvoker(commandName, genNamespace, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Python), respSchemaType?.GetTypeName(TargetLanguage.Python));
                    }

                    if (generateServer)
                    {
                        yield return new PythonCommandExecutor(commandName, genNamespace, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Python), respSchemaType?.GetTypeName(TargetLanguage.Python));
                    }

                    break;
                case "rust":
                    if (generateClient)
                    {
                        yield return new RustCommandInvoker(commandName, genNamespace, serializerEmptyType, reqSchemaType, respSchemaType, reqSchemaNamespace, respSchemaNamespace, normalResultName, normalResultSchema, normalResultNamespace, errorResultName, errorResultSchema, errorResultNamespace, isResponseNullable, doesCommandTargetExecutor);
                    }

                    if (generateServer)
                    {
                        yield return new RustCommandExecutor(commandName, genNamespace, serializerEmptyType, reqSchemaType, respSchemaType, reqSchemaNamespace, respSchemaNamespace, normalResultName, normalResultSchema, normalResultNamespace, errorResultName, errorResultSchema, errorResultNamespace, isResponseNullable, isIdempotent, cacheability, useSharedSubscription);
                    }

                    if (reqSchemaType is CodeName rustReqSchema)
                    {
                        yield return new RustSerialization(reqSchemaNamespace ?? genNamespace, genFormat, rustReqSchema, workingPath);
                    }

                    if (respSchemaType is CodeName rustRespSchema)
                    {
                        yield return new RustSerialization(respSchemaNamespace ?? genNamespace, genFormat, rustRespSchema, workingPath);
                    }

                    if (normalResultSchema != null)
                    {
                        yield return new RustSerialization(respSchemaNamespace ?? genNamespace, genFormat, normalResultSchema, workingPath);
                    }

                    break;
                case "c":
                    if (generateClient)
                    {
                        yield return new CCommandInvoker(modelId, commandName, commandTopic!, genNamespace, serviceName, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Independent), respSchemaType?.GetTypeName(TargetLanguage.Independent), normalizedVersionSuffix);
                    }

                    if (generateServer)
                    {
                        yield return new CCommandExecutor(modelId, commandName, commandTopic!, genNamespace, serviceName, serializerSubNamespace, serializerClassName, reqSchemaType?.GetTypeName(TargetLanguage.Independent), respSchemaType?.GetTypeName(TargetLanguage.Independent), normalizedVersionSuffix);
                    }

                    break;
                default:
                    throw GetLanguageNotRecognizedException(language);
            }

            cmdEnvoyInfos.Add(new CommandEnvoyInfo(commandName, reqSchemaType, respSchemaType, normalResultName, normalResultSchema, errorResultName, errorResultSchema, isRequestNullable, isResponseNullable));
        }