CreateEntityReference() public method

public CreateEntityReference ( String name ) : XmlEntityReference
name String
return XmlEntityReference
		public void ChildNodes ()
		{
			XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE root [<!ENTITY ent 'ent-value'><!ENTITY el '<foo>hoge</foo><bar/>'>]><root/>",
				XmlNodeType.Document, null);
			XmlDocument doc = new XmlDocument ();

			doc.Load (xtr);
			XmlEntityReference ent = doc.CreateEntityReference ("ent");
			// ChildNodes are not added yet.
			AssertNull (ent.FirstChild);
			doc.DocumentElement.AppendChild (ent);
			// ChildNodes are added here.
			AssertNotNull (ent.FirstChild);

			ent = doc.CreateEntityReference ("foo");
			AssertNull (ent.FirstChild);
			// Entity value is empty when the matching DTD entity 
			// node does not exist.
			doc.DocumentElement.AppendChild (ent);
			AssertNotNull (ent.FirstChild);

			AssertEquals (String.Empty, ent.FirstChild.Value);

			ent = doc.CreateEntityReference ("el");
			AssertEquals ("", ent.InnerText);
			doc.DocumentElement.AppendChild (ent);
			AssertEquals ("<foo>hoge</foo><bar />", ent.InnerXml);
			AssertEquals ("hoge", ent.InnerText);
			AssertEquals (XmlNodeType.Element, ent.FirstChild.NodeType);
		}
        private XmlAttribute LoadAttributeNode()
        {
            Debug.Assert(reader.NodeType == XmlNodeType.Attribute);

            XmlReader r = reader;

            if (r.IsDefault)
            {
                return(LoadDefaultAttribute());
            }

            XmlAttribute   attr       = doc.CreateAttribute(r.Prefix, r.LocalName, r.NamespaceURI);
            IXmlSchemaInfo schemaInfo = r.SchemaInfo;

            if (schemaInfo != null)
            {
                attr.XmlName = doc.AddAttrXmlName(attr.Prefix, attr.LocalName, attr.NamespaceURI, schemaInfo);
            }
            while (r.ReadAttributeValue())
            {
                XmlNode node;
                switch (r.NodeType)
                {
                case XmlNodeType.Text:
                    node = doc.CreateTextNode(r.Value);
                    break;

                case XmlNodeType.EntityReference:
                    node = doc.CreateEntityReference(r.LocalName);
                    if (r.CanResolveEntity)
                    {
                        r.ResolveEntity();
                        LoadAttributeValue(node, false);
                        // Code internally relies on the fact that an EntRef nodes has at least one child (even an empty text node). Ensure that this holds true,
                        // if the reader does not present any children for the ent-ref
                        if (node.FirstChild == null)
                        {
                            node.AppendChildForLoad(doc.CreateTextNode(string.Empty), doc);
                        }
                    }
                    break;

                default:
                    throw UnexpectedNodeType(r.NodeType);
                }
                Debug.Assert(node != null);
                attr.AppendChildForLoad(node, doc);
            }

            return(attr);
        }
        public override void WriteEntityRef(string name)
        {
            VerifyState(Method.WriteEntityRef);
            XmlNode node = document.CreateEntityReference(name);

            AddChild(node, write);
        }
示例#4
0
        public override void WriteEntityRef(string name)
        {
            VerifyState(Method.WriteEntityRef);
            XmlNode node = _document.CreateEntityReference(name);

            AddChild(node, _write);
            // REVIEW: the namespace scope is incorrect(?) unless write == null
        }
		public void WriteTo ()
		{
			XmlDocument doc = new XmlDocument();
			doc.LoadXml("<root/>");
			XmlEntityReference er = doc.CreateEntityReference("foo");
			doc.DocumentElement.AppendChild(er);
			AssertEquals ("Name", "foo", er.Name);
			AssertEquals ("WriteTo", "<root>&foo;</root>", doc.DocumentElement.OuterXml);
		}
示例#6
0
        private XmlEntityReference LoadEntityReferenceNode()
        {
            Debug.Assert(reader.NodeType == XmlNodeType.EntityReference);

            XmlEntityReference eref = doc.CreateEntityReference(reader.Name);

            if (reader.CanResolveEntity)
            {
                reader.ResolveEntity();
                LoadChildren(eref);
                // Code internally relies on the fact that an EntRef nodes has at least one child (even an empty text node). Ensure that this holds true,
                // if the reader does not present any children for the ent-ref
                if (eref.LastChild == null)
                {
                    eref.AppendChild(doc.CreateTextNode(""));
                }
            }
            return(eref);
        }
示例#7
0
        /// <summary>
        /// Creates a System.Xml.XmlEntityReference node.
        /// </summary>
        /// <param name="name">The name of the entity reference</param>
        public override void WriteEntityRef(string name)
        {
            if (state == WriteState.Element)
            {
                state = WriteState.Content;
            }
            XmlNode n = current;

            if (state == WriteState.Attribute)
            {
                n = ca;
            }
            else if (state != WriteState.Content)
            {
                throw new InvalidOperationException("Invalid state '" + WriteState.ToString() + "' for entity reference");
            }
            n.AppendChild(owner.CreateEntityReference(name));
        }
