GetV1ConformanceLevel() статический приватный Метод

static private GetV1ConformanceLevel ( XmlReader reader ) : ConformanceLevel
reader XmlReader
Результат ConformanceLevel
Пример #1
0
        internal XmlReader AddConformanceWrapper(XmlReader baseReader)
        {
            XmlReaderSettings baseReaderSettings = baseReader.Settings;
            bool          checkChars             = false;
            bool          noWhitespace           = false;
            bool          noComments             = false;
            bool          noPIs    = false;
            DtdProcessing dtdProc  = (DtdProcessing)(-1);
            bool          needWrap = false;

            if (baseReaderSettings == null)
            {
#pragma warning disable 618

#if SILVERLIGHT
                // Starting from Windows phone 8.1 (TargetsAtLeast_Desktop_V4_5_1) we converge with the desktop behavior so we'll let the reader
                // not throw exception if has different conformance level than Auto.
                if (BinaryCompatibility.TargetsAtLeast_Desktop_V4_5_1)
                {
                    if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
                    {
                        throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
                    }
                }
                else if (this.conformanceLevel != ConformanceLevel.Auto)
                {
                    throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
                }
#else
                if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
                {
                    throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
                }
#endif

#if !SILVERLIGHT
                // get the V1 XmlTextReader ref
                XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
                if (v1XmlTextReader == null)
                {
                    XmlValidatingReader vr = baseReader as XmlValidatingReader;
                    if (vr != null)
                    {
                        v1XmlTextReader = (XmlTextReader)vr.Reader;
                    }
                }
#endif

                // assume the V1 readers already do all conformance checking;
                // wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
                if (this.ignoreWhitespace)
                {
                    WhitespaceHandling wh = WhitespaceHandling.All;
#if !SILVERLIGHT
                    // special-case our V1 readers to see if whey already filter whitespaces
                    if (v1XmlTextReader != null)
                    {
                        wh = v1XmlTextReader.WhitespaceHandling;
                    }
#endif
                    if (wh == WhitespaceHandling.All)
                    {
                        noWhitespace = true;
                        needWrap     = true;
                    }
                }
                if (this.ignoreComments)
                {
                    noComments = true;
                    needWrap   = true;
                }
                if (this.ignorePIs)
                {
                    noPIs    = true;
                    needWrap = true;
                }
                // DTD processing
                DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
#if !SILVERLIGHT
                if (v1XmlTextReader != null)
                {
                    baseDtdProcessing = v1XmlTextReader.DtdProcessing;
                }
#endif
                if ((this.dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
                    (this.dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse))
                {
                    dtdProc  = this.dtdProcessing;
                    needWrap = true;
                }
#pragma warning restore 618
            }
            else
            {
                if (this.conformanceLevel != baseReaderSettings.ConformanceLevel && this.conformanceLevel != ConformanceLevel.Auto)
                {
                    throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
                }
                if (this.checkCharacters && !baseReaderSettings.CheckCharacters)
                {
                    checkChars = true;
                    needWrap   = true;
                }
                if (this.ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace)
                {
                    noWhitespace = true;
                    needWrap     = true;
                }
                if (this.ignoreComments && !baseReaderSettings.IgnoreComments)
                {
                    noComments = true;
                    needWrap   = true;
                }
                if (this.ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions)
                {
                    noPIs    = true;
                    needWrap = true;
                }

                if ((this.dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
                    (this.dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse))
                {
                    dtdProc  = this.dtdProcessing;
                    needWrap = true;
                }
            }

            if (needWrap)
            {
                IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
                if (readerAsNSResolver != null)
                {
                    return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc));
                }
                else
                {
                    return(new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc));
                }
            }
            else
            {
                return(baseReader);
            }
        }
