Inheritance: XmlWrappingWriter
        private XmlWriter AddConformanceWrapper(XmlWriter baseWriter)
        {
            System.Xml.ConformanceLevel auto     = System.Xml.ConformanceLevel.Auto;
            XmlWriterSettings           settings = baseWriter.Settings;
            bool checkValues     = false;
            bool checkNames      = false;
            bool replaceNewLines = false;
            bool flag4           = false;

            if (settings == null)
            {
                if (this.newLineHandling == System.Xml.NewLineHandling.Replace)
                {
                    replaceNewLines = true;
                    flag4           = true;
                }
                if (this.checkCharacters)
                {
                    checkValues = true;
                    flag4       = true;
                }
            }
            else
            {
                if (this.conformanceLevel != settings.ConformanceLevel)
                {
                    auto  = this.ConformanceLevel;
                    flag4 = true;
                }
                if (this.checkCharacters && !settings.CheckCharacters)
                {
                    checkValues = true;
                    checkNames  = auto == System.Xml.ConformanceLevel.Auto;
                    flag4       = true;
                }
                if ((this.newLineHandling == System.Xml.NewLineHandling.Replace) && (settings.NewLineHandling == System.Xml.NewLineHandling.None))
                {
                    replaceNewLines = true;
                    flag4           = true;
                }
            }
            XmlWriter writer = baseWriter;

            if (flag4)
            {
                if (auto != System.Xml.ConformanceLevel.Auto)
                {
                    writer = new XmlWellFormedWriter(writer, this);
                }
                if (checkValues || replaceNewLines)
                {
                    writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, this.NewLineChars);
                }
            }
            if (!this.IsQuerySpecific || ((settings != null) && settings.IsQuerySpecific))
            {
                return(writer);
            }
            return(new QueryOutputWriterV1(writer, this));
        }
        private XmlWriter AddConformanceWrapper(XmlWriter baseWriter)
        {
            ConformanceLevel  confLevel          = ConformanceLevel.Auto;
            XmlWriterSettings baseWriterSettings = baseWriter.Settings;
            bool checkValues     = false;
            bool checkNames      = false;
            bool replaceNewLines = false;
            bool needWrap        = false;

            if (baseWriterSettings == null)
            {
                // assume the V1 writer already do all conformance checking;
                // wrap only if NewLineHandling == Replace or CheckCharacters is true
                if (_newLineHandling == NewLineHandling.Replace)
                {
                    replaceNewLines = true;
                    needWrap        = true;
                }
                if (_checkCharacters)
                {
                    checkValues = true;
                    needWrap    = true;
                }
            }
            else
            {
                if (_conformanceLevel != baseWriterSettings.ConformanceLevel)
                {
                    confLevel = this.ConformanceLevel;
                    needWrap  = true;
                }
                if (_checkCharacters && !baseWriterSettings.CheckCharacters)
                {
                    checkValues = true;
                    checkNames  = confLevel == ConformanceLevel.Auto;
                    needWrap    = true;
                }
                if (_newLineHandling == NewLineHandling.Replace &&
                    baseWriterSettings.NewLineHandling == NewLineHandling.None)
                {
                    replaceNewLines = true;
                    needWrap        = true;
                }
            }

            XmlWriter writer = baseWriter;

            if (needWrap)
            {
                if (confLevel != ConformanceLevel.Auto)
                {
                    writer = new XmlWellFormedWriter(writer, this);
                }
                if (checkValues || replaceNewLines)
                {
                    writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, this.NewLineChars);
                }
            }

            if (this.IsQuerySpecific && (baseWriterSettings == null || !baseWriterSettings.IsQuerySpecific))
            {
                // Create QueryOutputWriterV1 if CData sections or DocType need to be tracked
                writer = new QueryOutputWriterV1(writer, this);
            }

            return(writer);
        }
        private XmlWriter AddConformanceWrapper(XmlWriter baseWriter) {
            ConformanceLevel confLevel = ConformanceLevel.Auto;
            XmlWriterSettings baseWriterSettings = baseWriter.Settings;
            bool checkValues = false;
            bool checkNames = false;
            bool replaceNewLines = false;
            bool needWrap = false;

            if (baseWriterSettings == null) {
                // assume the V1 writer already do all conformance checking; 
                // wrap only if NewLineHandling == Replace or CheckCharacters is true
                if (this.newLineHandling == NewLineHandling.Replace) {
                    replaceNewLines = true;
                    needWrap = true;
                }
                if (this.checkCharacters) {
                    checkValues = true;
                    needWrap = true;
                }
            }
            else {
                if (this.conformanceLevel != baseWriterSettings.ConformanceLevel) {
                    confLevel = this.ConformanceLevel;
                    needWrap = true;
                }
                if (this.checkCharacters && !baseWriterSettings.CheckCharacters) {
                    checkValues = true;
                    checkNames = confLevel == ConformanceLevel.Auto;
                    needWrap = true;
                }
                if (this.newLineHandling == NewLineHandling.Replace &&
                     baseWriterSettings.NewLineHandling == NewLineHandling.None) {
                    replaceNewLines = true;
                    needWrap = true;
                }
            }

            XmlWriter writer = baseWriter;

            if (needWrap) {
                if (confLevel != ConformanceLevel.Auto) {
                    writer = new XmlWellFormedWriter(writer, this);
                }
                if (checkValues || replaceNewLines) {
                    writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, this.NewLineChars);
                }
            }