示例#8
0
        private void WriteStyle(XmlDocument doc, XmlElement me, object o)
        {
            if (o.GetType() != typeof(SvgStyle))
            {
                me.SetAttribute("style", doc.NamespaceURI, o.ToString());
                return;
            }

            SvgStyle style = (SvgStyle)o;

            /*
            foreach(string s in style.Keys)
            {
                me.SetAttribute(s, doc.NamespaceURI, style.Get(s).ToString());
            }
            */

            me.SetAttribute("style", doc.NamespaceURI, style.ToString());

            doc.CreateEntityReference("pingu");
        }
示例#9
0
 public override void WriteEntityRef(string name)
 {
     WritePossiblyTopLevelNode(doc.CreateEntityReference(name), true);
 }
示例#10
0
        /// <summary>
        /// Used by CompressXML
        /// </summary>
        /// <param name="counts">Map of attribute to number of occurrences -- could be used to improve algorithm</param>
        /// <param name="entities">Map of attribute to entity name</param>
        /// <param name="doc"></param>
        /// <param name="el"></param>
        /// <param name="idx">Number that is incremented to provide new entity names</param>
        private static void RecCompXML(Hashtable counts, Hashtable entities, XmlDocument doc, XmlElement el, ref int idx)
        {
            ArrayList keys = new ArrayList();

            foreach(XmlAttribute att in el.Attributes)
            {
                //don't try to do anything with xmlns nodes.
                if (att.Name.IndexOf("xmlns") == -1)
                    keys.Add(att.Name);
            }

            foreach(string s in keys)
            {
                string val = el.Attributes[s].Value;

                if (counts[val] == null)
                {
                    counts[val] = 1;
                }
                else
                {
                    counts[val] = (int)counts[val] + 1;
                }

                if (val.Length > 30)
                {
                    string entname;

                    if(entities[val] == null)
                    {
                        idx += 1;
                        entname = "E"+idx.ToString();
                        entities[val] = entname;
                    }
                    else
                    {
                        entname = (string)entities[val];
                    }

                    XmlAttribute attr;

                    //xlinks are a special case at the moment as the .NET XML API requires whatever bit of code
                    //outputs a qualified name to *just magically happen to know* the URI that the prefix refers to.
                    if (s.IndexOf("xlink") == 0)
                    {
                        attr = doc.CreateAttribute(s, "http://www.w3.org/1999/xlink");
                    }
                    else
                    {
                        attr = doc.CreateAttribute(s);
                    }

                    attr.AppendChild(doc.CreateEntityReference(entname));
                    el.SetAttributeNode(attr);
                }

            }

            foreach(XmlNode ch in el.ChildNodes)
            {
                if (ch.GetType() == typeof(XmlElement))
                    RecCompXML(counts, entities, doc, (XmlElement)ch, ref idx);
            }
        }
示例#11
0
		protected internal override void Associate(XmlDocument/*!*/ document)
		{
			if (!IsAssociated)
			{
				XmlEntityReference = document.CreateEntityReference(_name);
			}
		}
示例#12
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);
		}
示例#13
0
        /// <summary>
        /// Used by CompressXML
        /// </summary>
        /// <param name="counts">Map of attribute to number of occurrences -- could be used to improve algorithm</param>
        /// <param name="entities">Map of attribute to entity name</param>
        /// <param name="doc"></param>
        /// <param name="el"></param>
        /// <param name="idx">Number that is incremented to provide new entity names</param>
        private static void RecCompXML(Hashtable counts, Hashtable entities, XmlDocument doc, XmlElement el, ref int idx)
        {
            ArrayList keys = new ArrayList();

            foreach(XmlAttribute att in el.Attributes)
            {
                keys.Add(att.Name);
            }

            foreach(string s in keys)
            {
                string val = el.Attributes[s].Value;

                if (counts[val] == null)
                {
                    counts[val] = 1;
                }
                else
                {
                    counts[val] = (int)counts[val] + 1;
                }

                if (val.Length > 30)
                {
                    string entname;

                    if(entities[val] == null)
                    {
                        idx += 1;
                        entname = "E"+idx.ToString();
                        entities[val] = entname;
                    }
                    else
                    {
                        entname = (string)entities[val];
                    }

                    XmlAttribute attr = doc.CreateAttribute(s);
                    attr.AppendChild(doc.CreateEntityReference(entname));
                    el.SetAttributeNode(attr);
                }

            }

            foreach(XmlNode ch in el.ChildNodes)
            {
                if (ch.GetType() == typeof(XmlElement))
                    RecCompXML(counts, entities, doc, (XmlElement)ch, ref idx);
            }
        }