Example #1
0
        //</Snippet5>

        //************************************************************************************
        //
        //  Add an element to the XML document at a specific location
        //  Takes a string that describes where the user wants the new node
        //  to be positioned. The string comes from a series of radio buttons in a UI.
        //  this method also accepts the XMLDocument in context. You have to use the
        //  this instance because it is the object that was used to generate the
        //  selectedBook XMLNode.
        //
        //************************************************************************************
        //</Snipppet9>
        public void InsertBookElement(XmlElement bookElement, string position, XmlNode selectedBook, bool validateNode, bool generateSchema)
        {
            XmlDocument doc = bookElement.OwnerDocument;

            string stringThatContainsNewline = bookElement.OuterXml;

            switch (position)
            {
            case Constants.positionTop:
                // Add newline characters and spaces to make XML more readable.
                XmlSignificantWhitespace sigWhiteSpace = doc.CreateSignificantWhitespace("\n  ");
                doc.DocumentElement.InsertBefore(sigWhiteSpace, doc.DocumentElement.FirstChild);
                doc.DocumentElement.InsertAfter(bookElement, doc.DocumentElement.FirstChild);
                break;

            case Constants.positionBottom:
                // Add newline characters to make XML more readable.
                XmlWhitespace whitespace   = doc.CreateWhitespace("  ");
                XmlNode       appendedNode = doc.DocumentElement.AppendChild(bookElement);
                doc.DocumentElement.InsertBefore(whitespace, appendedNode);
                sigWhiteSpace = doc.CreateSignificantWhitespace("\n");
                doc.DocumentElement.InsertAfter(sigWhiteSpace, appendedNode);
                break;

            case Constants.positionAbove:
                // Add newline characters to make XML more readable.
                XmlNode currNode = doc.DocumentElement.InsertBefore(bookElement, selectedBook);
                sigWhiteSpace = doc.CreateSignificantWhitespace("\n  ");
                doc.DocumentElement.InsertAfter(sigWhiteSpace, currNode);
                break;

            case Constants.positionBelow:
                // Add newline characters to make XML more readable.
                sigWhiteSpace = doc.CreateSignificantWhitespace("\n  ");
                XmlNode whiteSpaceNode = doc.DocumentElement.InsertAfter(sigWhiteSpace, selectedBook);
                doc.DocumentElement.InsertAfter(bookElement, whiteSpaceNode);
                break;

            default:
                doc.DocumentElement.AppendChild(bookElement);
                break;
            }

            if (validateNode)
            {
                validateXML(generateSchema, doc);
            }
        }
        private static XmlNode CreateNode(XmlDocument doc, XmlNodeType nodeType)
        {
            Assert.NotNull(doc);

            switch (nodeType)
            {
            case XmlNodeType.CDATA:
                return(doc.CreateCDataSection(@"&lt; &amp; <tag> < ! > & </tag> 	 "));

            case XmlNodeType.Comment:
                return(doc.CreateComment(@"comment"));

            case XmlNodeType.Element:
                return(doc.CreateElement("E"));

            case XmlNodeType.Text:
                return(doc.CreateTextNode("text"));

            case XmlNodeType.Whitespace:
                return(doc.CreateWhitespace(@"	  "));

            case XmlNodeType.SignificantWhitespace:
                return(doc.CreateSignificantWhitespace("	"));

            default:
                Assert.True(false, "Wrong XmlNodeType: '" + nodeType + "'");
                return(null);
            }
        }
Example #3
0
    public Sample()
    {
        XmlDocument doc = new XmlDocument();

        doc.LoadXml("<!-- Sample XML fragment -->" +
                    "<author xml:space='preserve'>" +
                    "<first-name>Eva</first-name>" +
                    "<last-name>Corets</last-name>" +
                    "</author>");


        Console.WriteLine("InnerText before...");
        Console.WriteLine(doc.DocumentElement.InnerText);

        // Add white space.
        currNode = doc.DocumentElement;
        XmlSignificantWhitespace sigws = doc.CreateSignificantWhitespace("\t");

        currNode.InsertAfter(sigws, currNode.FirstChild);

        Console.WriteLine();
        Console.WriteLine("InnerText after...");
        Console.WriteLine(doc.DocumentElement.InnerText);

        // Save and then display the file.
        doc.Save(filename);
        Console.WriteLine();
        Console.WriteLine("Reading file...");
        ReadFile(filename);
    }
Example #4
0
        private async Task Dump_Out_XML()
        {
            Debug.WriteLine("Debugging Dump...");

            XmlDocument outputXML = new XmlDocument();


            XmlElement rootElement = outputXML.CreateElement(string.Empty, "stations", string.Empty);

            outputXML.AppendChild(rootElement);

            XmlSignificantWhitespace sigws = outputXML.CreateSignificantWhitespace("\n\t");

            rootElement.InsertAfter(sigws, rootElement.FirstChild);

            foreach (Podcast thisOne in PodList.Items)
            {
                XmlElement stationElement = outputXML.CreateElement(string.Empty, "station", string.Empty);

                XmlElement stationNameElement = outputXML.CreateElement(string.Empty, "stationName", string.Empty);

                XmlText text1 = outputXML.CreateTextNode(thisOne.stationName);
                stationNameElement.AppendChild(text1);
                stationElement.AppendChild(stationNameElement);
                stationElement.InsertAfter(sigws, stationNameElement);

                XmlElement stationURLElement = outputXML.CreateElement(string.Empty, "stationURL", string.Empty);

                XmlText text2 = outputXML.CreateTextNode(thisOne.stationURL);
                stationURLElement.AppendChild(text2);
                stationElement.AppendChild(stationURLElement);
                stationElement.InsertAfter(sigws, stationURLElement);


                rootElement.AppendChild(stationElement);



                Debug.WriteLine(thisOne.stationName);
                Debug.WriteLine(thisOne.stationURL);
            }



            Debug.WriteLine(outputXML.InnerXml.ToString());

            StorageFolder PodBlasterFolder = await KnownFolders.MusicLibrary.GetFolderAsync("Podblaster");

            string XMLFilePath = PodBlasterFolder.Path + @"\stations.xml";

            StorageFile XMLFile = await PodBlasterFolder.GetFileAsync("stations.xml");

            await FileIO.WriteTextAsync(XMLFile, outputXML.InnerXml.ToString());

            Debug.WriteLine("Wrote out XML File!");
        }
