InitializeStructMembers()

bool System.Xml.Serialization.XmlReflectionImporter.InitializeStructMembers ( StructMapping mapping, StructModel model, bool openModel, string typeName, RecursionLimiter limiter )

inlineprivate

Definition at line 771 of file XmlReflectionImporter.cs.

    {
        if (mapping.IsFullyInitialized)
        {
            return true;
        }
        if (model.TypeDesc.BaseTypeDesc != null)
        {
            TypeModel typeModel = _modelScope.GetTypeModel(model.Type.BaseType, directReference: false);
            if (!(typeModel is StructModel))
            {
                throw new NotSupportedException(System.SR.Format(System.SR.XmlUnsupportedInheritance, model.Type.BaseType.FullName));
            }
            StructMapping structMapping = ImportStructLikeMapping((StructModel)typeModel, mapping.Namespace, openModel, null, limiter);
            int num = limiter.DeferredWorkItems.IndexOf(structMapping);
            if (num >= 0)
            {
                if (!limiter.DeferredWorkItems.Contains(mapping))
                {
                    limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping));
                }
                int num2 = limiter.DeferredWorkItems.Count - 1;
                if (num < num2)
                {
                    ImportStructWorkItem value = limiter.DeferredWorkItems[num];
                    limiter.DeferredWorkItems[num] = limiter.DeferredWorkItems[num2];
                    limiter.DeferredWorkItems[num2] = value;
                }
                return false;
            }
            mapping.BaseMapping = structMapping;
            ICollection values = mapping.BaseMapping.LocalAttributes.Values;
            foreach (AttributeAccessor item in values)
            {
                AddUniqueAccessor(mapping.LocalAttributes, item);
            }
            if (!mapping.BaseMapping.HasExplicitSequence())
            {
                values = mapping.BaseMapping.LocalElements.Values;
                foreach (ElementAccessor item2 in values)
                {
                    AddUniqueAccessor(mapping.LocalElements, item2);
                }
            }
        }
        List<MemberMapping> list = new List<MemberMapping>();
        TextAccessor textAccessor = null;
        bool hasElements = false;
        bool flag = false;
        MemberInfo[] memberInfos = model.GetMemberInfos();
        foreach (MemberInfo memberInfo in memberInfos)
        {
            if (!(memberInfo is FieldInfo) && !(memberInfo is PropertyInfo))
            {
                continue;
            }
            XmlAttributes attributes = GetAttributes(memberInfo);
            if (attributes.XmlIgnore)
            {
                continue;
            }
            FieldModel fieldModel = model.GetFieldModel(memberInfo);
            if (fieldModel == null)
            {
                continue;
            }
            try
            {
                MemberMapping memberMapping = ImportFieldMapping(model, fieldModel, attributes, mapping.Namespace, limiter);
                if (memberMapping == null || (mapping.BaseMapping != null && mapping.BaseMapping.Declares(memberMapping, mapping.TypeName)))
                {
                    continue;
                }
                flag |= memberMapping.IsSequence;
                AddUniqueAccessor(memberMapping, mapping.LocalElements, mapping.LocalAttributes, flag);
                if (memberMapping.Text != null)
                {
                    if (!memberMapping.Text.Mapping.TypeDesc.CanBeTextValue && memberMapping.Text.Mapping.IsList)
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlIllegalTypedTextAttribute, typeName, memberMapping.Text.Name, memberMapping.Text.Mapping.TypeDesc.FullName));
                    }
                    if (textAccessor != null)
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlIllegalMultipleText, model.Type.FullName));
                    }
                    textAccessor = memberMapping.Text;
                }
                if (memberMapping.Xmlns != null)
                {
                    if (mapping.XmlnsMember != null)
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlMultipleXmlns, model.Type.FullName));
                    }
                    mapping.XmlnsMember = memberMapping;
                }
                if (memberMapping.Elements != null && memberMapping.Elements.Length != 0)
                {
                    hasElements = true;
                }
                list.Add(memberMapping);
            }
            catch (Exception ex)
            {
                if (ex is OutOfMemoryException)
                {
                    throw;
                }
                throw CreateMemberReflectionException(fieldModel, ex);
            }
        }
        mapping.SetContentModel(textAccessor, hasElements);
        if (flag)
        {
            Hashtable hashtable = new Hashtable();
            for (int j = 0; j < list.Count; j++)
            {
                MemberMapping memberMapping2 = list[j];
                if (memberMapping2.IsParticle)
                {
                    if (!memberMapping2.IsSequence)
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlSequenceInconsistent, "Order", memberMapping2.Name));
                    }
                    if (hashtable[memberMapping2.SequenceId] != null)
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlSequenceUnique, memberMapping2.SequenceId.ToString(CultureInfo.InvariantCulture), "Order", memberMapping2.Name));
                    }
                    hashtable[memberMapping2.SequenceId] = memberMapping2;
                }
            }
            list.Sort(new MemberMappingComparer());
        }
        mapping.Members = list.ToArray();
        if (mapping.BaseMapping == null)
        {
            mapping.BaseMapping = GetRootMapping();
        }
        if (mapping.XmlnsMember != null && mapping.BaseMapping.HasXmlnsMember)
        {
            throw new InvalidOperationException(System.SR.Format(System.SR.XmlMultipleXmlns, model.Type.FullName));
        }
        IncludeTypes(model.Type, limiter);
        _typeScope.AddTypeMapping(mapping);
        if (openModel)
        {
            mapping.IsOpenModel = true;
        }
        return true;
    }

References System.Xml.Serialization.XmlReflectionImporter._modelScope, System.Xml.Serialization.XmlReflectionImporter._typeScope, System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.Xml.Serialization.TypeScope.AddTypeMapping(), System.Xml.Serialization.XmlReflectionImporter.AddUniqueAccessor(), System.Collections.Generic.Dictionary< TKey, TValue >.Contains(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Xml.Serialization.XmlReflectionImporter.CreateMemberReflectionException(), System.Xml.Dictionary, System.SR.Format(), System.Xml.Serialization.XmlReflectionImporter.GetAttributes(), System.Xml.Serialization.XmlReflectionImporter.GetRootMapping(), System.Xml.Serialization.ModelScope.GetTypeModel(), System.Xml.Serialization.XmlReflectionImporter.ImportFieldMapping(), System.Xml.Serialization.XmlReflectionImporter.ImportStructLikeMapping(), System.Xml.Serialization.XmlReflectionImporter.IncludeTypes(), System.Globalization.CultureInfo.InvariantCulture, System.item, System.list, System.value, System.Collections.Generic.Dictionary< TKey, TValue >.Values, System.values, System.Xml.Serialization.XmlAttributes.XmlIgnore, System.SR.XmlIllegalMultipleText, System.SR.XmlIllegalTypedTextAttribute, System.SR.XmlMultipleXmlns, System.SR.XmlSequenceInconsistent, System.SR.XmlSequenceUnique, and System.SR.XmlUnsupportedInheritance.

Referenced by System.Xml.Serialization.XmlReflectionImporter.ImportStructLikeMapping().