#if !SILVERLIGHT
            if (this.IsQuerySpecific && (baseWriterSettings == null || !baseWriterSettings.IsQuerySpecific)) {
                // Create QueryOutputWriterV1 if CData sections or DocType need to be tracked
                writer = new QueryOutputWriterV1(writer, this);
            }
#endif

            return writer;
        }
        private static XmlWriter AddConformanceWrapper(XmlWriter baseWriter, XmlWriterSettings baseWriterSettings, XmlWriterSettings settings) {
            ConformanceLevel confLevel = ConformanceLevel.Auto;
            bool checkValues = false;
            bool checkNames = false;
            bool replaceNewLines = false;
            bool needWrap = false;

            if (baseWriterSettings == null) {
                // assume the V1 writer already do all conformance checking; 
                // wrap only if NewLineHandling == Replace or CheckCharacters is true
                if (settings.NewLineHandling == NewLineHandling.Replace) {
                    replaceNewLines = true;
                    needWrap = true;
                }
                if (settings.CheckCharacters) {
                    checkValues = true;
                    needWrap = true;
                }
            }
            else {
                if (settings.ConformanceLevel != baseWriterSettings.ConformanceLevel) {
                    confLevel = settings.ConformanceLevel;
                    needWrap = true;
                }
                if (settings.CheckCharacters && !baseWriterSettings.CheckCharacters) {
                    checkValues = true;
                    checkNames = confLevel == ConformanceLevel.Auto;
                    needWrap = true;
                }
                if (settings.NewLineHandling == NewLineHandling.Replace &&
                     baseWriterSettings.NewLineHandling == NewLineHandling.None) {
                    replaceNewLines = true;
                    needWrap = true;
                }
            }

            if (needWrap) {
                XmlWriter writer = baseWriter;
                if (confLevel != ConformanceLevel.Auto) {
                    writer = new XmlWellFormedWriter(writer, settings);
                }
                if (checkValues || replaceNewLines) {
                    writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, settings.NewLineChars);
                }
                return writer;
            }
            else {
                return baseWriter;
            }
        }
Esempio n. 5
0
        private static XmlWriter AddConformanceWrapper(XmlWriter baseWriter, XmlWriterSettings baseWriterSettings, XmlWriterSettings settings)
        {
            ConformanceLevel confLevel       = ConformanceLevel.Auto;
            bool             checkValues     = false;
            bool             checkNames      = false;
            bool             replaceNewLines = false;
            bool             needWrap        = false;

            if (baseWriterSettings == null)
            {
                // assume the V1 writer already do all conformance checking;
                // wrap only if NewLineHandling == Replace or CheckCharacters is true
                if (settings.NewLineHandling == NewLineHandling.Replace)
                {
                    replaceNewLines = true;
                    needWrap        = true;
                }
                if (settings.CheckCharacters)
                {
                    checkValues = true;
                    needWrap    = true;
                }
            }
            else
            {
                if (settings.ConformanceLevel != baseWriterSettings.ConformanceLevel)
                {
                    confLevel = settings.ConformanceLevel;
                    needWrap  = true;
                }
                if (settings.CheckCharacters && !baseWriterSettings.CheckCharacters)
                {
                    checkValues = true;
                    checkNames  = confLevel == ConformanceLevel.Auto;
                    needWrap    = true;
                }
                if (settings.NewLineHandling == NewLineHandling.Replace &&
                    baseWriterSettings.NewLineHandling == NewLineHandling.None)
                {
                    replaceNewLines = true;
                    needWrap        = true;
                }
            }

            if (needWrap)
            {
                XmlWriter writer = baseWriter;
                if (confLevel != ConformanceLevel.Auto)
                {
                    writer = new XmlWellFormedWriter(writer, settings);
                }
                if (checkValues || replaceNewLines)
                {
                    writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, settings.NewLineChars);
                }
                return(writer);
            }
            else
            {
                return(baseWriter);
            }
        }