Example #5
0
 public void XmlSignificantWhitespaceBadConstructor()
 {
     try {
         broken = document.CreateSignificantWhitespace("black");
     } catch (ArgumentException) {
         return;
     } catch (Exception) {
         Assert.Fail("Incorrect Exception thrown.");
     }
 }
        private void ProcessAppInfoDocMarkup(bool root)
        {
            //First time reader is positioned on AppInfo or Documentation element
            XmlNode currentNode = null;

            switch (reader.NodeType)
            {
            case XmlNodeType.Element:
                annotationNSManager.PushScope();
                currentNode = LoadElementNode(root);
                break;

            case XmlNodeType.Text:
                currentNode = dummyDocument.CreateTextNode(reader.Value);
                goto default;

            case XmlNodeType.SignificantWhitespace:
                currentNode = dummyDocument.CreateSignificantWhitespace(reader.Value);
                goto default;

            case XmlNodeType.CDATA:
                currentNode = dummyDocument.CreateCDataSection(reader.Value);
                goto default;

            case XmlNodeType.EntityReference:
                currentNode = dummyDocument.CreateEntityReference(reader.Name);
                goto default;

            case XmlNodeType.Comment:
                currentNode = dummyDocument.CreateComment(reader.Value);
                goto default;

            case XmlNodeType.ProcessingInstruction:
                currentNode = dummyDocument.CreateProcessingInstruction(reader.Name, reader.Value);
                goto default;

            case XmlNodeType.EndEntity:
                break;

            case XmlNodeType.Whitespace:
                break;

            case XmlNodeType.EndElement:
                annotationNSManager.PopScope();
                parentNode = parentNode.ParentNode;
                break;

            default:     //other possible node types: Document/DocType/DocumentFrag/Entity/Notation/Xmldecl cannot appear as children of xs:appInfo or xs:doc
                Debug.Assert(currentNode != null);
                Debug.Assert(parentNode != null);
                parentNode.AppendChild(currentNode);
                break;
            }
        }
Example #7
0
        public void GetReady()
        {
            document = new XmlDocument();
            document.LoadXml("<root><foo></foo></root>");
            XmlElement element = document.CreateElement("foo");

            whitespace = document.CreateSignificantWhitespace("\r\n");
            element.AppendChild(whitespace);

            doc2 = new XmlDocument();
        }
Example #8
0
        //[Fact] https://github.com/dotnet/corefx/issues/208
        public static void ImportSignificantWhitespace()
        {
            var whitespace   = "        \t";
            var tempDoc      = new XmlDocument();
            var nodeToImport = tempDoc.CreateSignificantWhitespace(whitespace);

            var xmlDocument = new XmlDocument();
            var node        = xmlDocument.ImportNode(nodeToImport, true);

            Assert.Equal(xmlDocument, node.OwnerDocument);
            Assert.Equal(XmlNodeType.SignificantWhitespace, node.NodeType);
            Assert.Equal(whitespace, node.Value);
        }
Example #9
0
        public static void ImportSignificantWhitespace()
        {
            var whitespace = "        \t";
            var tempDoc = new XmlDocument();
            var nodeToImport = tempDoc.CreateSignificantWhitespace(whitespace);

            var xmlDocument = new XmlDocument();
            var node = xmlDocument.ImportNode(nodeToImport, true);

            Assert.Equal(xmlDocument, node.OwnerDocument);
            Assert.Equal(XmlNodeType.SignificantWhitespace, node.NodeType);
            Assert.Equal(whitespace, node.Value);
        }
Example #10
0
        private void button1_Click(object sender, EventArgs e)
        {
            string      path     = Application.StartupPath + @"\sample.xml";
            XmlDocument doc      = new XmlDocument();
            XmlElement  root     = doc.CreateElement("root");
            XmlElement  fullname = doc.CreateElement("fullname");
            XmlElement  address  = doc.CreateElement("address");

            XmlText fullnametext = doc.CreateTextNode(textBox1.Text);
            XmlText street1      = doc.CreateTextNode(textBox2.Text);
            XmlText street2      = doc.CreateTextNode(textBox3.Text);
            XmlText city         = doc.CreateTextNode(textBox4.Text);
            XmlText state        = doc.CreateTextNode(textBox5.Text);
            XmlText country      = doc.CreateTextNode(textBox6.Text);

            XmlSignificantWhitespace sws1 = doc.CreateSignificantWhitespace("\r\n");
            XmlSignificantWhitespace sws2 = doc.CreateSignificantWhitespace("\r\n");
            XmlSignificantWhitespace sws3 = doc.CreateSignificantWhitespace("\r\n");
            XmlSignificantWhitespace sws4 = doc.CreateSignificantWhitespace("\r\n");
            XmlSignificantWhitespace sws5 = doc.CreateSignificantWhitespace("\r\n");

            fullname.AppendChild(fullnametext);

            address.AppendChild(street1);
            address.AppendChild(sws1);
            address.AppendChild(street2);
            address.AppendChild(sws2);
            address.AppendChild(city);
            address.AppendChild(sws3);
            address.AppendChild(state);
            address.AppendChild(sws4);
            address.AppendChild(country);
            address.AppendChild(sws5);

            doc.AppendChild(root);
            root.AppendChild(fullname);
            root.AppendChild(address);
            doc.Save(path);
        }
Example #11
0
        public void AsText_on_significant_whitespace_should_return_value()
        {
            var document = new XmlDocument();

            document.AppendChild(document.CreateElement("test"));
            var x = document.CreateElement("x");

            document.DocumentElement.AppendChild(x);
            x.AppendChild(document.CreateSignificantWhitespace(" "));
            var doc = new XDoc(document);

            Assert.AreEqual(" ", doc["x"][0].AsText);
        }
    // Test the construction of whitespace nodes.
    public void TestXmlSignificantWhitespaceConstruct()
    {
        // Valid significant whitespace strings.
        CheckProperties("Construct (1)",
                        doc.CreateSignificantWhitespace(null),
                        String.Empty, false);
        CheckProperties("Construct (2)",
                        doc.CreateSignificantWhitespace(String.Empty),
                        String.Empty, false);
        CheckProperties("Construct (3)",
                        doc.CreateSignificantWhitespace(" \f\t\r\n\v"),
                        " \f\t\r\n\v", false);

        // Invalid significant whitespace strings.
        try
        {
            doc.CreateWhitespace("abc");
            Fail("Construct (4)");
        }
        catch (ArgumentException)
        {
            // Success
        }
    }
