private void ApplyInheritedTypeMap(TypeMap inheritedTypeMap)
        {
            foreach (var inheritedMappedProperty in inheritedTypeMap.PropertyMaps.Where(m => m.IsMapped))
            {
                var conventionPropertyMap = GetPropertyMap(inheritedMappedProperty);

                if (conventionPropertyMap != null)
                {
                    conventionPropertyMap.ApplyInheritedPropertyMap(inheritedMappedProperty);
                }
                else
                {
                    AddPropertyMap(new PropertyMap(inheritedMappedProperty, this));
                }
            }
            _beforeMapActions.UnionWith(inheritedTypeMap._beforeMapActions);
            _afterMapActions.UnionWith(inheritedTypeMap._afterMapActions);
            var notOverridenSourceConfigs =
                inheritedTypeMap.SourceMemberConfigs.Where(
                    baseConfig => SourceMemberConfigs.All(derivedConfig => derivedConfig.SourceMember != baseConfig.SourceMember)).ToList();

            notOverridenSourceConfigs.ForEach(AddSourceMemberConfig);
            var notOverridenPathMaps = NotOverridenPathMaps(inheritedTypeMap);

            notOverridenPathMaps.ForEach(AddPathMap);
            _valueTransformerConfigs.InsertRange(0, inheritedTypeMap._valueTransformerConfigs);
        }
        public string[] GetUnmappedPropertyNames()
        {
            var autoMappedProperties = GetPropertyNames(PropertyMaps);

            IEnumerable <string> properties;

            if (ConfiguredMemberList == MemberList.Destination)
            {
                properties = DestinationTypeDetails.PublicWriteAccessors
                             .Select(p => p.Name)
                             .Except(autoMappedProperties)
                             .Except(PathMaps.Select(p => p.MemberPath.First.Name));
            }
            else
            {
                var redirectedSourceMembers = MemberMaps
                                              .Where(pm => pm.IsMapped && pm.SourceMember != null && pm.SourceMember.Name != pm.DestinationName)
                                              .Select(pm => pm.SourceMember.Name);

                var ignoredSourceMembers = SourceMemberConfigs
                                           .Where(smc => smc.IsIgnored())
                                           .Select(pm => pm.SourceMember.Name);

                properties = SourceTypeDetails.PublicReadAccessors
                             .Select(p => p.Name)
                             .Except(autoMappedProperties)
                             .Except(redirectedSourceMembers)
                             .Except(ignoredSourceMembers);
            }

            return(properties.Where(memberName => !Profile.GlobalIgnores.Any(memberName.StartsWith)).ToArray());

            string GetPropertyName(PropertyMap pm) => ConfiguredMemberList == MemberList.Destination
                ? pm.DestinationName
                : pm.SourceMember != null
                    ? pm.SourceMember.Name
                    : pm.DestinationName;

            string[] GetPropertyNames(IEnumerable <PropertyMap> propertyMaps) => propertyMaps.Where(pm => pm.IsMapped).Select(GetPropertyName).ToArray();
        }