private void ResolveMember()

in Sharpmake/Resolver.cs [763:926]
146 lines of code
36 McCabe index (conditional complexity)

        private void ResolveMember(string objectPath, object obj, MemberInfo memberInfo, object fallbackValue)
        {
            string memberPath;
            if (objectPath != null)
                memberPath = objectPath + _pathSeparator + memberInfo.Name;
            else
                memberPath = memberInfo.Name;

            if (GetResolveStatus(memberPath) == ResolveStatus.Resolved)
                return;

            if (memberInfo.MemberType == MemberTypes.Field)
            {
                FieldInfo fieldInfo = memberInfo as FieldInfo;
                object fieldValue = fieldInfo.GetValue(obj);

                if (fieldValue != null)
                {
                    if (fieldInfo.FieldType == typeof(string))
                    {
                        if (CanWriteFieldValue(fieldInfo))
                        {
                            SetResolving(memberPath);
                            string value = fieldValue as string;
                            bool wasChanged;
                            value = Resolve(value, fallbackValue, out wasChanged);
                            if (wasChanged)
                                fieldInfo.SetValue(obj, value);
                            SetResolved(memberPath);
                        }
                    }
                    else if (fieldInfo.FieldType == typeof(Strings))
                    {
                        if (CanWriteFieldValue(fieldInfo))
                        {
                            SetResolving(memberPath);
                            Strings values = fieldValue as Strings;

                            if (values != null)
                            {
                                foreach (string value in values.Values)
                                {
                                    bool wasChanged;
                                    string newValue = Resolve(value, fallbackValue, out wasChanged);
                                    if (wasChanged)
                                        values.UpdateValue(value, newValue);
                                }
                            }

                            SetResolved(memberPath);
                        }
                    }
                    else if (fieldValue is OrderableStrings)
                    {
                        if (CanWriteFieldValue(fieldInfo))
                        {
                            SetResolving(memberPath);
                            OrderableStrings values = fieldValue as OrderableStrings;

                            for (int i = 0; i < values.Count; ++i)
                            {
                                bool wasChanged;
                                string value = Resolve(values[i], fallbackValue, out wasChanged);
                                if (wasChanged)
                                    i = values.SetOrRemoveAtIndex(i, value);
                            }

                            SetResolved(memberPath);
                        }
                    }
                    else if (fieldValue is IList<string>)
                    {
                        if (CanWriteFieldValue(fieldInfo))
                        {
                            SetResolving(memberPath);
                            IList<string> values = fieldValue as IList<string>;

                            for (int i = 0; i < values.Count; ++i)
                            {
                                bool wasChanged;
                                string value = Resolve(values[i], fallbackValue, out wasChanged);
                                if (wasChanged)
                                    values[i] = value;
                            }

                            SetResolved(memberPath);
                        }
                    }
                    else if (fieldValue is HashSet<KeyValuePair<string, string>>)
                    {
                        if (CanWriteFieldValue(fieldInfo))
                        {
                            SetResolving(memberPath);

                            ResolveKeyPairHashSet((HashSet<KeyValuePair<string, string>>)fieldValue, fallbackValue);

                            SetResolved(memberPath);
                        }
                    }
                    else if (fieldInfo.FieldType.IsClass)
                    {
                        object memberObject = fieldValue;
                        ResolveObject(memberPath, memberObject, fallbackValue);
                    }
                }
            }
            else if (memberInfo.MemberType == MemberTypes.Property)
            {
                PropertyInfo propertyInfo = memberInfo as PropertyInfo;

                if (propertyInfo.CanRead)
                {
                    object propertyValue = propertyInfo.GetValue(obj, null);
                    if (propertyValue != null)
                    {
                        if (propertyInfo.PropertyType == typeof(string))
                        {
                            if (propertyInfo.CanWrite && propertyInfo.CanRead)
                            {
                                SetResolving(memberPath);
                                string value = propertyValue as string;
                                propertyInfo.SetValue(obj, Resolve(value, fallbackValue), null);
                                SetResolved(memberPath);
                            }
                        }
                        else if (propertyInfo.PropertyType == typeof(Strings))
                        {
                            SetResolving(memberPath);
                            Strings values = propertyValue as Strings;

                            foreach (string value in values.Values)
                            {
                                string newValue = Resolve(value, fallbackValue);
                                values.UpdateValue(value, newValue);
                            }

                            SetResolved(memberPath);
                        }
                        else if (propertyValue is IList<string>)
                        {
                            SetResolving(memberPath);
                            IList<string> values = propertyValue as IList<string>;

                            for (int i = 0; i < values.Count; ++i)
                                values[i] = Resolve(values[i], fallbackValue);

                            SetResolved(memberPath);
                        }
                        else if (propertyValue is HashSet<KeyValuePair<string, string>>)
                        {
                            SetResolving(memberPath);

                            ResolveKeyPairHashSet((HashSet<KeyValuePair<string, string>>)propertyValue, fallbackValue);

                            SetResolved(memberPath);
                        }
                        else if (propertyInfo.PropertyType.IsClass)
                        {
                            ResolveObject(memberPath, propertyValue, fallbackValue);
                        }
                    }
                }
            }
        }