Example #13
0
    // Test setting attributes via direct text node inserts.
    public void TestXmlAttributeInsert()
    {
        XmlAttribute attr;

        attr = doc.CreateAttribute("prefix", "foo", "uri");

        XmlText text1 = doc.CreateTextNode("hello");
        XmlText text2 = doc.CreateTextNode(" and goodbye");

        attr.AppendChild(text1);
        AssertEquals("Insert (1)", "hello", attr.Value);
        AssertEquals("Insert (2)", text1, attr.FirstChild);
        AssertEquals("Insert (3)", text1, attr.LastChild);

        attr.AppendChild(text2);
        AssertEquals("Insert (4)", "hello and goodbye", attr.Value);
        AssertEquals("Insert (5)", text1, attr.FirstChild);
        AssertEquals("Insert (6)", text2, attr.LastChild);

        // Entity references do not affect the combined value,
        // but they do affect the XML.
        XmlEntityReference entity = doc.CreateEntityReference("foo");

        attr.AppendChild(entity);
        AssertEquals("Insert (7)", "hello and goodbye", attr.Value);
        AssertEquals("Insert (8)",
                     "hello and goodbye&foo;", attr.InnerXml);

        // Cannot insert whitespace into attributes.
        try
        {
            attr.AppendChild(doc.CreateWhitespace("   "));
            Fail("Insert (9)");
        }
        catch (InvalidOperationException)
        {
            // Success
        }
        try
        {
            attr.AppendChild(doc.CreateSignificantWhitespace("   "));
            Fail("Insert (9)");
        }
        catch (InvalidOperationException)
        {
            // Success
        }
    }
Example #14
0
        public void AsText_on_element_concats_whitespace_text_significant_whitespace_and_CDATA()
        {
            var document = new XmlDocument();

            document.AppendChild(document.CreateElement("test"));
            var x = document.CreateElement("x");

            document.DocumentElement.AppendChild(x);
            x.AppendChild(document.CreateTextNode("foo"));
            x.AppendChild(document.CreateWhitespace(" "));
            x.AppendChild(document.CreateCDataSection("bar"));
            x.AppendChild(document.CreateSignificantWhitespace(" "));
            var doc = new XDoc(document);

            Assert.AreEqual("foo bar ", doc["x"].AsText);
        }
Example #15
0
        public void SignificantWhitespaceIgnored2()
        {
            // To make sure, create pure significant whitespace element
            // using XmlNodeReader (that does not have xml:space attribute
            // column).
            DataSet     ds  = new DataSet();
            XmlDocument doc = new XmlDocument();

            doc.AppendChild(doc.CreateElement("root"));
            doc.DocumentElement.AppendChild(doc.CreateSignificantWhitespace
                                                ("      \n\n"));
            XmlReader xr = new XmlNodeReader(doc);

            ds.InferXmlSchema(xr, null);
            DataSetAssertion.AssertDataSet("pure_whitespace", ds, "root", 0, 0);
        }
Example #16
0
    public static void Main()
    {
        XmlDocument doc = new XmlDocument();

        doc.LoadXml("<author xml:space='preserve'>" +
                    "<first-name>Eva</first-name>" +
                    "<last-name>Corets</last-name>" +
                    "</author>");

        Console.WriteLine("InnerText before...");
        Console.WriteLine(doc.DocumentElement.InnerText);

        // Add white space.
        XmlNode currNode = doc.DocumentElement;
        XmlSignificantWhitespace sigws = doc.CreateSignificantWhitespace("\t");

        currNode.InsertAfter(sigws, currNode.FirstChild);

        Console.WriteLine();
        Console.WriteLine("InnerText after...");
        Console.WriteLine(doc.DocumentElement.InnerText);
    }
Example #17
0
        public static XmlNode CreateNode(XmlDocument doc, XmlNodeType nodeType)
        {
            Assert.NotNull(doc);

            switch (nodeType)
            {
                case XmlNodeType.CDATA:
                    return doc.CreateCDataSection(@"&lt; &amp; <tag> < ! > & </tag> 	 ");
                case XmlNodeType.Comment:
                    return doc.CreateComment(@"comment");
                case XmlNodeType.Element:
                    return doc.CreateElement("E");
                case XmlNodeType.Text:
                    return doc.CreateTextNode("text");
                case XmlNodeType.Whitespace:
                    return doc.CreateWhitespace(@"	  ");
                case XmlNodeType.SignificantWhitespace:
                    return doc.CreateSignificantWhitespace("	");
                default:
                    throw new ArgumentException("Wrong XmlNodeType: '" + nodeType + "'");
            }
        }
Example #18
0
 public void InnerAndOuterXml()
 {
     whitespace = doc2.CreateSignificantWhitespace("\r\n\t ");
     Assert.AreEqual(String.Empty, whitespace.InnerXml);
     Assert.AreEqual("\r\n\t ", whitespace.OuterXml);
 }
