private void ProcessMappings()

in SharpGen/Transform/TransformManager.cs [325:411]
85 lines of code
26 McCabe index (conditional complexity)

        private void ProcessMappings(CppElementFinder elementFinder, ConfigFile file)
        {
            // Perform all mappings from <mappings> tag
            foreach (var configRule in file.Mappings)
            {
                var ruleUsed = false;
                switch (configRule)
                {
                    case MappingRule {Enum: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppEnum>(mappingRule.Enum, mappingRule);
                        break;
                    case MappingRule {EnumItem: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppEnumItem>(mappingRule.EnumItem, mappingRule);
                        break;
                    case MappingRule {Struct: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppStruct>(mappingRule.Struct, mappingRule);
                        break;
                    case MappingRule {Field: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppField>(mappingRule.Field, mappingRule);
                        break;
                    case MappingRule {Interface: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppInterface>(mappingRule.Interface, mappingRule);
                        break;
                    case MappingRule {Function: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppFunction>(mappingRule.Function, mappingRule);
                        break;
                    case MappingRule {Method: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppMethod>(mappingRule.Method, mappingRule);
                        break;
                    case MappingRule {Parameter: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppParameter>(mappingRule.Parameter, mappingRule);
                        break;
                    case MappingRule {Element: { }} mappingRule:
                        ruleUsed = elementFinder.ExecuteRule<CppElement>(mappingRule.Element, mappingRule);
                        break;
                    case MappingRule {DocItem: { }} mappingRule:
                        DocLinker.AddOrUpdateDocLink(mappingRule.DocItem, mappingRule.MappingNameFinal);
                        ruleUsed = true;
                        break;
                    case RemoveRule {Enum: { }} removeRule:
                        ruleUsed = RemoveElements<CppEnum>(elementFinder, removeRule.Enum);
                        break;
                    case RemoveRule {EnumItem: { }} removeRule:
                        ruleUsed = RemoveElements<CppEnumItem>(elementFinder, removeRule.EnumItem);
                        break;
                    case RemoveRule {Struct: { }} removeRule:
                        ruleUsed = RemoveElements<CppStruct>(elementFinder, removeRule.Struct);
                        break;
                    case RemoveRule {Field: { }} removeRule:
                        ruleUsed = RemoveElements<CppField>(elementFinder, removeRule.Field);
                        break;
                    case RemoveRule {Interface: { }} removeRule:
                        ruleUsed = RemoveElements<CppInterface>(elementFinder, removeRule.Interface);
                        break;
                    case RemoveRule {Function: { }} removeRule:
                        ruleUsed = RemoveElements<CppFunction>(elementFinder, removeRule.Function);
                        break;
                    case RemoveRule {Method: { }} removeRule:
                        ruleUsed = RemoveElements<CppMethod>(elementFinder, removeRule.Method);
                        break;
                    case RemoveRule {Parameter: { }} removeRule:
                        ruleUsed = RemoveElements<CppParameter>(elementFinder, removeRule.Parameter);
                        break;
                    case RemoveRule {Element: { }} removeRule:
                        ruleUsed = RemoveElements<CppElement>(elementFinder, removeRule.Element);
                        break;
                    case ContextRule contextRule:
                        HandleContextRule(elementFinder, file, contextRule);
                        ruleUsed = true;
                        break;
                    case MoveRule moveRule:
                    {
                        if (moveRule.Struct != null)
                            StructTransform.MoveStructToInner(moveRule.Struct, moveRule.To);
                        else if (moveRule.Method != null)
                            InterfaceTransform.MoveMethodsToInnerInterface(moveRule.Method, moveRule.To, moveRule.Property, moveRule.Base);
                        ruleUsed = true;
                        break;
                    }
                }

                if (!ruleUsed)
                {
                    Logger.Warning(LoggingCodes.UnusedMappingRule, "Mapping rule [{0}] did not match any elements.", configRule);
                }
            }
        }