Пример #2
0
        internal XmlReader AddConformanceWrapper(XmlReader baseReader)
        {
            XmlReaderSettings baseReaderSettings = baseReader.Settings;
            bool          checkChars             = false;
            bool          noWhitespace           = false;
            bool          noComments             = false;
            bool          noPIs    = false;
            DtdProcessing dtdProc  = (DtdProcessing)(-1);
            bool          needWrap = false;

            if (baseReaderSettings == null)
            {
#pragma warning disable 618

                if (_conformanceLevel != ConformanceLevel.Auto && _conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
                {
                    throw new InvalidOperationException(SR.Format(SR.Xml_IncompatibleConformanceLevel, _conformanceLevel.ToString()));
                }

                // get the V1 XmlTextReader ref
                XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
                if (v1XmlTextReader == null)
                {
                    XmlValidatingReader vr = baseReader as XmlValidatingReader;
                    if (vr != null)
                    {
                        v1XmlTextReader = (XmlTextReader)vr.Reader;
                    }
                }

                // assume the V1 readers already do all conformance checking;
                // wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
                if (_ignoreWhitespace)
                {
                    WhitespaceHandling wh = WhitespaceHandling.All;
                    // special-case our V1 readers to see if whey already filter whitespaces
                    if (v1XmlTextReader != null)
                    {
                        wh = v1XmlTextReader.WhitespaceHandling;
                    }
                    if (wh == WhitespaceHandling.All)
                    {
                        noWhitespace = true;
                        needWrap     = true;
                    }
                }
                if (_ignoreComments)
                {
                    noComments = true;
                    needWrap   = true;
                }
                if (_ignorePIs)
                {
                    noPIs    = true;
                    needWrap = true;
                }
                // DTD processing
                DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
                if (v1XmlTextReader != null)
                {
                    baseDtdProcessing = v1XmlTextReader.DtdProcessing;
                }

                if ((_dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
                    (_dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse))
                {
                    dtdProc  = _dtdProcessing;
                    needWrap = true;
                }
#pragma warning restore 618
            }
            else
            {
                if (_conformanceLevel != baseReaderSettings.ConformanceLevel && _conformanceLevel != ConformanceLevel.Auto)
                {
                    throw new InvalidOperationException(SR.Format(SR.Xml_IncompatibleConformanceLevel, _conformanceLevel.ToString()));
                }
                if (_checkCharacters && !baseReaderSettings.CheckCharacters)
                {
                    checkChars = true;
                    needWrap   = true;
                }
                if (_ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace)
                {
                    noWhitespace = true;
                    needWrap     = true;
                }
                if (_ignoreComments && !baseReaderSettings.IgnoreComments)
                {
                    noComments = true;
                    needWrap   = true;
                }
                if (_ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions)
                {
                    noPIs    = true;
                    needWrap = true;
                }

                if ((_dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
                    (_dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse))
                {
                    dtdProc  = _dtdProcessing;
                    needWrap = true;
                }
            }

            if (needWrap)
            {
                IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
                if (readerAsNSResolver != null)
                {
                    return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc));
                }
                else
                {
                    return(new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc));
                }
            }
            else
            {
                return(baseReader);
            }
        }
Пример #3
0
        internal XmlReader AddConformanceWrapper(XmlReader baseReader)
        {
            XmlReaderSettings settings = baseReader.Settings;
            bool checkCharacters       = false;
            bool ignoreWhitespace      = false;
            bool ignoreComments        = false;
            bool ignorePis             = false;

            System.Xml.DtdProcessing dtdProcessing = ~System.Xml.DtdProcessing.Prohibit;
            bool flag5 = false;

            if (settings == null)
            {
                if ((this.conformanceLevel != System.Xml.ConformanceLevel.Auto) && (this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader)))
                {
                    throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", new object[] { this.conformanceLevel.ToString() }));
                }
                XmlTextReader reader = baseReader as XmlTextReader;
                if (reader == null)
                {
                    XmlValidatingReader reader2 = baseReader as XmlValidatingReader;
                    if (reader2 != null)
                    {
                        reader = (XmlTextReader)reader2.Reader;
                    }
                }
                if (this.ignoreWhitespace)
                {
                    WhitespaceHandling all = WhitespaceHandling.All;
                    if (reader != null)
                    {
                        all = reader.WhitespaceHandling;
                    }
                    if (all == WhitespaceHandling.All)
                    {
                        ignoreWhitespace = true;
                        flag5            = true;
                    }
                }
                if (this.ignoreComments)
                {
                    ignoreComments = true;
                    flag5          = true;
                }
                if (this.ignorePIs)
                {
                    ignorePis = true;
                    flag5     = true;
                }
                System.Xml.DtdProcessing parse = System.Xml.DtdProcessing.Parse;
                if (reader != null)
                {
                    parse = reader.DtdProcessing;
                }
                if (((this.dtdProcessing == System.Xml.DtdProcessing.Prohibit) && (parse != System.Xml.DtdProcessing.Prohibit)) || ((this.dtdProcessing == System.Xml.DtdProcessing.Ignore) && (parse == System.Xml.DtdProcessing.Parse)))
                {
                    dtdProcessing = this.dtdProcessing;
                    flag5         = true;
                }
            }
            else
            {
                if ((this.conformanceLevel != settings.ConformanceLevel) && (this.conformanceLevel != System.Xml.ConformanceLevel.Auto))
                {
                    throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", new object[] { this.conformanceLevel.ToString() }));
                }
                if (this.checkCharacters && !settings.CheckCharacters)
                {
                    checkCharacters = true;
                    flag5           = true;
                }
                if (this.ignoreWhitespace && !settings.IgnoreWhitespace)
                {
                    ignoreWhitespace = true;
                    flag5            = true;
                }
                if (this.ignoreComments && !settings.IgnoreComments)
                {
                    ignoreComments = true;
                    flag5          = true;
                }
                if (this.ignorePIs && !settings.IgnoreProcessingInstructions)
                {
                    ignorePis = true;
                    flag5     = true;
                }
                if (((this.dtdProcessing == System.Xml.DtdProcessing.Prohibit) && (settings.DtdProcessing != System.Xml.DtdProcessing.Prohibit)) || ((this.dtdProcessing == System.Xml.DtdProcessing.Ignore) && (settings.DtdProcessing == System.Xml.DtdProcessing.Parse)))
                {
                    dtdProcessing = this.dtdProcessing;
                    flag5         = true;
                }
            }
            if (!flag5)
            {
                return(baseReader);
            }
            IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;

            if (readerAsNSResolver != null)
            {
                return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, dtdProcessing));
            }
            return(new XmlCharCheckingReader(baseReader, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, dtdProcessing));
        }