Example #19
0
        protected override void projectItemGenerator_ProjectItemGenerated(object sender, ProjectItemGeneratedEventArgs e)
        {
            var name = e.ProjectItemName;

            if (name.StartsWith(Path.DirectorySeparatorChar))
            {
                name = name.Substring(1, name.Length - 1);
            }
            var pathsRelative = new List <string>();
            var paths         = new List <string>();

            paths.AddRange(_outputFolder.Split(Path.DirectorySeparatorChar));
            paths.AddRange(e.ProjectName.Split(Path.DirectorySeparatorChar));
            if (!e.ParentItemName.IsEmpty() && !e.ParentItemName.Contains("."))
            {
                paths.AddRange(e.ParentItemName.Split(Path.DirectorySeparatorChar));
                pathsRelative.AddRange(e.ParentItemName.Split(Path.DirectorySeparatorChar));
            }
            else if (!e.ParentItemName.IsEmpty() && e.ParentItemName.Contains("."))
            {
                var arr = e.ParentItemName.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries).ToList();
                if (arr.Count > 1)
                {
                    arr.RemoveAt(arr.Count - 1);
                    paths.AddRange(arr);
                    pathsRelative.AddRange(arr);
                }
            }
            paths.AddRange(name.Split(Path.DirectorySeparatorChar));

            pathsRelative.AddRange(name.Split(Path.DirectorySeparatorChar));
            var fileName = System.IO.Path.Combine(paths.ToArray());

            //On linux the pasrsing of an absolute path will leave the first element of "paths" as empty string
            //Prepend file with path separator to signify absolute path
            if (paths.Any() && paths.FirstOrDefault() == string.Empty && !fileName.StartsWith(Path.DirectorySeparatorChar))
            {
                fileName = Path.DirectorySeparatorChar + fileName;
            }

            var fileStateInfo = new Generator.Common.Util.FileStateInfo {
                FileName = fileName
            };

            if (!File.Exists(fileName) || e.Overwrite)
            {
                var folderName = new FileInfo(fileName).DirectoryName;
                //In case this is a parent nested file, do not try to create
                if (!File.Exists(folderName))
                {
                    Directory.CreateDirectory(folderName);
                    File.WriteAllText(fileName, e.ProjectItemContent);
                }
                else
                {
                    fileName = System.IO.Path.Combine(_outputFolder, e.ProjectName, name);
                    File.WriteAllText(fileName, e.ProjectItemContent);
                }
            }
            else
            {
                fileStateInfo.FileState = Generator.Common.Util.FileStateConstants.Skipped;
            }

            //Embed the file in the project if need be
            if (e.Properties.ContainsKey("BuildAction") && (int)e.Properties["BuildAction"] == 3)
            {
                var projectFileName = System.IO.Path.Combine(_outputFolder, e.ProjectName, $"{e.ProjectName}.csproj");
                if (File.Exists(projectFileName))
                {
                    var includeFile = System.IO.Path.Combine(pathsRelative.ToArray());

                    var document = new XmlDocument();
                    document.PreserveWhitespace = true;
                    document.Load(projectFileName);
                    var groups = document.DocumentElement.SelectNodes("ItemGroup");

                    //Ensure file is not already embedded
                    var checkFile = includeFile.Replace("/", @"\"); //in case linux
                    if (document.DocumentElement.SelectSingleNode($"ItemGroup/EmbeddedResource[@Include='{checkFile}']") == null)
                    {
                        var     whiteSpace  = "  ";
                        XmlNode targetGroup = null;
                        foreach (XmlElement g in groups)
                        {
                            //Find the first "ItemGroup" with a "EmbeddedResource" item
                            //This will be the one to which we add the new embedded file
                            if (g.SelectSingleNode("EmbeddedResource") != null)
                            {
                                if (g.FirstChild.NodeType == XmlNodeType.Whitespace)
                                {
                                    if (g.FirstChild.Value.Replace("\r", "").Replace("\n", "").Contains('\t'))
                                    {
                                        whiteSpace = "\t";
                                    }
                                }
                                targetGroup = g;
                                break;
                            }
                        }

                        //If there is no group create a new one
                        if (targetGroup == null)
                        {
                            targetGroup = document.DocumentElement.AppendChild(document.CreateElement("ItemGroup"));
                        }

                        //Add whitespace and the item
                        targetGroup.AppendChild(document.CreateSignificantWhitespace(whiteSpace));
                        var node = targetGroup.AppendChild(document.CreateElement("EmbeddedResource"));
                        var attr = node.Attributes.Append(document.CreateAttribute("Include"));
                        attr.Value = checkFile;
                        targetGroup.AppendChild(document.CreateSignificantWhitespace("\r\n" + whiteSpace));

                        document.Save(projectFileName);
                    }
                }
            }

            //Write Log
            Generator.Common.Logging.nHydrateLog.LogInfo("Project Item Generated: {0}", e.ProjectItemName);
            e.FileState = fileStateInfo.FileState;
            e.FullName  = fileStateInfo.FileName;
            this.OnProjectItemGenerated(sender, e);
        }
 public CreatorIssuer _0005(string config)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     return(new ValPropertyStruct(tagIssuer.CreateSignificantWhitespace(config)));
 }
Example #21
0
        void CopyNode(XmlDocument newDoc, XmlNode from, XmlNode toParent)
        {
            if (RemoveAll && from.NodeType != XmlNodeType.Element)
            {
                return;
            }

            XmlNode child       = null;
            bool    newLineNode = false;

            switch (from.NodeType)
            {
            case XmlNodeType.Element:
                newLineNode = true;
                if (RemoveNamespacesAndPrefixes)
                {
                    child = newDoc.CreateElement(from.LocalName);
                }
                else
                {
                    XmlElement e = from as XmlElement;
                    child = newDoc.CreateElement(e.Prefix, e.LocalName, e.NamespaceURI);
                }
                break;

            case XmlNodeType.Attribute: {
                if (RemoveAttributes)
                {
                    return;
                }

                XmlAttribute fromAttr = from as XmlAttribute;
                if (!fromAttr.Specified)
                {
                    return;
                }

                XmlAttribute a;

                if (RemoveNamespacesAndPrefixes)
                {
                    a = newDoc.CreateAttribute(fromAttr.LocalName);
                }
                else
                {
                    a = newDoc.CreateAttribute(fromAttr.Prefix, fromAttr.LocalName, fromAttr.NamespaceURI);
                }

                toParent.Attributes.Append(a);
                CopyNodes(newDoc, from, a);
                return;
            }

            case XmlNodeType.CDATA:
                newLineNode = true;
                child       = newDoc.CreateCDataSection((from as XmlCDataSection).Data);
                break;

            case XmlNodeType.Comment:
                if (RemoveWhiteSpace)
                {
                    return;
                }
                newLineNode = true;
                child       = newDoc.CreateComment((from as XmlComment).Data);
                break;

            case XmlNodeType.ProcessingInstruction:
                newLineNode = true;
                XmlProcessingInstruction pi = from as XmlProcessingInstruction;
                child = newDoc.CreateProcessingInstruction(pi.Target, pi.Data);
                break;

            case XmlNodeType.DocumentType:
                newLineNode = true;
                toParent.AppendChild(from.CloneNode(true));
                return;

            case XmlNodeType.EntityReference:
                child = newDoc.CreateEntityReference((from as XmlEntityReference).Name);
                break;

            case XmlNodeType.SignificantWhitespace:
                if (RemoveWhiteSpace)
                {
                    return;
                }
                child = newDoc.CreateSignificantWhitespace(from.Value);
                break;

            case XmlNodeType.Text:
                if (RemoveText)
                {
                    return;
                }
                newLineNode = true;
                child       = newDoc.CreateTextNode(from.Value);
                break;

            case XmlNodeType.Whitespace:
                if (RemoveWhiteSpace)
                {
                    return;
                }
                child = newDoc.CreateWhitespace(from.Value);
                break;

            case XmlNodeType.XmlDeclaration:
                newLineNode = true;
                XmlDeclaration d  = from as XmlDeclaration;
                XmlDeclaration d1 = newDoc.CreateXmlDeclaration(d.Version, d.Encoding, d.Standalone);
                newDoc.InsertBefore(d1, newDoc.DocumentElement);
                return;
            }
            if (NewLines && newLineNode && toParent.NodeType != XmlNodeType.Attribute)
            {
                XmlSignificantWhitespace s = newDoc.CreateSignificantWhitespace("\r\n");
                toParent.AppendChild(s);
            }
            toParent.AppendChild(child);
            CopyNodes(newDoc, from, child);
        }
