// Check the "PopScope" method.
public void TestXmlNamespaceManagerPopScope()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("PopScope (1)", !ns.PopScope());
ns.PushScope();
Assert("PopScope (2)", ns.PopScope());
}
public void PopScopeMustKeepAddedInScope()
{
namespaceManager = new XmlNamespaceManager(new NameTable()); // clear
namespaceManager.AddNamespace("foo", "urn:foo"); // 0
namespaceManager.AddNamespace("bar", "urn:bar"); // 0
namespaceManager.PushScope(); // 1
namespaceManager.PushScope(); // 2
namespaceManager.PopScope(); // 2
namespaceManager.PopScope(); // 1
namespaceManager.PopScope(); // 0
Assert.AreEqual("urn:foo", namespaceManager.LookupNamespace("foo"));
Assert.AreEqual("urn:bar", namespaceManager.LookupNamespace("bar"));
}
public XmlNamespaceManager LoadNamespace(XmlDocument wDoc)
{
XmlNamespaceManager res = new XmlNamespaceManager(wDoc.NameTable);
res.PopScope();
XmlElement rNode = wDoc.DocumentElement;
string nStr;
foreach (XmlAttribute attr in rNode.Attributes)
{
nStr = attr.Name;
if (nStr.Contains("xmlns"))
{
if (nStr.Length == 5)
{
res.AddNamespace("ns", attr.Value); //!!
}
else
{
res.AddNamespace(nStr.Replace("xmlns:", ""), attr.Value);
}
}
}
return(res);
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
Dictionary <string, string> attributeNameValues = ReadAttributeElements(reader, manager);
string elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
IXmlElement element = CreateElement(propertyName, document, elementPrefix, manager);
currentNode.AppendChild(element);
// add attributes to newly created element
foreach (KeyValuePair <string, string> nameValue in attributeNameValues)
{
string attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);
IXmlNode attribute = (!string.IsNullOrEmpty(attributePrefix))
? document.CreateAttribute(nameValue.Key, manager.LookupNamespace(attributePrefix), nameValue.Value)
: document.CreateAttribute(nameValue.Key, 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)
{
DateTime d = (DateTime)reader.Value;
element.AppendChild(document.CreateTextNode(XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind))));
}
else if (reader.TokenType == JsonToken.Null)
{
// empty element. do nothing
}
else
{
// finished element will have no children to deserialize
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
DeserializeNode(reader, document, manager, element);
manager.PopScope();
}
}
}
public override bool Read()
{
var read = base.Read();
switch (base.NodeType)
{
case XmlNodeType.Element:
_nsManager.PushScope();
for (var go = BaseReader.MoveToFirstAttribute(); go; go = BaseReader.MoveToNextAttribute())
{
if (BaseReader.NamespaceURI != _xmlNsNamespace)
{
continue;
}
var prefix = GetNamespacePrefix();
// Only push if it's not already defined.
if (_nsManager.LookupNamespace(prefix) == null)
{
_nsManager.AddNamespace(prefix, Value);
}
}
if (BaseReader.HasAttributes)
{
BaseReader.MoveToElement();
}
break;
case XmlNodeType.EndElement:
_nsManager.PopScope();
break;
}
return(read);
}
/// <summary>
/// See <see cref="XmlReader.Read"/>.
/// </summary>
public override bool Read()
{
bool read = base.Read();
if (base.NodeType == XmlNodeType.Element)
{
nsManager.PushScope();
for (bool go = base.BaseReader.MoveToFirstAttribute(); go; go = base.BaseReader.MoveToNextAttribute())
{
if (base.BaseReader.NamespaceURI == xmlNsNamespace)
{
string prefix = GetNamespacePrefix();
// Only push if it's not already defined.
if (nsManager.LookupNamespace(prefix) == null)
{
nsManager.AddNamespace(prefix, Value);
}
}
}
// If it had attributes, we surely moved through all of them searching for namespaces
if (base.BaseReader.HasAttributes)
{
base.BaseReader.MoveToElement();
}
}
else if (base.NodeType == XmlNodeType.EndElement)
{
nsManager.PopScope();
}
return(read);
}
private void ProcessElement()
{
Push(elementName);
if (_isProcessContents)
{
_nsManager.PopScope();
}
context.ElementDecl = ThoroughGetElementDecl();
if (context.ElementDecl != null)
{
ValidateStartElement();
ValidateEndStartElement();
context.NeedValidateChildren = true;
context.ElementDecl.ContentValidator.InitValidation(context);
}
}
private static void SerializeElement(XmlWriter writer, XmlNamespaceManager manager, Element element)
{
if (WriteStartTag(writer, manager, element, out string ns))
{
manager.PushScope();
WriteAttributes(writer, manager, element);
// Add the default namespace (if there is one) here so that it
// takes precedence over other prefixes with the same namespace
if (ns != null)
{
manager.AddNamespace(string.Empty, ns);
}
WriteData(writer, element.InnerText);
// Write the child elements: serialized, children then unknown children.
WriteElements(writer, manager, element);
SerializeElements(writer, manager, element.Children);
SerializeElements(writer, manager, element.Orphans);
writer.WriteEndElement();
manager.PopScope();
}
}
private void CreateElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string elementName, XmlNamespaceManager manager, string elementPrefix, Dictionary <string, string> attributeNameValues)
{
IXmlElement newChild = this.CreateElement(elementName, document, elementPrefix, manager);
currentNode.AppendChild(newChild);
foreach (KeyValuePair <string, string> pair in attributeNameValues)
{
string qualifiedName = XmlConvert.EncodeName(pair.Key);
string prefix = MiscellaneousUtils.GetPrefix(pair.Key);
string text1 = manager.LookupNamespace(prefix);
if (text1 == null)
{
}
IXmlNode attribute = !string.IsNullOrEmpty(prefix) ? document.CreateAttribute(qualifiedName, string.Empty, pair.Value) : document.CreateAttribute(qualifiedName, pair.Value);
newChild.SetAttributeNode(attribute);
}
if (((reader.TokenType == JsonToken.String) || (reader.TokenType == JsonToken.Integer)) || (((reader.TokenType == JsonToken.Float) || (reader.TokenType == JsonToken.Boolean)) || (reader.TokenType == JsonToken.Date)))
{
string text = this.ConvertTokenToXmlValue(reader);
if (text != null)
{
newChild.AppendChild(document.CreateTextNode(text));
}
}
else if (reader.TokenType != JsonToken.Null)
{
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, newChild);
manager.PopScope();
}
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
}
}
// Note that this must be done *before* filtering nodes out
// by context node list.
private void FillMissingPrefixes(XmlNode n, XmlNamespaceManager nsmgr, ArrayList tmpList)
{
if (n.Prefix.Length == 0 && propagatedNss != null)
{
foreach (DictionaryEntry de in propagatedNss)
{
if ((string)de.Value == n.NamespaceURI)
{
n.Prefix = (string)de.Key;
break;
}
}
}
if (n.NodeType == XmlNodeType.Element && ((XmlElement)n).HasAttributes)
{
foreach (XmlAttribute a in n.Attributes)
{
if (a.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
nsmgr.AddNamespace(a.Prefix.Length == 0 ? String.Empty : a.LocalName, a.Value);
}
}
nsmgr.PushScope();
}
if (n.NamespaceURI.Length > 0 && nsmgr.LookupPrefix(n.NamespaceURI) == null)
{
tmpList.Add(CreateXmlns(n));
}
if (n.NodeType == XmlNodeType.Element && ((XmlElement)n).HasAttributes)
{
foreach (XmlAttribute a in n.Attributes)
{
if (a.NamespaceURI.Length > 0 && nsmgr.LookupNamespace(a.Prefix) == null)
{
tmpList.Add(CreateXmlns(a));
}
}
}
foreach (XmlAttribute a in tmpList)
{
((XmlElement)n).SetAttributeNode(a);
}
tmpList.Clear();
if (n.HasChildNodes)
{
for (XmlNode c = n.FirstChild; c != null; c = c.NextSibling)
{
if (c.NodeType == XmlNodeType.Element)
{
FillMissingPrefixes(c, nsmgr, tmpList);
}
}
}
nsmgr.PopScope();
}
private void CreateElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string elementName, XmlNamespaceManager manager, string elementPrefix, Dictionary <string, string> attributeNameValues)
{
IXmlElement xmlElement = this.CreateElement(elementName, document, elementPrefix, manager);
currentNode.AppendChild(xmlElement);
foreach (KeyValuePair <string, string> attributeNameValue in attributeNameValues)
{
string str = XmlConvert.EncodeName(attributeNameValue.Key);
string prefix = MiscellaneousUtils.GetPrefix(attributeNameValue.Key);
xmlElement.SetAttributeNode((!string.IsNullOrEmpty(prefix) ? document.CreateAttribute(str, manager.LookupNamespace(prefix) ?? string.Empty, attributeNameValue.Value) : document.CreateAttribute(str, attributeNameValue.Value)));
}
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer || reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Boolean || reader.TokenType == JsonToken.Date)
{
string xmlValue = this.ConvertTokenToXmlValue(reader);
if (xmlValue != null)
{
xmlElement.AppendChild(document.CreateTextNode(xmlValue));
return;
}
}
else if (reader.TokenType != JsonToken.Null)
{
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, xmlElement);
manager.PopScope();
}
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
}
}
void ValidateElement(XElement e)
{
XmlSchemaInfo si = addSchemaInfo ? new XmlSchemaInfo() : null;
string xsiType = null;
string xsiNil = null;
PushElement(e, ref xsiType, ref xsiNil);
IXmlLineInfo original = SaveLineInfo(e);
source = e;
validator.ValidateElement(e.Name.LocalName, e.Name.NamespaceName, si, xsiType, xsiNil, null, null);
ValidateAttributes(e);
validator.ValidateEndOfAttributes(si);
ValidateNodes(e);
validator.ValidateEndElement(si);
if (addSchemaInfo)
{
if (si.Validity == XmlSchemaValidity.Valid && si.IsDefault)
{
e.Value = GetDefaultValue(si.SchemaElement);
}
ReplaceSchemaInfo(e, si);
}
RestoreLineInfo(original);
namespaceManager.PopScope();
}
/// <summary>
/// Pops the context.
/// </summary>
/// <param name="nmgr">The NMGR.</param>
/// <param name="node">The node.</param>
private void PopContext(XmlNamespaceManager nmgr, XmlNode node)
{
if (node.NamespaceURI != String.Empty)
{
nmgr.PopScope();
prefixSequence--;
}
}
private void ShowAllNamespaces(XmlNamespaceManager nsmgr)
{
do
{
foreach (String prefix in nsmgr)
{
Console.WriteLine("Prefix={0}, Namespace={1}", prefix, nsmgr.LookupNamespace(prefix));
}
}while (nsmgr.PopScope());
}
private void CreateElement(
JsonReader reader,
IXmlDocument document,
IXmlNode currentNode,
string elementName,
XmlNamespaceManager manager,
string elementPrefix,
Dictionary <string, string> attributeNameValues)
{
IXmlElement element = this.CreateElement(elementName, document, elementPrefix, manager);
currentNode.AppendChild((IXmlNode)element);
if (attributeNameValues != null)
{
foreach (KeyValuePair <string, string> attributeNameValue in attributeNameValues)
{
string str = XmlConvert.EncodeName(attributeNameValue.Key);
string prefix = MiscellaneousUtils.GetPrefix(attributeNameValue.Key);
IXmlNode attribute = !string.IsNullOrEmpty(prefix)
? document.CreateAttribute(str, manager.LookupNamespace(prefix) ?? string.Empty, attributeNameValue.Value)
: document.CreateAttribute(str, attributeNameValue.Value);
element.SetAttributeNode(attribute);
}
}
switch (reader.TokenType)
{
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Date:
string xmlValue = this.ConvertTokenToXmlValue(reader);
if (xmlValue == null)
{
break;
}
element.AppendChild(document.CreateTextNode(xmlValue));
break;
case JsonToken.Null:
break;
case JsonToken.EndObject:
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
break;
default:
manager.PushScope();
this.DeserializeNode(reader, document, manager, (IXmlNode)element);
manager.PopScope();
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
break;
}
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> dictionary = ReadAttributeElements(reader, manager);
string prefix = MiscellaneousUtils.GetPrefix(propertyName);
IXmlElement xmlElement = CreateElement(propertyName, document, prefix, manager);
currentNode.AppendChild(xmlElement);
foreach (KeyValuePair <string, string> item in dictionary)
{
string prefix2 = MiscellaneousUtils.GetPrefix(item.Key);
object xmlNode2;
if (!string.IsNullOrEmpty(prefix2))
{
IXmlNode xmlNode = document.CreateAttribute(item.Key, manager.LookupNamespace(prefix2), item.Value);
xmlNode2 = xmlNode;
}
else
{
xmlNode2 = document.CreateAttribute(item.Key, item.Value);
}
IXmlNode attributeNode = (IXmlNode)xmlNode2;
xmlElement.SetAttributeNode(attributeNode);
}
if (reader.TokenType == JsonToken.String)
{
xmlElement.AppendChild(document.CreateTextNode(reader.Value.ToString()));
}
else if (reader.TokenType == JsonToken.Integer)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
}
else if (reader.TokenType == JsonToken.Float)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
}
else if (reader.TokenType == JsonToken.Boolean)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
}
else if (reader.TokenType == JsonToken.Date)
{
DateTime value = (DateTime)reader.Value;
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString(value, DateTimeUtils.ToSerializationMode(value.Kind))));
}
else if (reader.TokenType != JsonToken.Null && reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
DeserializeNode(reader, document, manager, xmlElement);
manager.PopScope();
}
}
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;
}
}
/// <summary>
/// Perform scan.
/// </summary>
public void Analyze(QilNode nd, bool defaultNmspInScope)
{
_addInScopeNmsp = false;
_cntNmsp = 0;
// If xmlns="" is in-scope, push it onto the namespace stack
if (defaultNmspInScope)
{
_nsmgr.PushScope();
_nsmgr.AddNamespace(string.Empty, string.Empty);
_cntNmsp++;
}
AnalyzeContent(nd);
if (defaultNmspInScope)
{
_nsmgr.PopScope();
}
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> attributeNameValues = this.ReadAttributeElements(reader, manager);
string elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
IXmlElement element = this.CreateElement(propertyName, document, elementPrefix, manager);
currentNode.AppendChild(element);
// add attributes to newly created element
foreach (KeyValuePair <string, string> nameValue in attributeNameValues)
{
string attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);
IXmlNode attribute = (!string.IsNullOrEmpty(attributePrefix))
? document.CreateAttribute(nameValue.Key, manager.LookupNamespace(attributePrefix), nameValue.Value)
: document.CreateAttribute(nameValue.Key, nameValue.Value);
element.SetAttributeNode(attribute);
}
if (reader.TokenType == JsonToken.String ||
reader.TokenType == JsonToken.Integer ||
reader.TokenType == JsonToken.Float ||
reader.TokenType == JsonToken.Boolean ||
reader.TokenType == JsonToken.Date)
{
element.AppendChild(document.CreateTextNode(this.ConvertTokenToXmlValue(reader)));
}
else if (reader.TokenType == JsonToken.Null)
{
// empty element. do nothing
}
else
{
// finished element will have no children to deserialize
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, element);
manager.PopScope();
}
}
}
public void NewNamespaceManager()
{
// make sure that you can call PopScope when there aren't any to pop.
Assert.IsTrue(!namespaceManager.PopScope());
// the following strings should have been added to the name table by the
// namespace manager.
string xmlnsPrefix = nameTable.Get("xmlns");
string xmlPrefix = nameTable.Get("xml");
string stringEmpty = nameTable.Get(String.Empty);
string xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
string xmlNamespace = "http://www.w3.org/XML/1998/namespace";
// none of them should be null.
Assert.IsNotNull(xmlnsPrefix);
Assert.IsNotNull(xmlPrefix);
Assert.IsNotNull(stringEmpty);
Assert.IsNotNull(xmlnsNamespace);
Assert.IsNotNull(xmlNamespace);
// Microsoft's XmlNamespaceManager reports that these three
// namespaces aren't declared for some reason.
Assert.IsTrue(!namespaceManager.HasNamespace("xmlns"));
Assert.IsTrue(!namespaceManager.HasNamespace("xml"));
Assert.IsTrue(!namespaceManager.HasNamespace(String.Empty));
// these three namespaces are declared by default.
Assert.AreEqual("http://www.w3.org/2000/xmlns/", namespaceManager.LookupNamespace("xmlns"));
Assert.AreEqual("http://www.w3.org/XML/1998/namespace", namespaceManager.LookupNamespace("xml"));
Assert.AreEqual(String.Empty, namespaceManager.LookupNamespace(String.Empty));
// the namespaces should be the same references found in the name table.
Assert.AreSame(xmlnsNamespace, namespaceManager.LookupNamespace("xmlns"));
Assert.AreSame(xmlNamespace, namespaceManager.LookupNamespace("xml"));
Assert.AreSame(stringEmpty, namespaceManager.LookupNamespace(String.Empty));
// looking up undeclared namespaces should return null.
Assert.IsNull(namespaceManager.LookupNamespace("foo"));
}
private void CallRequest(TagTestItem def, AttrBroadcasterFilter attr, CreatorIssuer state, string pred2, XmlNamespaceManager reference3, string asset4, Dictionary <string, string> token5)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
InfoRequestStrategy infoRequestStrategy = FindIterator(pred2, attr, asset4, reference3);
state._0001(infoRequestStrategy);
if (token5 != null)
{
foreach (KeyValuePair <string, string> item in token5)
{
string text = XmlConvert.EncodeName(item.Key);
string text2 = CustomerListAnnotation.CountIssuer(item.Key);
CreatorIssuer key = (!SetterTest.StartReader(text2)) ? attr._0002(text, reference3.LookupNamespace(text2) ?? string.Empty, item.Value) : attr._0002(text, item.Value);
infoRequestStrategy._0001(key);
}
}
switch (def._0001())
{
case WatcherComposer.Null:
break;
case WatcherComposer.Integer:
case WatcherComposer.Float:
case WatcherComposer.String:
case WatcherComposer.Boolean:
case WatcherComposer.Date:
case WatcherComposer.Bytes:
{
string text3 = WriteRequest(def);
if (text3 != null)
{
((CreatorIssuer)infoRequestStrategy)._0001(attr._0002(text3));
}
break;
}
case WatcherComposer.EndObject:
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
default:
reference3.PushScope();
ValidateIterator(def, attr, reference3, infoRequestStrategy);
reference3.PopScope();
reference3.RemoveNamespace(string.Empty, reference3.DefaultNamespace);
break;
}
}
public void AddPushPopRemove()
{
XmlNamespaceManager nsmgr =
new XmlNamespaceManager(new NameTable());
string ns = nsmgr.NameTable.Add("urn:foo");
nsmgr.AddNamespace("foo", ns);
Assert.AreEqual("foo", nsmgr.LookupPrefix(ns));
nsmgr.PushScope();
Assert.AreEqual("foo", nsmgr.LookupPrefix(ns));
nsmgr.PopScope();
Assert.AreEqual("foo", nsmgr.LookupPrefix(ns));
nsmgr.RemoveNamespace("foo", ns);
Assert.IsNull(nsmgr.LookupPrefix(ns));
}
private void WriteEndElementInternal(bool fullEndElement)
{
CheckState();
if (fullEndElement)
{
Emitter.WriteFullEndElement();
}
else
{
Emitter.WriteEndElement();
}
_state = WriteState.Content;
//Pop namespace scope
_nsManager.PopScope();
}
// Test enumerating over a namespace manager.
public void TestXmlNamespaceManagerEnumerate()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
ns.AddNamespace("foo", "uri1");
CheckEnum(ns, "uri1");
ns.PushScope();
ns.AddNamespace("foo", "uri2");
CheckEnum(ns, "uri2");
ns.AddNamespace("foo", "uri3");
CheckEnum(ns, "uri3");
ns.PopScope();
ns.AddNamespace("", "");
CheckEnum(ns, "uri1");
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> strs = this.ReadAttributeElements(reader, manager);
string prefix = MiscellaneousUtils.GetPrefix(propertyName);
IXmlElement xmlElement = this.CreateElement(propertyName, document, prefix, manager);
currentNode.AppendChild(xmlElement);
foreach (KeyValuePair <string, string> keyValuePair in strs)
{
string str = MiscellaneousUtils.GetPrefix(keyValuePair.Key);
xmlElement.SetAttributeNode((string.IsNullOrEmpty(str) ? document.CreateAttribute(keyValuePair.Key, keyValuePair.Value) : document.CreateAttribute(keyValuePair.Key, manager.LookupNamespace(str), keyValuePair.Value)));
}
if (reader.TokenType == JsonToken.String)
{
xmlElement.AppendChild(document.CreateTextNode(reader.Value.ToString()));
}
else if (reader.TokenType == JsonToken.Integer)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
}
else if (reader.TokenType == JsonToken.Float)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
}
else if (reader.TokenType == JsonToken.Boolean)
{
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
}
else if (reader.TokenType == JsonToken.Date)
{
DateTime value = (DateTime)reader.Value;
xmlElement.AppendChild(document.CreateTextNode(XmlConvert.ToString(value, Newtonsoft.Json.Utilities.DateTimeUtils.ToSerializationMode(value.Kind))));
}
else if (reader.TokenType != JsonToken.Null)
{
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, xmlElement);
manager.PopScope();
}
}
}
// Token: 0x06001033 RID: 4147 RVA: 0x000516F8 File Offset: 0x0004F8F8
private void smethod_2970(Class_285 arg_0, Class_389 arg_1, Class_387 arg_2, string str_0, XmlNamespaceManager arg_3)
{
if (string.IsNullOrEmpty(str_0))
{
throw new Class_417("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> dictionary = this.cmethod_2974(arg_0, arg_3);
string prefix = Class_513.GetPrefix(str_0);
if (str_0.StartsWith('@'))
{
string text = str_0.Substring(1);
string text2 = arg_0.prop_10.ToString();
string prefix2 = Class_513.GetPrefix(text);
Class_387 arg_4 = (!string.IsNullOrEmpty(prefix2)) ? arg_1.tmethod_2842(text, arg_3.LookupNamespace(prefix2), text2) : arg_1.xmethod_2841(text, text2);
((Class_391)arg_2).kmethod_2857(arg_4);
return;
}
Class_391 class_ = this.kmethod_2977(str_0, arg_1, prefix, arg_3);
arg_2.kmethod_2817(class_);
foreach (KeyValuePair <string, string> keyValuePair in dictionary)
{
string prefix3 = Class_513.GetPrefix(keyValuePair.Key);
Class_387 arg_5 = (!string.IsNullOrEmpty(prefix3)) ? arg_1.tmethod_2842(keyValuePair.Key, arg_3.LookupNamespace(prefix3), keyValuePair.Value) : arg_1.xmethod_2841(keyValuePair.Key, keyValuePair.Value);
class_.kmethod_2857(arg_5);
}
if (arg_0.prop_9 == Class_508.String || arg_0.prop_9 == Class_508.Integer || arg_0.prop_9 == Class_508.Float || arg_0.prop_9 == Class_508.Boolean || arg_0.prop_9 == Class_508.Date)
{
class_.kmethod_2817(arg_1.tmethod_2832(this.xmethod_2971(arg_0)));
return;
}
if (arg_0.prop_9 == Class_508.Null)
{
return;
}
if (arg_0.prop_9 != Class_508.EndObject)
{
arg_3.PushScope();
this.lmethod_2978(arg_0, arg_1, arg_3, class_);
arg_3.PopScope();
}
arg_3.RemoveNamespace(string.Empty, arg_3.DefaultNamespace);
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> dictionary = this.ReadAttributeElements(reader, manager);
string prefix = MiscellaneousUtils.GetPrefix(propertyName);
if (propertyName.StartsWith("@"))
{
string text = propertyName.Substring(1);
string value = reader.Value.ToString();
string prefix2 = MiscellaneousUtils.GetPrefix(text);
IXmlNode attributeNode = (!string.IsNullOrEmpty(prefix2)) ? document.CreateAttribute(text, manager.LookupNamespace(prefix2), value) : document.CreateAttribute(text, value);
((IXmlElement)currentNode).SetAttributeNode(attributeNode);
return;
}
IXmlElement xmlElement = this.CreateElement(propertyName, document, prefix, manager);
currentNode.AppendChild(xmlElement);
foreach (KeyValuePair <string, string> current in dictionary)
{
string prefix3 = MiscellaneousUtils.GetPrefix(current.Key);
IXmlNode attributeNode2 = (!string.IsNullOrEmpty(prefix3)) ? document.CreateAttribute(current.Key, manager.LookupNamespace(prefix3), current.Value) : document.CreateAttribute(current.Key, current.Value);
xmlElement.SetAttributeNode(attributeNode2);
}
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer || reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Boolean || reader.TokenType == JsonToken.Date)
{
xmlElement.AppendChild(document.CreateTextNode(this.ConvertTokenToXmlValue(reader)));
return;
}
if (reader.TokenType == JsonToken.Null)
{
return;
}
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, xmlElement);
manager.PopScope();
}
}
private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> dictionary = this.ReadAttributeElements(reader, manager);
string prefix1 = MiscellaneousUtils.GetPrefix(propertyName);
if (propertyName.StartsWith("@"))
{
string str1 = propertyName.Substring(1);
string str2 = reader.Value.ToString();
string prefix2 = MiscellaneousUtils.GetPrefix(str1);
IXmlNode attribute = !string.IsNullOrEmpty(prefix2) ? document.CreateAttribute(str1, manager.LookupNamespace(prefix2), str2) : document.CreateAttribute(str1, str2);
((IXmlElement)currentNode).SetAttributeNode(attribute);
}
else
{
IXmlElement element = this.CreateElement(propertyName, document, prefix1, manager);
currentNode.AppendChild((IXmlNode)element);
foreach (KeyValuePair <string, string> keyValuePair in dictionary)
{
string prefix2 = MiscellaneousUtils.GetPrefix(keyValuePair.Key);
IXmlNode attribute = !string.IsNullOrEmpty(prefix2) ? document.CreateAttribute(keyValuePair.Key, manager.LookupNamespace(prefix2), keyValuePair.Value) : document.CreateAttribute(keyValuePair.Key, keyValuePair.Value);
element.SetAttributeNode(attribute);
}
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer || (reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Boolean) || reader.TokenType == JsonToken.Date)
{
element.AppendChild(document.CreateTextNode(this.ConvertTokenToXmlValue(reader)));
}
else
{
if (reader.TokenType == JsonToken.Null || reader.TokenType == JsonToken.EndObject)
{
return;
}
manager.PushScope();
this.DeserializeNode(reader, document, manager, (IXmlNode)element);
manager.PopScope();
}
}
}
private void method_8(JsonReader jsonReader_0, Interface11 interface11_0, Interface10 interface10_0, string string_8, XmlNamespaceManager xmlNamespaceManager_0)
{
if (string.IsNullOrEmpty(string_8))
{
throw new JsonSerializationException("XmlNodeConverter cannot convert JSON with an empty property name to XML.");
}
Dictionary <string, string> dictionary = this.method_12(jsonReader_0, xmlNamespaceManager_0);
string str = Class193.smethod_4(string_8);
if (string_8.StartsWith("@"))
{
string str2 = string_8.Substring(1);
string str3 = jsonReader_0.Object_0.ToString();
string str4 = Class193.smethod_4(str2);
Interface10 interface2 = !string.IsNullOrEmpty(str4) ? interface11_0.imethod_11(str2, xmlNamespaceManager_0.LookupNamespace(str4), str3) : interface11_0.imethod_10(str2, str3);
((Interface12)interface10_0).imethod_1(interface2);
}
else
{
Interface12 interface3 = this.method_14(string_8, interface11_0, str, xmlNamespaceManager_0);
interface10_0.imethod_0(interface3);
foreach (KeyValuePair <string, string> pair in dictionary)
{
string str5 = Class193.smethod_4(pair.Key);
Interface10 interface4 = !string.IsNullOrEmpty(str5) ? interface11_0.imethod_11(pair.Key, xmlNamespaceManager_0.LookupNamespace(str5), pair.Value) : interface11_0.imethod_10(pair.Key, pair.Value);
interface3.imethod_1(interface4);
}
if ((((jsonReader_0.JsonToken_0 != JsonToken.String) && (jsonReader_0.JsonToken_0 != JsonToken.Integer)) && ((jsonReader_0.JsonToken_0 != JsonToken.Float) && (jsonReader_0.JsonToken_0 != JsonToken.Boolean))) && (jsonReader_0.JsonToken_0 != JsonToken.Date))
{
if ((jsonReader_0.JsonToken_0 != JsonToken.Null) && (jsonReader_0.JsonToken_0 != JsonToken.EndObject))
{
xmlNamespaceManager_0.PushScope();
this.method_15(jsonReader_0, interface11_0, xmlNamespaceManager_0, interface3);
xmlNamespaceManager_0.PopScope();
}
}
else
{
interface3.imethod_0(interface11_0.imethod_2(this.method_9(jsonReader_0)));
}
}
}
// Check the "HasNamespace" method.
public void TestXmlNamespaceManagerHas()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("Has (1)", ns.HasNamespace("xml"));
Assert("Has (2)", ns.HasNamespace("xmlns"));
Assert("Has (3)", ns.HasNamespace(""));
Assert("Has (4)", !ns.HasNamespace("foo"));
ns.AddNamespace("foo", "uri");
Assert("Has (5)", ns.HasNamespace("xml"));
Assert("Has (6)", ns.HasNamespace("xmlns"));
Assert("Has (7)", ns.HasNamespace(""));
Assert("Has (8)", ns.HasNamespace("foo"));
ns.PushScope();
ns.AddNamespace("bar", "uri2");
Assert("Has (9)", ns.HasNamespace("xml"));
Assert("Has (10)", ns.HasNamespace("xmlns"));
Assert("Has (11)", ns.HasNamespace(""));
Assert("Has (12)", ns.HasNamespace("foo"));
Assert("Has (13)", ns.HasNamespace("bar"));
ns.PopScope();
Assert("Has (14)", ns.HasNamespace("xml"));
Assert("Has (15)", ns.HasNamespace("xmlns"));
Assert("Has (16)", ns.HasNamespace(""));
Assert("Has (17)", ns.HasNamespace("foo"));
Assert("Has (18)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("foo", "uri");
Assert("Has (19)", ns.HasNamespace("xml"));
Assert("Has (20)", ns.HasNamespace("xmlns"));
Assert("Has (21)", ns.HasNamespace(""));
Assert("Has (22)", !ns.HasNamespace("foo"));
Assert("Has (23)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("", "");
Assert("Has (24)", ns.HasNamespace("xml"));
Assert("Has (25)", ns.HasNamespace("xmlns"));
Assert("Has (26)", ns.HasNamespace(""));
Assert("Has (27)", !ns.HasNamespace("foo"));
Assert("Has (28)", !ns.HasNamespace("bar"));
Assert("Has (29)", !ns.HasNamespace(null));
}
// Check the "PopScope" method.
public void TestXmlNamespaceManagerPopScope()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("PopScope (1)", !ns.PopScope());
ns.PushScope();
Assert("PopScope (2)", ns.PopScope());
}
// Check the "HasNamespace" method.
public void TestXmlNamespaceManagerHas()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
Assert("Has (1)", ns.HasNamespace("xml"));
Assert("Has (2)", ns.HasNamespace("xmlns"));
Assert("Has (3)", ns.HasNamespace(""));
Assert("Has (4)", !ns.HasNamespace("foo"));
ns.AddNamespace("foo", "uri");
Assert("Has (5)", ns.HasNamespace("xml"));
Assert("Has (6)", ns.HasNamespace("xmlns"));
Assert("Has (7)", ns.HasNamespace(""));
Assert("Has (8)", ns.HasNamespace("foo"));
ns.PushScope();
ns.AddNamespace("bar", "uri2");
Assert("Has (9)", ns.HasNamespace("xml"));
Assert("Has (10)", ns.HasNamespace("xmlns"));
Assert("Has (11)", ns.HasNamespace(""));
Assert("Has (12)", ns.HasNamespace("foo"));
Assert("Has (13)", ns.HasNamespace("bar"));
ns.PopScope();
Assert("Has (14)", ns.HasNamespace("xml"));
Assert("Has (15)", ns.HasNamespace("xmlns"));
Assert("Has (16)", ns.HasNamespace(""));
Assert("Has (17)", ns.HasNamespace("foo"));
Assert("Has (18)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("foo", "uri");
Assert("Has (19)", ns.HasNamespace("xml"));
Assert("Has (20)", ns.HasNamespace("xmlns"));
Assert("Has (21)", ns.HasNamespace(""));
Assert("Has (22)", !ns.HasNamespace("foo"));
Assert("Has (23)", !ns.HasNamespace("bar"));
ns.RemoveNamespace("", "");
Assert("Has (24)", ns.HasNamespace("xml"));
Assert("Has (25)", ns.HasNamespace("xmlns"));
Assert("Has (26)", ns.HasNamespace(""));
Assert("Has (27)", !ns.HasNamespace("foo"));
Assert("Has (28)", !ns.HasNamespace("bar"));
Assert("Has (29)", !ns.HasNamespace(null));
}
// Test enumerating over a namespace manager.
public void TestXmlNamespaceManagerEnumerate()
{
NameTable table = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(table);
ns.AddNamespace("foo", "uri1");
CheckEnum(ns, "uri1");
ns.PushScope();
ns.AddNamespace("foo", "uri2");
CheckEnum(ns, "uri2");
ns.AddNamespace("foo", "uri3");
CheckEnum(ns, "uri3");
ns.PopScope();
ns.AddNamespace("", "");
CheckEnum(ns, "uri1");
}