XmlSchemaParticle.cs

using System.Xml.Serialization;

namespace System.Xml.Schema
{
    public abstract class XmlSchemaParticle : XmlSchemaAnnotated
    {
        [Flags]
        private enum Occurs
        {
            None = 0x0,
            Min = 0x1,
            Max = 0x2
        }

        private class EmptyParticle : XmlSchemaParticle
        {
            internal override bool IsEmpty => true;
        }

        private decimal minOccurs = decimal.One;

        private decimal maxOccurs = decimal.One;

        private Occurs flags;

        internal static readonly XmlSchemaParticle Empty = new EmptyParticle();

        [XmlAttribute("minOccurs")]
        public string MinOccursString
        {
            get
            {
                if ((flags & Occurs.Min) != 0)
                {
                    return XmlConvert.ToString(minOccurs);
                }
                return null;
            }
            set
            {
                if (value == null)
                {
                    minOccurs = decimal.One;
                    flags &= ~Occurs.Min;
                    return;
                }
                minOccurs = XmlConvert.ToInteger(value);
                if (minOccurs < decimal.Zero)
                {
                    throw new XmlSchemaException("Sch_MinOccursInvalidXsd", string.Empty);
                }
                flags |= Occurs.Min;
            }
        }

        [XmlAttribute("maxOccurs")]
        public string MaxOccursString
        {
            get
            {
                if ((flags & Occurs.Max) != 0)
                {
                    if (!(maxOccurs == decimal.MaxValue))
                    {
                        return XmlConvert.ToString(maxOccurs);
                    }
                    return "unbounded";
                }
                return null;
            }
            set
            {
                if (value == null)
                {
                    maxOccurs = decimal.One;
                    flags &= ~Occurs.Max;
                    return;
                }
                if (value == "unbounded")
                {
                    maxOccurs = decimal.MaxValue;
                }
                else
                {
                    maxOccurs = XmlConvert.ToInteger(value);
                    if (maxOccurs < decimal.Zero)
                    {
                        throw new XmlSchemaException("Sch_MaxOccursInvalidXsd", string.Empty);
                    }
                    if (maxOccurs == decimal.Zero && (flags & Occurs.Min) == Occurs.None)
                    {
                        minOccurs = default(decimal);
                    }
                }
                flags |= Occurs.Max;
            }
        }

        [XmlIgnore]
        public decimal MinOccurs
        {
            get
            {
                return minOccurs;
            }
            set
            {
                if (value < decimal.Zero || value != decimal.Truncate(value))
                {
                    throw new XmlSchemaException("Sch_MinOccursInvalidXsd", string.Empty);
                }
                minOccurs = value;
                flags |= Occurs.Min;
            }
        }

        [XmlIgnore]
        public decimal MaxOccurs
        {
            get
            {
                return maxOccurs;
            }
            set
            {
                if (value < decimal.Zero || value != decimal.Truncate(value))
                {
                    throw new XmlSchemaException("Sch_MaxOccursInvalidXsd", string.Empty);
                }
                maxOccurs = value;
                if (maxOccurs == decimal.Zero && (flags & Occurs.Min) == Occurs.None)
                {
                    minOccurs = default(decimal);
                }
                flags |= Occurs.Max;
            }
        }

        internal virtual bool IsEmpty => maxOccurs == decimal.Zero;

        internal bool IsMultipleOccurrence => maxOccurs > decimal.One;

        internal virtual string NameString => string.Empty;

        internal XmlQualifiedName GetQualifiedName()
        {
            XmlSchemaElement xmlSchemaElement = this as XmlSchemaElement;
            if (xmlSchemaElement != null)
            {
                return xmlSchemaElement.QualifiedName;
            }
            XmlSchemaAny xmlSchemaAny = this as XmlSchemaAny;
            if (xmlSchemaAny != null)
            {
                string @namespace = xmlSchemaAny.Namespace;
                @namespace = ((@namespace == null) ? string.Empty : @namespace.Trim());
                return new XmlQualifiedName("*", (@namespace.Length == 0) ? "##any" : @namespace);
            }
            return XmlQualifiedName.Empty;
        }
    }
}