Example #22
0
        private void MergeIntoDestination()
        {
            XmlNodeList nodes;
            var         levenshtein = new NormalizedLevenshtein();
            var         root        = _destDoc.DocumentElement;

            if (_replace)
            {
                nodes = root.SelectNodes("//xliff:trans-unit", _nsmgr);
            }
            else
            {
                nodes = root.SelectNodes("//xliff:trans-unit[not(xliff:target)]", _nsmgr);
            }

            foreach (XmlNode node in nodes)
            {
                var id = node.Attributes["id"].Value;
                if (_translations.ContainsKey(id))
                {
                    var source      = node.SelectSingleNode("xliff:source", _nsmgr);
                    var transSource = _translations[id].SelectSingleNode($"./xliff:source", _nsmgr);
                    var transTarget = _translations[id].SelectSingleNode($"./xliff:target", _nsmgr);

                    if (source.InnerText != transSource.InnerText)
                    {
                        var percentSimilar = Math.Round((1 - levenshtein.Distance(source.InnerText, transSource.InnerText)) * 100);
                        if (_verbose)
                        {
                            Console.WriteLine($"Sources mismatch in id='{id}' Similarity {percentSimilar}%.");
                            Console.WriteLine($" Source file='{transSource.InnerText}'");
                            Console.WriteLine($" Target file='{source.InnerText}'");
                        }
                        if (percentSimilar < _fuzzy)
                        {
                            if (_verbose)
                            {
                                Console.WriteLine($"Skipping");
                            }
                            continue;
                        }
                    }

                    if (_replace)
                    {
                        var oldTarget = node.SelectSingleNode("xliff:target", _nsmgr);
                        if (oldTarget != null)
                        {
                            node.RemoveChild(oldTarget);
                        }
                    }

                    if (source.NextSibling.Name != "#significant-whitespace")
                    {
                        XmlSignificantWhitespace sigws = _destDoc.CreateSignificantWhitespace("\n          ");
                        node.InsertAfter(sigws, source);
                    }
                    XmlNode target = _destDoc.ImportNode(transTarget, true);
                    node.InsertAfter(target, source.NextSibling);
                    if (target.NextSibling.Name != "#significant-whitespace")
                    {
                        XmlSignificantWhitespace sigws = _destDoc.CreateSignificantWhitespace("\n          ");
                        node.InsertAfter(sigws, target);
                    }
                }
            }
        }
