XmlMapping.cs

namespace System.Xml.Serialization
{
    [global::__DynamicallyInvokable]
    public abstract class XmlMapping
    {
        private TypeScope scope;

        private bool generateSerializer;

        private bool isSoap;

        private ElementAccessor accessor;

        private string key;

        private bool shallow;

        private XmlMappingAccess access;

        internal ElementAccessor Accessor => accessor;

        internal TypeScope Scope => scope;

        [global::__DynamicallyInvokable]
        public string ElementName
        {
            [global::__DynamicallyInvokable]
            get
            {
                return System.Xml.Serialization.Accessor.UnescapeName(Accessor.Name);
            }
        }

        [global::__DynamicallyInvokable]
        public string XsdElementName
        {
            [global::__DynamicallyInvokable]
            get
            {
                return Accessor.Name;
            }
        }

        [global::__DynamicallyInvokable]
        public string Namespace
        {
            [global::__DynamicallyInvokable]
            get
            {
                return accessor.Namespace;
            }
        }

        internal bool GenerateSerializer
        {
            get
            {
                return generateSerializer;
            }
            set
            {
                generateSerializer = value;
            }
        }

        internal bool IsReadable => (access & XmlMappingAccess.Read) != XmlMappingAccess.None;

        internal bool IsWriteable => (access & XmlMappingAccess.Write) != XmlMappingAccess.None;

        internal bool IsSoap
        {
            get
            {
                return isSoap;
            }
            set
            {
                isSoap = value;
            }
        }

        internal string Key => key;

        internal XmlMapping(TypeScope scope, ElementAccessor accessor)
            : this(scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write)
        {
        }

        internal XmlMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access)
        {
            this.scope = scope;
            this.accessor = accessor;
            this.access = access;
            shallow = (scope == null);
        }

        [global::__DynamicallyInvokable]
        public void SetKey(string key)
        {
            SetKeyInternal(key);
        }

        internal void SetKeyInternal(string key)
        {
            this.key = key;
        }

        internal static string GenerateKey(Type type, XmlRootAttribute root, string ns)
        {
            if (root == null)
            {
                root = (XmlRootAttribute)XmlAttributes.GetAttr(type, typeof(XmlRootAttribute));
            }
            return type.FullName + ":" + ((root == null) ? string.Empty : root.Key) + ":" + ((ns == null) ? string.Empty : ns);
        }

        internal void CheckShallow()
        {
            if (shallow)
            {
                throw new InvalidOperationException(Res.GetString("XmlMelformMapping"));
            }
        }

        internal static bool IsShallow(XmlMapping[] mappings)
        {
            for (int i = 0; i < mappings.Length; i++)
            {
                if (mappings[i] == null || mappings[i].shallow)
                {
                    return true;
                }
            }
            return false;
        }
    }
}