Example #23
0
 /// <summary>
 /// Creates an System.Xml.XmlSignificantWhitespace node.
 /// </summary>
 /// <param name="text">The string must contain only the following characters #20; #10; #13; and #9;.</param>
 /// <returns>A new XmlSignificantWhitespace node.</returns>
 public XmlSignificantWhitespace CreateSignificantWhitespace(System.String text)
 {
     return(xmlDocument.CreateSignificantWhitespace(text));
 }
        private void LoadDocument()
        {
            bool       preserveWhitespace = false;
            XmlReader  r      = this.reader;
            XmlNode    parent = this.doc;
            XmlElement element;

            while (r.Read())
            {
                XmlNode node = null;
                switch (r.NodeType)
                {
                case XmlNodeType.Element:
                    bool fEmptyElement = r.IsEmptyElement;
                    element = doc.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);

                    AddToTable(element);
                    element.IsEmpty = fEmptyElement;
                    ReadAttributes(r, element);

                    if (!fEmptyElement)
                    {
                        parent.AppendChild(element);
                        parent = element;
                        continue;
                    }
                    node = element;
                    break;

                case XmlNodeType.EndElement:
                    if (parent.ParentNode == null)
                    {
                        // syntax error in document.
                        IXmlLineInfo li = (IXmlLineInfo)r;
                        throw new XmlException(string.Format(SR.UnexpectedToken,
                                                             "</" + r.LocalName + ">", li.LineNumber, li.LinePosition), null, li.LineNumber, li.LinePosition);
                    }
                    parent = parent.ParentNode;
                    continue;

                case XmlNodeType.EntityReference:
                    if (r.CanResolveEntity)
                    {
                        r.ResolveEntity();
                    }
                    continue;

                case XmlNodeType.EndEntity:
                    continue;

                case XmlNodeType.Attribute:
                    node = LoadAttributeNode();
                    break;

                case XmlNodeType.Text:
                    node = doc.CreateTextNode(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.SignificantWhitespace:
                    node = doc.CreateSignificantWhitespace(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.Whitespace:
                    if (preserveWhitespace)
                    {
                        node = doc.CreateWhitespace(r.Value);
                        AddToTable(node);
                        break;
                    }
                    else
                    {
                        continue;
                    }

                case XmlNodeType.CDATA:
                    node = doc.CreateCDataSection(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.XmlDeclaration:
                    node = LoadDeclarationNode();
                    break;

                case XmlNodeType.ProcessingInstruction:
                    node = doc.CreateProcessingInstruction(r.Name, r.Value);
                    AddToTable(node);
                    if (string.IsNullOrEmpty(this.xsltFileName) && r.Name == "xml-stylesheet")
                    {
                        string href = ParseXsltArgs(((XmlProcessingInstruction)node).Data);
                        if (!string.IsNullOrEmpty(href))
                        {
                            this.xsltFileName = href;
                        }
                    }
                    break;

                case XmlNodeType.Comment:
                    node = doc.CreateComment(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.DocumentType: {
                    string pubid = r.GetAttribute("PUBLIC");
                    string sysid = r.GetAttribute("SYSTEM");
                    node = doc.CreateDocumentType(r.Name, pubid, sysid, r.Value);
                    break;
                }

                default:
                    UnexpectedNodeType(r.NodeType);
                    break;
                }

                Debug.Assert(node != null);
                Debug.Assert(parent != null);
                if (parent != null)
                {
                    parent.AppendChild(node);
                }
            }
        }
Example #25
0
        /// <summary>
        /// Creates, updates and inserts a node.
        /// </summary>
        private void InsertNode(XmlNode anchor, IUpdateOperation updateOperation)
        {
            // create node according to type
            XmlNode newXmlNode;

            switch (GetNodeType())
            {
            case XmlNodeType.Attribute:
                newXmlNode = XmlDocument.CreateAttribute(Name, Namespace ?? string.Empty);
                break;

            case XmlNodeType.Element:
                newXmlNode = XmlDocument.CreateElement(Name, Namespace ?? string.Empty);
                break;

            case XmlNodeType.CData:
                newXmlNode = XmlDocument.CreateCDataSection(string.Empty);
                break;

            case XmlNodeType.Comment:
                newXmlNode = XmlDocument.CreateComment(string.Empty);
                break;

            case XmlNodeType.SignificantWhitespace:
                newXmlNode = XmlDocument.CreateSignificantWhitespace(string.Empty);
                break;

            case XmlNodeType.Text:
                newXmlNode = XmlDocument.CreateTextNode(string.Empty);
                break;

            case XmlNodeType.Whitespace:
                newXmlNode = XmlDocument.CreateWhitespace(string.Empty);
                break;

            default:
                // should not happen
                throw new ArgumentOutOfRangeException();
            }

            // update node with input
            updateOperation.Update(newXmlNode);

            // insert node relative to anchor
            if (newXmlNode is XmlAttribute)
            {
                var newXmlAttribute = (XmlAttribute)newXmlNode;
                switch (GetNodePosition())
                {
                case XmlNodePosition.Append:
                case XmlNodePosition.After:
                    if (anchor is XmlAttribute)
                    {
                        var xmlAttribute = (XmlAttribute)anchor;
                        if (xmlAttribute.OwnerElement != null)
                        {
                            xmlAttribute.OwnerElement.Attributes.InsertAfter(newXmlAttribute, xmlAttribute);
                        }
                    }
                    else if (anchor.Attributes != null)
                    {
                        anchor.Attributes.Append(newXmlAttribute);
                    }
                    break;

                case XmlNodePosition.Prepend:
                case XmlNodePosition.Before:
                    if (anchor is XmlAttribute)
                    {
                        var xmlAttribute = (XmlAttribute)anchor;
                        if (xmlAttribute.OwnerElement != null)
                        {
                            xmlAttribute.OwnerElement.Attributes.InsertBefore(newXmlAttribute, xmlAttribute);
                        }
                    }
                    else if (anchor.Attributes != null)
                    {
                        anchor.Attributes.Prepend(newXmlAttribute);
                    }
                    break;

                default:
                    // should not happen
                    throw new ArgumentOutOfRangeException();
                }
            }
            else
            {
                switch (GetNodePosition())
                {
                case XmlNodePosition.Append:
                    anchor.AppendChild(newXmlNode);
                    break;

                case XmlNodePosition.Prepend:
                    anchor.PrependChild(newXmlNode);
                    break;

                case XmlNodePosition.After:
                    if (anchor.ParentNode != null)
                    {
                        anchor.ParentNode.InsertAfter(newXmlNode, anchor);
                    }
                    break;

                case XmlNodePosition.Before:
                    if (anchor.ParentNode != null)
                    {
                        anchor.ParentNode.InsertBefore(newXmlNode, anchor);
                    }
                    break;

                default:
                    // should not happen
                    throw new ArgumentOutOfRangeException();
                }
            }
        }
Example #26
0
        private XmlNode LoadNode(bool skipOverWhitespace)
        {
            XmlReader      r      = _reader;
            XmlNode        parent = null;
            XmlElement     element;
            IXmlSchemaInfo schemaInfo;

            do
            {
                XmlNode node = null;
                switch (r.NodeType)
                {
                case XmlNodeType.Element:
                    bool fEmptyElement = r.IsEmptyElement;
                    element         = _doc.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);
                    element.IsEmpty = fEmptyElement;

                    if (r.MoveToFirstAttribute())
                    {
                        XmlAttributeCollection attributes = element.Attributes;
                        do
                        {
                            XmlAttribute attr = LoadAttributeNode();
                            attributes.Append(attr);     // special case for load
                        }while (r.MoveToNextAttribute());
                        r.MoveToElement();
                    }

                    // recursively load all children.
                    if (!fEmptyElement)
                    {
                        if (parent != null)
                        {
                            parent.AppendChildForLoad(element, _doc);
                        }
                        parent = element;
                        continue;
                    }
                    else
                    {
                        schemaInfo = r.SchemaInfo;
                        if (schemaInfo != null)
                        {
                            element.XmlName = _doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
                        }
                        node = element;
                        break;
                    }

                case XmlNodeType.EndElement:
                    if (parent == null)
                    {
                        return(null);
                    }
                    Debug.Assert(parent.NodeType == XmlNodeType.Element);
                    schemaInfo = r.SchemaInfo;
                    if (schemaInfo != null)
                    {
                        element = parent as XmlElement;
                        if (element != null)
                        {
                            element.XmlName = _doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
                        }
                    }
                    if (parent.ParentNode == null)
                    {
                        return(parent);
                    }
                    parent = parent.ParentNode;
                    continue;

                case XmlNodeType.EntityReference:
                    node = LoadEntityReferenceNode(false);
                    break;

                case XmlNodeType.EndEntity:
                    Debug.Assert(parent == null);
                    return(null);

                case XmlNodeType.Attribute:
                    node = LoadAttributeNode();
                    break;

                case XmlNodeType.Text:
                    node = _doc.CreateTextNode(r.Value);
                    break;

                case XmlNodeType.SignificantWhitespace:
                    node = _doc.CreateSignificantWhitespace(r.Value);
                    break;

                case XmlNodeType.Whitespace:
                    if (_preserveWhitespace)
                    {
                        node = _doc.CreateWhitespace(r.Value);
                        break;
                    }
                    else if (parent == null && !skipOverWhitespace)
                    {
                        // if called from LoadEntityReferenceNode, just return null
                        return(null);
                    }
                    else
                    {
                        continue;
                    }

                case XmlNodeType.CDATA:
                    node = _doc.CreateCDataSection(r.Value);
                    break;


                case XmlNodeType.XmlDeclaration:
                    node = LoadDeclarationNode();
                    break;

                case XmlNodeType.ProcessingInstruction:
                    node = _doc.CreateProcessingInstruction(r.Name, r.Value);
                    break;

                case XmlNodeType.Comment:
                    node = _doc.CreateComment(r.Value);
                    break;

                case XmlNodeType.DocumentType:
                    node = LoadDocumentTypeNode();
                    break;

                default:
                    throw UnexpectedNodeType(r.NodeType);
                }

                Debug.Assert(node != null);
                if (parent != null)
                {
                    parent.AppendChildForLoad(node, _doc);
                }
                else
                {
                    return(node);
                }
            }while (r.Read());

            // when the reader ended before full subtree is read, return whatever we have created so far
            if (parent != null)
            {
                while (parent.ParentNode != null)
                {
                    parent = parent.ParentNode;
                }
            }
            return(parent);
        }
Example #27
0
        private void ProcessAppInfoDocMarkup(bool root)
        {
            //First time reader is positioned on AppInfo or Documentation element
            XmlNode currentNode = null;

            switch (_reader.NodeType)
            {
            case XmlNodeType.Element:
                _annotationNSManager.PushScope();
                currentNode = LoadElementNode(root);
                //  Dev10 (TFS) #479761: The following code was to address the issue of where an in-scope namespace delaration attribute
                //      was not added when an element follows an empty element. This fix will result in persisting schema in a consistent form
                //      although it does not change the semantic meaning of the schema.
                //      Since it is as a breaking change and Dev10 needs to maintain the backward compatibility, this fix is being reverted.
                //  if (reader.IsEmptyElement) {
                //      annotationNSManager.PopScope();
                //  }
                break;

            case XmlNodeType.Text:
                currentNode = _dummyDocument.CreateTextNode(_reader.Value);
                goto default;

            case XmlNodeType.SignificantWhitespace:
                currentNode = _dummyDocument.CreateSignificantWhitespace(_reader.Value);
                goto default;

            case XmlNodeType.CDATA:
                currentNode = _dummyDocument.CreateCDataSection(_reader.Value);
                goto default;

            case XmlNodeType.EntityReference:
                currentNode = _dummyDocument.CreateEntityReference(_reader.Name);
                goto default;

            case XmlNodeType.Comment:
                currentNode = _dummyDocument.CreateComment(_reader.Value);
                goto default;

            case XmlNodeType.ProcessingInstruction:
                currentNode = _dummyDocument.CreateProcessingInstruction(_reader.Name, _reader.Value);
                goto default;

            case XmlNodeType.EndEntity:
                break;

            case XmlNodeType.Whitespace:
                break;

            case XmlNodeType.EndElement:
                _annotationNSManager.PopScope();
                _parentNode = _parentNode.ParentNode;
                break;

            default:     //other possible node types: Document/DocType/DocumentFrag/Entity/Notation/Xmldecl cannot appear as children of xs:appInfo or xs:doc
                Debug.Assert(currentNode != null);
                Debug.Assert(_parentNode != null);
                _parentNode.AppendChild(currentNode);
                break;
            }
        }
Example #28
0
        private static int Detokenize(Tuple <ArrayDiffKind, Token>[] tokens, int index, XmlElement current, XmlDocument doc)
        {
            for (; index < tokens.Length; ++index)
            {
                var token = tokens[index];
                switch (token.Item1)
                {
                case ArrayDiffKind.Same:
                case ArrayDiffKind.Added:
                    switch (token.Item2.Type)
                    {
                    case XmlNodeType.CDATA:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        current.AppendChild(doc.CreateCDataSection(token.Item2.Value));
                        break;

                    case XmlNodeType.Comment:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        current.AppendChild(doc.CreateComment(token.Item2.Value));
                        break;

                    case XmlNodeType.SignificantWhitespace:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        current.AppendChild(doc.CreateSignificantWhitespace(token.Item2.Value));
                        break;

                    case XmlNodeType.Text:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        current.AppendChild(doc.CreateTextNode(token.Item2.Value));
                        break;

                    case XmlNodeType.Whitespace:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        current.AppendChild(doc.CreateWhitespace(token.Item2.Value));
                        break;

                    case XmlNodeType.Element:
                        XmlElement next = doc.CreateElement(token.Item2.Value);
                        if (current == null)
                        {
                            doc.AppendChild(next);
                        }
                        else
                        {
                            current.AppendChild(next);
                        }
                        index = Detokenize(tokens, index + 1, next, doc);
                        break;

                    case XmlNodeType.Attribute:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }
                        string[] parts = token.Item2.Value.Split(new char[] { '=' }, 2);
                        current.SetAttribute(parts[0], parts[1]);
                        break;

                    case XmlNodeType.EndElement:

                        // nothing to do
                        break;

                    case XmlNodeType.None:
                        if (current == null)
                        {
                            throw new ArgumentNullException("current");
                        }

                        // ensure we're closing the intended element
                        if (token.Item2.Value != current.Name)
                        {
                            throw new InvalidOperationException(string.Format("mismatched element ending; found </{0}>, expected </{1}>", token.Item2.Value, current.Name));
                        }

                        // we're done with this sequence
                        return(index);

                    default:
                        throw new InvalidOperationException("unhandled node type: " + token.Item2.Type);
                    }
                    break;

                case ArrayDiffKind.Removed:

                    // ignore removed nodes
                    break;

                default:
                    throw new InvalidOperationException("invalid diff kind: " + token.Item1);
                }
            }
            if (current != null)
            {
                throw new InvalidOperationException("unexpected end of tokens");
            }
            return(index);
        }
Example #29
0
        private void DeserializeValue(
            JsonReader reader,
            XmlDocument document,
            XmlNamespaceManager manager,
            string propertyName,
            XmlNode currentNode)
        {
            switch (propertyName)
            {
            case TextName:
                currentNode.AppendChild(document.CreateTextNode(reader.Value.ToString()));
                break;

            case CDataName:
                currentNode.AppendChild(document.CreateCDataSection(reader.Value.ToString()));
                break;

            case WhitespaceName:
                currentNode.AppendChild(document.CreateWhitespace(reader.Value.ToString()));
                break;

            case SignificantWhitespaceName:
                currentNode.AppendChild(document.CreateSignificantWhitespace(reader.Value.ToString()));
                break;

            default:
                // processing instructions and the xml declaration start with ?
                if (propertyName[0] == '?')
                {
                    if (propertyName == DeclarationName)
                    {
                        string version    = null;
                        string encoding   = null;
                        string standalone = null;
                        while (reader.Read() && reader.TokenType != JsonToken.EndObject)
                        {
                            switch (reader.Value.ToString())
                            {
                            case "@version":
                                reader.Read();
                                version = reader.Value.ToString();
                                break;

                            case "@encoding":
                                reader.Read();
                                encoding = reader.Value.ToString();
                                break;

                            case "@standalone":
                                reader.Read();
                                standalone = reader.Value.ToString();
                                break;

                            default:
                                throw new JsonSerializationException(
                                          "Unexpected property name encountered while deserializing XmlDeclaration: "
                                          + reader.Value);
                            }
                        }

                        XmlDeclaration declaration = document.CreateXmlDeclaration(version, encoding, standalone);
                        currentNode.AppendChild(declaration);
                    }
                    else
                    {
                        XmlProcessingInstruction instruction =
                            document.CreateProcessingInstruction(propertyName.Substring(1), reader.Value.ToString());
                        currentNode.AppendChild(instruction);
                    }
                }
                else
                {
                    // deserialize xml element
                    bool   finishedAttributes  = false;
                    bool   finishedElement     = false;
                    string elementPrefix       = GetPrefix(propertyName);
                    var    attributeNameValues = new Dictionary <string, string>();

                    // a string token means the element only has a single text child
                    if (reader.TokenType != JsonToken.String &&
                        reader.TokenType != JsonToken.Null &&
                        reader.TokenType != JsonToken.Boolean &&
                        reader.TokenType != JsonToken.Integer &&
                        reader.TokenType != JsonToken.Float &&
                        reader.TokenType != JsonToken.Date)
                    {
                        // read properties until first non-attribute is encountered
                        while (!finishedAttributes && !finishedElement && reader.Read())
                        {
                            switch (reader.TokenType)
                            {
                            case JsonToken.PropertyName:
                                string attributeName = reader.Value.ToString();

                                if (attributeName[0] == '@')
                                {
                                    attributeName = attributeName.Substring(1);
                                    reader.Read();
                                    string attributeValue = reader.Value.ToString();
                                    attributeNameValues.Add(attributeName, attributeValue);

                                    string namespacePrefix;

                                    if (IsNamespaceAttribute(attributeName, out namespacePrefix))
                                    {
                                        manager.AddNamespace(namespacePrefix, attributeValue);
                                    }
                                }
                                else
                                {
                                    finishedAttributes = true;
                                }
                                break;

                            case JsonToken.EndObject:
                                finishedElement = true;
                                break;

                            default:
                                throw new JsonSerializationException(
                                          "Unexpected JsonToken: " + reader.TokenType);
                            }
                        }
                    }

                    // have to wait until attributes have been parsed before creating element
                    // attributes may contain namespace info used by the element
                    XmlElement element = (!string.IsNullOrEmpty(elementPrefix))
                            ? document.CreateElement(propertyName, manager.LookupNamespace(elementPrefix))
                            : document.CreateElement(propertyName);

                    currentNode.AppendChild(element);

                    // add attributes to newly created element
                    foreach (KeyValuePair <string, string> nameValue in attributeNameValues)
                    {
                        string attributePrefix = GetPrefix(nameValue.Key);

                        XmlAttribute attribute = (!string.IsNullOrEmpty(attributePrefix))
                                ? document.CreateAttribute(nameValue.Key, manager.LookupNamespace(attributePrefix))
                                : document.CreateAttribute(nameValue.Key);

                        attribute.Value = nameValue.Value;

                        element.SetAttributeNode(attribute);
                    }

                    if (reader.TokenType == JsonToken.String)
                    {
                        element.AppendChild(document.CreateTextNode(reader.Value.ToString()));
                    }
                    else if (reader.TokenType == JsonToken.Integer)
                    {
                        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
                    }
                    else if (reader.TokenType == JsonToken.Float)
                    {
                        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
                    }
                    else if (reader.TokenType == JsonToken.Boolean)
                    {
                        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
                    }
                    else if (reader.TokenType == JsonToken.Date)
                    {
                        element.AppendChild(document.CreateTextNode(XmlConvert.ToString((DateTime)reader.Value, DefaultDateTimeFormat)));
                    }
                    else if (reader.TokenType == JsonToken.Null)
                    {
                        // empty element. do nothing
                    }
                    else
                    {
                        // finished element will have no children to deserialize
                        if (!finishedElement)
                        {
                            manager.PushScope();

                            DeserializeNode(reader, document, manager, element);

                            manager.PopScope();
                        }
                    }
                }
                break;
            }
        }
Example #30
0
 public XmlSignificantWhitespace CreateSignificantWhitespace(string text)
 {
     return(_doc.CreateSignificantWhitespace(text));
 }
 public IXmlNode CreateSignificantWhitespace(string text)
 {
     return(new XmlNodeWrapper(_document.CreateSignificantWhitespace(text)));
 }
Example #32
0
        private void LoadDocument()
        {
            bool       preserveWhitespace = false;
            XmlReader  r      = this.reader;
            XmlNode    parent = this.doc;
            XmlElement element;

            while (r.Read())
            {
                XmlNode node = null;
                switch (r.NodeType)
                {
                case XmlNodeType.Element:
                    bool fEmptyElement = r.IsEmptyElement;
                    element = doc.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);
                    AddToTable(element);
                    element.IsEmpty = fEmptyElement;
                    ReadAttributes(r, element);

                    if (!fEmptyElement)
                    {
                        parent.AppendChild(element);
                        parent = element;
                        continue;
                    }
                    node = element;
                    if (!namespaceList.Contains(node.NamespaceURI))
                    {
                        namespaceList.Add(node.NamespaceURI);
                    }
                    break;

                case XmlNodeType.EndElement:
                    if (parent.ParentNode == null)
                    {
                        // syntax error in document.
                        IXmlLineInfo li = (IXmlLineInfo)r;
                        throw new XmlException(string.Format("Unexpected end tag '{0}' at line {1} column {2}",
                                                             r.LocalName, li.LineNumber, li.LinePosition), null, li.LineNumber, li.LinePosition);
                    }
                    parent = parent.ParentNode;
                    continue;

                case XmlNodeType.EntityReference:
                    if (r.CanResolveEntity)
                    {
                        r.ResolveEntity();
                    }
                    continue;

                case XmlNodeType.EndEntity:
                    continue;

                case XmlNodeType.Attribute:
                    node = LoadAttributeNode();
                    if (!namespaceList.Contains(node.NamespaceURI))
                    {
                        namespaceList.Add(node.NamespaceURI);
                    }
                    break;

                case XmlNodeType.Text:
                    node = doc.CreateTextNode(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.SignificantWhitespace:
                    node = doc.CreateSignificantWhitespace(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.Whitespace:
                    if (preserveWhitespace)
                    {
                        node = doc.CreateWhitespace(r.Value);
                        AddToTable(node);
                        break;
                    }
                    else
                    {
                        continue;
                    }

                case XmlNodeType.CDATA:
                    node = doc.CreateCDataSection(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.XmlDeclaration:
                    node = LoadDeclarationNode();
                    break;

                case XmlNodeType.ProcessingInstruction:
                    node = doc.CreateProcessingInstruction(r.Name, r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.Comment:
                    node = doc.CreateComment(r.Value);
                    AddToTable(node);
                    break;

                case XmlNodeType.DocumentType:
                    continue;

                default:
                    UnexpectedNodeType(r.NodeType);
                    break;
                }

                Debug.Assert(node != null);
                Debug.Assert(parent != null);
                if (parent != null)
                {
                    parent.AppendChild(node);
                }
            }
        }