public void DumpReader (XmlReader xr, bool attValue)
{
Console.WriteLine ("NodeType: " + xr.NodeType);
Console.WriteLine ("Prefix: " + xr.Prefix);
Console.WriteLine ("Name: " + xr.Name);
Console.WriteLine ("LocalName: " + xr.LocalName);
Console.WriteLine ("NamespaceURI: " + xr.NamespaceURI);
Console.WriteLine ("Value: " + xr.Value);
Console.WriteLine ("Depth: " + xr.Depth);
Console.WriteLine ("IsEmptyElement: " + xr.IsEmptyElement);
if (xr.NodeType == XmlNodeType.Attribute) {
Console.WriteLine ("Attribute Values::::");
while (xr.ReadAttributeValue ())
DumpReader (xr, true);
Console.WriteLine (":::Attribute Values End");
} else if (!attValue) {
Console.WriteLine ("Attributes::::");
Console.Write (xr.AttributeCount);
if (xr.MoveToFirstAttribute ()) {
do {
DumpReader (xr, false);
} while (xr.MoveToNextAttribute ());
xr.MoveToElement ();
}
Console.WriteLine (":::Attributes End");
}
}
// returns remaining attributes to be processed
List <StringPair> ProcessAttributes(XmlReader r, List <Pair> members, out string typeArgNames)
{
// base (top element)
if (!xmlbase_done)
{
xmlbase_done = true;
string xmlbase = r.GetAttribute("base", XamlLanguage.Xml1998Namespace) ?? r.BaseURI;
if (xmlbase != null)
{
members.Add(new Pair(XamlLanguage.Base, xmlbase));
}
}
typeArgNames = null;
var atts = new List <StringPair>();
var tagNamespace = r.NamespaceURI;
if (r.MoveToFirstAttribute())
{
do
{
switch (r.NamespaceURI)
{
case XamlLanguage.Xml1998Namespace:
switch (r.LocalName)
{
case "base":
continue; // already processed.
case "lang":
members.Add(new Pair(XamlLanguage.Lang, r.Value));
continue;
case "space":
members.Add(new Pair(XamlLanguage.Space, r.Value));
continue;
}
break;
case XamlLanguage.Xmlns2000Namespace:
continue;
case XamlLanguage.Xaml2006Namespace:
XamlDirective d = FindStandardDirective(r.LocalName, AllowedMemberLocations.Attribute);
if (d != null)
{
// check TypeArguments to resolve Type, and remove them from the list. They don't appear as a node.
if (ReferenceEquals(d, XamlLanguage.TypeArguments))
{
typeArgNames = r.Value;
continue;
}
members.Add(new Pair(d, r.Value));
continue;
}
throw new NotSupportedException(String.Format("Attribute '{0}' is not supported", r.Name));
default:
if (string.IsNullOrEmpty(r.NamespaceURI) || tagNamespace == r.NamespaceURI || r.LocalName.IndexOf('.') > 0)
{
atts.Add(new StringPair(r.Name, r.Value));
continue;
}
// Custom directive
members.Add(new Pair(SchemaContext.GetXamlDirective(r.NamespaceURI, r.LocalName), r.Value));
break;
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
return(atts);
}
//[Variation("ReadSubtree only works on Element Node")]
public void ReadSubtreeOnlyWorksOnElementNode()
{
XmlReader DataReader = GetReader();
while (DataReader.Read())
{
if (DataReader.NodeType != XmlNodeType.Element)
{
string nodeType = DataReader.NodeType.ToString();
bool flag = true;
try
{
DataReader.ReadSubtree();
}
catch (InvalidOperationException)
{
flag = false;
}
if (flag)
{
TestLog.WriteLine("ReadSubtree doesn't throw InvalidOp Exception on NodeType : " + nodeType);
throw new TestException(TestResult.Failed, "");
}
// now try next read
try
{
DataReader.Read();
}
catch (XmlException)
{
TestLog.WriteLine("Cannot Read after an invalid operation exception");
throw new TestException(TestResult.Failed, "");
}
}
else
{
if (DataReader.HasAttributes)
{
bool flag = true;
DataReader.MoveToFirstAttribute();
try
{
DataReader.ReadSubtree();
}
catch (InvalidOperationException)
{
flag = false;
}
if (flag)
{
TestLog.WriteLine("ReadSubtree doesn't throw InvalidOp Exception on Attribute Node Type");
throw new TestException(TestResult.Failed, "");
}
//now try next read.
try
{
DataReader.Read();
}
catch (XmlException)
{
TestLog.WriteLine("Cannot Read after an invalid operation exception");
throw new TestException(TestResult.Failed, "");
}
}
}
}//end while
}
internal void Parse(XmlReader reader)
{
GetPositionInfo(reader);
var hasEndElement = !reader.IsEmptyElement;
Debug.Assert(reader.NodeType == XmlNodeType.Element);
for (var more = reader.MoveToFirstAttribute(); more; more = reader.MoveToNextAttribute())
{
ParseAttribute(reader);
}
HandleAttributesComplete();
var done = !hasEndElement;
var skipToNextElement = false;
while (!done)
{
if (skipToNextElement)
{
skipToNextElement = false;
reader.Skip();
if (reader.EOF)
{
break;
}
}
else
{
if (!reader.Read())
{
break;
}
}
switch (reader.NodeType)
{
case XmlNodeType.Element:
skipToNextElement = ParseElement(reader);
break;
case XmlNodeType.EndElement:
{
done = true;
break;
}
case XmlNodeType.CDATA:
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
ParseText(reader);
break;
// we ignore these childless elements
case XmlNodeType.Whitespace:
case XmlNodeType.XmlDeclaration:
case XmlNodeType.Comment:
case XmlNodeType.Notation:
case XmlNodeType.ProcessingInstruction:
{
break;
}
// we ignore these elements that can have children
case XmlNodeType.DocumentType:
case XmlNodeType.EntityReference:
{
skipToNextElement = true;
break;
}
default:
{
AddError(
ErrorCode.UnexpectedXmlNodeType, EdmSchemaErrorSeverity.Error, reader,
Strings.UnexpectedXmlNodeType(reader.NodeType));
skipToNextElement = true;
break;
}
}
}
HandleChildElementsComplete();
if (reader.EOF &&
reader.Depth > 0)
{
AddError(
ErrorCode.MalformedXml, EdmSchemaErrorSeverity.Error, 0, 0,
Strings.MalformedXml(LineNumber, LinePosition));
}
}
/// <summary>读取</summary>
/// <param name="reader"></param>
/// <param name="value">数值</param>
public static void ReadXml(XmlReader reader, Object value)
{
var pis = value.GetType().GetProperties(true);
var names = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
foreach (var pi in pis)
{
if (!pi.CanRead)
{
continue;
}
if (pi.GetCustomAttribute <XmlIgnoreAttribute>(false) != null)
{
continue;
}
// 已处理的特性
names.Add(pi.Name);
var v = reader.GetAttribute(pi.Name);
if (String.IsNullOrEmpty(v))
{
continue;
}
if (pi.PropertyType == typeof(String[]))
{
var ss = v.Split(new String[] { "," }, StringSplitOptions.RemoveEmptyEntries);
// 去除前后空格，因为手工修改xml的时候，可能在逗号后加上空格
for (int i = 0; i < ss.Length; i++)
{
ss[i] = ss[i].Trim();
}
value.SetValue(pi, ss);
}
else
{
value.SetValue(pi, v.ChangeType(pi.PropertyType));
}
}
var pi1 = pis.FirstOrDefault(e => e.Name == "Name");
var pi2 = pis.FirstOrDefault(e => e.Name == "TableName" || e.Name == "ColumnName");
if (pi1 != null && pi2 != null)
{
// 兼容旧版本
var v2 = reader.GetAttribute("Alias");
if (!String.IsNullOrEmpty(v2))
{
value.SetValue(pi2, value.GetValue(pi1));
value.SetValue(pi1, v2);
}
// 写入的时候省略了相同的TableName/ColumnName
v2 = (String)value.GetValue(pi2);
if (String.IsNullOrEmpty(v2))
{
value.SetValue(pi2, value.GetValue(pi1));
}
}
// 自增字段非空
if (value is IDataColumn)
{
var dc = value as IDataColumn;
if (dc.Identity)
{
dc.Nullable = false;
}
}
//reader.Skip();
// 剩余特性作为扩展属性
if (reader.MoveToFirstAttribute())
{
if (value is IDataTable || value is IDataColumn)
{
var dic = (value is IDataTable) ? (value as IDataTable).Properties : (value as IDataColumn).Properties;
do
{
if (!names.Contains(reader.Name))
{
dic[reader.Name] = reader.Value;
}
} while (reader.MoveToNextAttribute());
}
}
}
public static void HandleBuilding(XmlReader reader, CityGml2GO cityGml2Go)
{
var buildingName = "";
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "id")
{
buildingName = reader.Value;
}
}
var buildingGo = new GameObject(string.IsNullOrEmpty(buildingName) ? "Building" : buildingName);
var buildingProperties = buildingGo.AddComponent <Scripts.BuildingProperties>();
var semanticType = buildingGo.AddComponent <SemanticType>();
buildingGo.transform.SetParent(cityGml2Go.Parent.transform);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "Polygon")
{
var polyGo = PolygonHandler.PolyToMesh(reader, buildingName, cityGml2Go, semanticType);
if (polyGo != null)
{
polyGo.transform.SetParent(buildingGo.transform);
}
}
if (cityGml2Go.ShowCurves)
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "MultiCurve")
{
MultiCurveHandler.HandleMultiCurve(reader, buildingGo, semanticType, cityGml2Go);
}
}
if (cityGml2Go.Semantics)
{
if (reader.NodeType == XmlNodeType.Element && cityGml2Go.SemanticSurfaces.Any(x => x == reader.LocalName))
{
semanticType.Name = reader.LocalName;
reader.MoveToFirstAttribute();
if (reader.LocalName == "id")
{
semanticType.Id = reader.Value;
}
else
{
while (reader.MoveToNextAttribute())
{
semanticType.Id = reader.Value;
}
}
}
}
BuildingPropertiesHandler.HandleBuildingProperties(reader, buildingProperties);
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Building")
{
break;
}
}
Object.Destroy(semanticType);
}
private void Read(ConfigurationNode node, StringCollection fileNames)
{
var name = node.Name;
var endOfNode = _xmlReader.IsEmptyElement;
if (name != null)
{
var hasNext = _xmlReader.MoveToFirstAttribute();
while (hasNext)
{
var attributeName = _xmlReader.Name;
var attributeValue = _xmlReader.Value;
if (attributeName == "name")
{
}
else if (attributeName == "description")
{
node.Description = attributeValue;
}
else
{
var attribute = new ConfigurationAttribute(attributeName, attributeValue, null);
node.Attributes.Add(attribute);
}
hasNext = _xmlReader.MoveToNextAttribute();
}
}
while (!endOfNode && _xmlReader.Read())
{
switch (_xmlReader.NodeType)
{
case XmlNodeType.Element:
{
var elementName = _xmlReader.Name;
switch (elementName)
{
case ConfigurationElementName.Attribute:
ReadAttribute(node);
break;
case ConfigurationElementName.Node:
{
var nodeName = _xmlReader.GetAttribute("name");
var childNode = new ConfigurationNode(nodeName);
node.AddChildNode(childNode);
Read(childNode, fileNames);
}
break;
case "include":
{
var fileName = _xmlReader.GetAttribute("fileName");
fileName = Environment.ExpandEnvironmentVariables(fileName);
var reader2 = new ConfigurationReader();
var includeNode = reader2.Read(fileName, _sectionName, fileNames);
node.Attributes.Add(includeNode.Attributes);
foreach (var childNode in includeNode.ChildNodes)
{
node.AddChildNode(childNode);
}
if (_enableFileSystemWatcher && !fileNames.Contains(fileName))
{
fileNames.Add(fileName);
}
}
break;
default:
{
var nodeName = XmlConvert.DecodeName(elementName);
var childNode = new ConfigurationNode(nodeName);
node.AddChildNode(childNode);
Read(childNode, fileNames);
}
break;
}
}
break;
case XmlNodeType.EndElement:
endOfNode = true;
break;
default:
break;
}
}
}
internal bool MoveToFirstAttribute()
{
return(isEndOfEmptyElement ? false : reader.MoveToFirstAttribute());
}
public override bool MoveToFirstAttribute()
{
return(_baseReader.MoveToFirstAttribute());
}
// function for parsing an XML file from web via URL
public async Task <string> XmlParser(string URL)
{
// block of settings
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = new XmlUrlResolver();
settings.DtdProcessing = DtdProcessing.Parse;
settings.ValidationType = ValidationType.DTD;
settings.Async = true;
string XMLtext = "";
// block of parsing
using (XmlReader reader = XmlReader.Create(URL, settings))
{
while (await reader.ReadAsync())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "offer" && reader.MoveToFirstAttribute())
{
XMLtext += reader.GetAttribute("id");
XMLtext += " ";
}
}
}
return(XMLtext);
}
private void ParseStep(XmlReader reader, Stack <ElementRecord> elementStack, ref TextRecord textChunk, PhpArray values, PhpArray indices)
{
string elementName;
bool emptyElement;
ElementRecord currentElementRecord = null;
switch (reader.NodeType)
{
case XmlNodeType.Element:
elementName = reader.Name;
emptyElement = reader.IsEmptyElement;
PhpArray attributeArray = new PhpArray();
if (_processNamespaces && elementName.IndexOf(":") >= 0)
{
string localName = elementName.Substring(elementName.IndexOf(":") + 1);
elementName = reader.NamespaceURI + _namespaceSeparator + localName;
}
if (reader.MoveToFirstAttribute())
{
do
{
if (_processNamespaces && reader.Name.StartsWith("xmlns:"))
{
string namespaceID = reader.Name.Substring(6);
string namespaceUri = reader.Value;
if (_startNamespaceDeclHandler.Callback != null)
{
_startNamespaceDeclHandler.Invoke(this, namespaceID, namespaceUri);
}
continue;
}
attributeArray.Add(_enableCaseFolding ? reader.Name.ToUpperInvariant() : reader.Name, reader.Value);
}while (reader.MoveToNextAttribute());
}
// update current top of stack
if (elementStack.Count != 0)
{
currentElementRecord = elementStack.Peek();
UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, true);
if (currentElementRecord.State == ElementState.Beginning)
{
currentElementRecord.State = ElementState.Interior;
}
}
// push the element into the stack (needed for parse_into_struct)
elementStack.Push(
new ElementRecord()
{
ElementName = elementName,
Level = reader.Depth,
State = ElementState.Beginning,
Attributes = (PhpArray)attributeArray.DeepCopy()
});
if (_startElementHandler.Callback != null)
{
_startElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName, attributeArray);
}
else
if (_defaultHandler.Callback != null)
{
_defaultHandler.Invoke(this, "");
}
if (emptyElement)
{
goto case XmlNodeType.EndElement; // and end the element immediately (<element/>, XmlNodeType.EndElement will not be called)
}
break;
case XmlNodeType.EndElement:
elementName = reader.Name;
if (_processNamespaces && elementName.IndexOf(":") >= 0)
{
string localName = elementName.Substring(elementName.IndexOf(":") + 1);
elementName = reader.NamespaceURI + _namespaceSeparator + localName;
}
// pop the top element record
currentElementRecord = elementStack.Pop();
UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, false);
if (_endElementHandler.Callback != null)
{
_endElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName);
}
else
if (_defaultHandler.Callback != null)
{
_defaultHandler.Invoke(this, "");
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
if (textChunk == null)
{
textChunk = new TextRecord()
{
Text = reader.Value
};
}
else
{
textChunk.Text += reader.Value;
}
if (_characterDataHandler.Callback != null)
{
_characterDataHandler.Invoke(this, reader.Value);
}
else
if (_defaultHandler.Callback != null)
{
_defaultHandler.Invoke(this, reader.Value);
}
break;
case XmlNodeType.ProcessingInstruction:
if (_processingInstructionHandler.Callback != null)
{
_processingInstructionHandler.Invoke(this, reader.Name, reader.Value);
}
else
if (_defaultHandler.Callback != null)
{
_defaultHandler.Invoke(this, string.Empty);
}
break;
}
}
public void getXmlData(string letterId, string word)
{
XmlReader reader = XmlReader.Create("Madrasi.xml");
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "letter")
{
if (true == reader.MoveToFirstAttribute())
{
letterName = reader.Value;
}
}
else if (reader.Name == "word" && letterName == letterId)
{
if (true == reader.MoveToFirstAttribute())
{
wordName = reader.Value;
}
if (String.Compare(word, 0, wordName, 0, word.Length) == 0)
{
if (true == reader.MoveToNextAttribute())
{
wordMeaning = reader.Value;
}
if (true == reader.MoveToNextAttribute())
{
wordLanguage = reader.Value;
}
}
else
{
wordName = "";
wordMeaning = "";
wordLanguage = "";
wordOrigin = "";
}
}
}
else if (reader.NodeType == XmlNodeType.EndElement && letterName == letterId && wordName == word)
{
if (reader.Name == "word")
{
break;
}
}
else if (reader.NodeType == XmlNodeType.Text && letterName == letterId && wordName == word)
{
wordOrigin = reader.Value;
}
}
reader.Close();
// + "\n\nWord Meaning : " + wordMeaning + "\n\n Word Origin Language : " + wordLanguage + "\n\nWord Origin : " + wordOrigin;
}
/// <summary>读取</summary>
/// <param name="table"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static IDataTable ReadXml(this IDataTable table, XmlReader reader)
{
// 读属性
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
ReadXml(reader, table);
}
reader.ReadStartElement();
// 读字段
reader.MoveToElement();
// 有些数据表模型没有字段
if (reader.NodeType == XmlNodeType.Element && reader.Name.EqualIgnoreCase("Table"))
{
return(table);
}
while (reader.NodeType != XmlNodeType.EndElement)
//while (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Columns":
reader.ReadStartElement();
while (reader.IsStartElement())
{
var dc = table.CreateColumn();
var v = reader.GetAttribute("DataType");
if (v != null)
{
dc.DataType = v.GetTypeEx(false);
v = reader.GetAttribute("Length");
if (v != null && Int32.TryParse(v, out var len))
{
dc.Length = len;
}
dc = FixDefaultByType(dc, null);
// 清空默认的原始类型，让其从xml读取
dc.RawType = null;
}
(dc as IXmlSerializable).ReadXml(reader);
table.Columns.Add(dc);
}
reader.ReadEndElement();
// 修正可能的主字段
if (!table.Columns.Any(e => e.Master))
{
var f = table.Columns.FirstOrDefault(e => e.Name.EqualIgnoreCase("Name", "Title"));
if (f != null)
{
f.Master = true;
}
}
break;
case "Indexes":
reader.ReadStartElement();
while (reader.IsStartElement())
{
var di = table.CreateIndex();
(di as IXmlSerializable).ReadXml(reader);
di.Fix();
table.Indexes.Add(di);
}
reader.ReadEndElement();
break;
case "Relations":
reader.ReadStartElement();
reader.Skip();
reader.ReadEndElement();
break;
default:
// 这里必须处理，否则加载特殊Xml文件时将会导致死循环
reader.Read();
break;
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
// 修正
table.Fix();
return(table);
}
internal void ReadContentFrom(XmlReader r, LoadOptions o)
{
if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0)
{
ReadContentFrom(r);
return;
}
if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
XContainer c = this;
XNode n = null;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
string baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null;
IXmlLineInfo li = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null;
do
{
string uri = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (baseUri != null && baseUri != uri)
{
e.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
e.SetLineInfo(li.LineNumber, li.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if (li != null && li.HasLineInfo())
{
a.SetLineInfo(li.LineNumber, li.LinePosition);
}
e.AppendAttributeSkipNotify(a);
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
if (baseUri != null)
{
baseUri = uri;
}
}
break;
}
case XmlNodeType.EndElement:
{
if (c.content == null)
{
c.content = string.Empty;
}
// Store the line info of the end element tag.
// Note that since we've got EndElement the current container must be an XElement
XElement e = c as XElement;
Debug.Assert(e != null, "EndElement received but the current container is not an element.");
if (e != null && li != null && li.HasLineInfo())
{
e.SetEndElementLineInfo(li.LineNumber, li.LinePosition);
}
if (c == this) return;
if (baseUri != null && c.HasBaseUri)
{
baseUri = c.parent.BaseUri;
}
c = c.parent;
break;
}
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
if ((baseUri != null && baseUri != uri) ||
(li != null && li.HasLineInfo()))
{
n = new XText(r.Value);
}
else
{
c.AddStringSkipNotify(r.Value);
}
break;
case XmlNodeType.CDATA:
n = new XCData(r.Value);
break;
case XmlNodeType.Comment:
n = new XComment(r.Value);
break;
case XmlNodeType.ProcessingInstruction:
n = new XProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.DocumentType:
n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
if (n != null)
{
if (baseUri != null && baseUri != uri)
{
n.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
n.SetLineInfo(li.LineNumber, li.LinePosition);
}
c.AddNodeSkipNotify(n);
n = null;
}
} while (r.Read());
}
public bool ParseContent(TextReader sr)
{
var setting = new XmlReaderSettings();
setting.DtdProcessing = DtdProcessing.Ignore;
XmlReader xmlReader = XmlReader.Create(sr, setting);
int dataindex = 0;
int Width = 0;
int Height = 0;
while (xmlReader.Read())
{
string name = xmlReader.Name;
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
string[] attrs = null;
if (name == "map")
{
Width = CCUtils.CCParseInt(xmlReader.GetAttribute("width"));
Height = CCUtils.CCParseInt(xmlReader.GetAttribute("height"));
}
if (xmlReader.HasAttributes)
{
attrs = new string[xmlReader.AttributeCount * 2];
xmlReader.MoveToFirstAttribute();
int i = 0;
attrs[0] = xmlReader.Name;
attrs[1] = xmlReader.Value;
i += 2;
while (xmlReader.MoveToNextAttribute())
{
attrs[i] = xmlReader.Name;
attrs[i + 1] = xmlReader.Value;
i += 2;
}
// Move the reader back to the element node.
xmlReader.MoveToElement();
}
StartElement(this, name, attrs);
byte[] buffer = null;
//read data content of tmx file
if (name == "data")
{
if (attrs != null)
{
string encoding = "";
for (int i = 0; i < attrs.Length; i++)
{
if (attrs [i] == "encoding")
{
encoding = attrs [i + 1];
}
}
if (encoding == "base64")
{
var base64String = xmlReader.ReadElementContentAsString().Trim();
buffer = Convert.FromBase64String(base64String);
}
else
{
string value = xmlReader.ReadElementContentAsString();
buffer = Encoding.UTF8.GetBytes(value);
}
}
// Pure XML TileMap
else
{
int dataSize = (Width * Height * 4) + 1024;
buffer = new byte[dataSize];
}
TextHandler(this, buffer, buffer.Length);
EndElement(this, name);
}
else if (name == "key" || name == "integer" || name == "real" || name == "string")
{
string value = xmlReader.ReadElementContentAsString();
buffer = Encoding.UTF8.GetBytes(value);
TextHandler(this, buffer, buffer.Length);
EndElement(this, name);
}
else if (xmlReader.IsEmptyElement)
{
EndElement(this, name);
}
break;
case XmlNodeType.EndElement:
EndElement(this, xmlReader.Name);
dataindex++;
break;
default:
break;
}
}
return(true);
}
internal void ReadContentFrom(XmlReader r)
{
if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
XContainer c = this;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
do
{
switch (r.NodeType)
{
case XmlNodeType.Element:
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (r.MoveToFirstAttribute())
{
do
{
e.AppendAttributeSkipNotify(new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
}
break;
case XmlNodeType.EndElement:
if (c.content == null)
{
c.content = string.Empty;
}
if (c == this) return;
c = c.parent;
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
c.AddStringSkipNotify(r.Value);
break;
case XmlNodeType.CDATA:
c.AddNodeSkipNotify(new XCData(r.Value));
break;
case XmlNodeType.Comment:
c.AddNodeSkipNotify(new XComment(r.Value));
break;
case XmlNodeType.ProcessingInstruction:
c.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
break;
case XmlNodeType.DocumentType:
c.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value));
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
} while (r.Read());
}
/// <summary>
/// Main function that retrieves the list from API, including paging
/// </summary>
/// <param name="url">URL of API request</param>
/// <param name="haveSoFar">Number of pages already retrieved, for upper limit control</param>
/// <returns>List of pages</returns>
public List <Article> ApiMakeList(string url, int haveSoFar)
{// TODO: error handling
List <Article> list = new List <Article>();
string postfix = "";
string newUrl = url;
if (Hack1_12)
{
newUrl = RemoveCmcategory.Replace(newUrl, "");
}
while (list.Count + haveSoFar < Limit)
{
string text = Tools.GetHTML(newUrl + postfix);
if (text.Contains("code=\"cmtitleandcategory\""))
{
if (Hack1_12)
{
throw new ListProviderException("cmtitleandcategory persists.");
}
Hack1_12 = true;
newUrl = RemoveCmcategory.Replace(url, "");
text = Tools.GetHTML(newUrl + postfix);
}
XmlTextReader xml = new XmlTextReader(new StringReader(text));
xml.MoveToContent();
postfix = "";
while (xml.Read())
{
if (xml.Name == "query-continue")
{
XmlReader r = xml.ReadSubtree();
r.Read();
while (r.Read())
{
if (!r.IsStartElement())
{
continue;
}
if (!r.MoveToFirstAttribute())
{
throw new FormatException("Malformed element '" + r.Name + "' in <query-continue>");
}
postfix += "&" + r.Name + "=" + HttpUtility.UrlEncode(r.Value);
}
}
else if (PageElements.Contains(xml.Name) && xml.IsStartElement())
{
int ns = -1;
int.TryParse(xml.GetAttribute("ns"), out ns);
string name = xml.GetAttribute("title");
if (string.IsNullOrEmpty(name))
{
System.Windows.Forms.MessageBox.Show(xml.ReadInnerXml());
break;
}
// HACK: commented out until we make AWB always load namespaces from the wiki,
// to avoid problems with unknown namespace
//if (ns >= 0) list.Add(new Article(name, ns));
//else
list.Add(new Article(name));
}
}
if (string.IsNullOrEmpty(postfix))
{
break;
}
}
return(list);
}
internal List <PlaceholderModel> Parse(string hudOptionsPath)
{
int xmlVersion = GetXmlVersion(hudOptionsPath);
if (xmlVersion < CURRENT_XML_VERSION)
{
UpdateXmlVersion(xmlVersion, hudOptionsPath);
}
Dictionary <string, PlaceholderModel> placeHolders = new Dictionary <string, PlaceholderModel>();
string fileContent = File.ReadAllText(hudOptionsPath);
using (XmlReader xmlReader = XmlReader.Create(new StringReader(fileContent)))
{
while (xmlReader.ReadToFollowing("name"))
{
string name = xmlReader.ReadElementContentAsString();
if (!IsGeometricItem(name))
{
continue;
}
GeometricItem item = GetGeometricItem(name);
if (blackList.IsFiltered(item.Name))
{
continue;
}
if (!placeHolders.ContainsKey(item.Name))
{
PlaceholderModel placeholder = PlaceholderFactory.NewPlaceholder(item.Name);
placeHolders.Add(placeholder.Name, placeholder);
}
xmlReader.ReadToFollowing("value");
xmlReader.MoveToFirstAttribute();
string valueType = xmlReader.Value;
if (valueType != ValueType.VECTOR)
{
throw new Exception($"Expected value is a {ValueType.VECTOR}");
}
xmlReader.MoveToContent();
string value = xmlReader.ReadElementContentAsString();
switch (item.ItemType)
{
case ItemType.POSITION:
placeHolders[item.Name].Position = ParseVector(value);
break;
case ItemType.SIZE:
placeHolders[item.Name].Size = ParseVector(value);
break;
case ItemType.ANCHOR:
placeHolders[item.Name].Anchor = ParseVector(value);
break;
}
}
}
return(placeHolders.Values.ToList());
}
private static void CopyXmlToWriter(XmlReader r, XmlWriter w)
{
while (r.Read())
{
switch (r.NodeType)
{
case XmlNodeType.Element:
w.WriteStartElement(r.Prefix, r.LocalName, r.NamespaceURI);
if (r.HasAttributes)
{
r.MoveToFirstAttribute();
do
{
if (r.LocalName == "xop" && r.Prefix == "xmlns" && r.Value == "http://www.w3.org/2004/08/xop/include")
{
// special case: do not need to rewrite the xmlns:xop for MTOM
// skip
}
else
{
w.WriteAttributeString(r.Prefix, r.LocalName, r.NamespaceURI, r.Value);
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
if (r.IsEmptyElement)
{
w.WriteEndElement();
}
break;
case XmlNodeType.CDATA:
w.WriteCData(r.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
w.WriteWhitespace(r.Value);
break;
case XmlNodeType.Text:
w.WriteString(r.Value);
break;
case XmlNodeType.XmlDeclaration:
string stdAlone = r.GetAttribute("standalone");
if (stdAlone == null)
{
w.WriteStartDocument();
}
else
{
bool isStandAlone = false;
if (bool.TryParse(stdAlone, out isStandAlone))
{
w.WriteStartDocument(isStandAlone);
}
else
{
w.WriteStartDocument();
}
}
break;
case XmlNodeType.Comment:
w.WriteComment(r.Value);
break;
case XmlNodeType.EndElement:
w.WriteFullEndElement();
break;
}
}
}
public override bool MoveToFirstAttribute()
{
return(initial ? false : Reader.MoveToFirstAttribute());
}
/// <summary>
/// Load a model from an input stream
/// </summary>
/// <param name="inputStream">The stream to input from.</param>
/// <returns>A <see cref="Store"/> with the model loaded.</returns>
public Store Load(Stream inputStream)
{
List <string> unrecognizedNamespaces = null;
Stream namespaceStrippedStream = null;
Store store = null;
try
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
ExtensionLoader extensionLoader = myExtensionLoader;
readerSettings.CloseInput = false;
Dictionary <string, ExtensionModelBinding> documentExtensions = null;
using (XmlReader reader = XmlReader.Create(inputStream, readerSettings))
{
reader.MoveToContent();
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.MoveToFirstAttribute())
{
do
{
if (reader.Prefix == "xmlns")
{
string URI = reader.Value;
if (!string.Equals(URI, ORMCoreDomainModel.XmlNamespace, StringComparison.Ordinal) &&
!string.Equals(URI, ORMShapeDomainModel.XmlNamespace, StringComparison.Ordinal) &&
!string.Equals(URI, ORMSerializationEngine.RootXmlNamespace, StringComparison.Ordinal))
{
ExtensionModelBinding?extensionType = extensionLoader.GetExtensionDomainModel(URI);
if (extensionType.HasValue)
{
if (documentExtensions == null)
{
documentExtensions = new Dictionary <string, ExtensionModelBinding>();
}
documentExtensions[URI] = extensionType.Value;
}
else
{
(unrecognizedNamespaces ?? (unrecognizedNamespaces = new List <string>())).Add(URI);
}
}
}
} while (reader.MoveToNextAttribute());
}
}
}
extensionLoader.VerifyRequiredExtensions(ref documentExtensions);
if (unrecognizedNamespaces != null)
{
inputStream.Position = 0;
namespaceStrippedStream = ExtensionLoader.CleanupStream(inputStream, extensionLoader.StandardDomainModels, documentExtensions.Values, unrecognizedNamespaces);
if (namespaceStrippedStream != null)
{
inputStream = namespaceStrippedStream;
}
else
{
unrecognizedNamespaces = null;
}
}
inputStream.Position = 0;
store = CreateStore();
store.UndoManager.UndoState = UndoState.Disabled;
store.LoadDomainModels(extensionLoader.GetRequiredDomainModels(documentExtensions));
try
{
ModelingEventManager eventManager = ModelingEventManager.GetModelingEventManager(store);
using (Transaction t = store.TransactionManager.BeginTransaction("File load and fixup"))
{
foreach (IModelingEventSubscriber subscriber in Utility.EnumerateDomainModels <IModelingEventSubscriber>(store.DomainModels))
{
subscriber.ManageModelingEventHandlers(eventManager, EventSubscriberReasons.DocumentLoading | EventSubscriberReasons.ModelStateEvents, EventHandlerAction.Add);
}
if (inputStream.Length > 1)
{
(new ORMSerializationEngine(store)).Load(inputStream);
}
t.Commit();
}
foreach (IModelingEventSubscriber subscriber in Utility.EnumerateDomainModels <IModelingEventSubscriber>(store.DomainModels))
{
subscriber.ManageModelingEventHandlers(eventManager, EventSubscriberReasons.DocumentLoaded | EventSubscriberReasons.ModelStateEvents, EventHandlerAction.Add);
}
store.UndoManager.UndoState = UndoState.Enabled;
}
catch (TypeInitializationException ex)
{
// If the type that failed to load is an extensions, then remove it from
// the list of available extensions and try again.
if (documentExtensions != null)
{
string typeName = ex.TypeName;
foreach (KeyValuePair <string, ExtensionModelBinding> pair in documentExtensions)
{
Type testType = pair.Value.Type;
if (testType.FullName == typeName)
{
if (extensionLoader.CustomExtensionUnavailable(testType))
{
return(Load(inputStream));
}
break;
}
}
}
throw;
}
}
finally
{
if (namespaceStrippedStream != null)
{
namespaceStrippedStream.Dispose();
}
}
return(store);
}
/// <summary>读取</summary>
/// <param name="table"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static IDataTable ReadXml(this IDataTable table, XmlReader reader)
{
// 读属性
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
ReadXml(reader, table);
}
reader.ReadStartElement();
// 读字段
reader.MoveToElement();
// 有些数据表模型没有字段
if (reader.NodeType == XmlNodeType.Element && reader.Name.EqualIgnoreCase("Table"))
{
return(table);
}
while (reader.NodeType != XmlNodeType.EndElement)
//while (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Columns":
reader.ReadStartElement();
var id = 1;
while (reader.IsStartElement())
{
var dc = table.CreateColumn();
dc.ID = id++;
var v = reader.GetAttribute("DataType");
if (v != null)
{
dc.DataType = v.GetTypeEx();
v = reader.GetAttribute("Length");
var len = 0;
if (v != null && Int32.TryParse(v, out len))
{
dc.Length = len;
}
// 含有ID表示是旧的，不需要特殊处理，否则一些默认值会不对
v = reader.GetAttribute("ID");
if (v == null)
{
dc = Fix(dc, dc);
}
}
(dc as IXmlSerializable).ReadXml(reader);
table.Columns.Add(dc);
}
reader.ReadEndElement();
// 修正可能的主字段
if (!table.Columns.Any(e => e.Master))
{
var f = table.Columns.FirstOrDefault(e => e.Name.EqualIgnoreCase("Name", "Title"));
if (f != null)
{
f.Master = true;
}
}
break;
case "Indexes":
reader.ReadStartElement();
while (reader.IsStartElement())
{
var di = table.CreateIndex();
(di as IXmlSerializable).ReadXml(reader);
di.Fix();
table.Indexes.Add(di);
}
reader.ReadEndElement();
break;
case "Relations":
reader.ReadStartElement();
while (reader.IsStartElement())
{
var dr = table.CreateRelation();
(dr as IXmlSerializable).ReadXml(reader);
if (table.GetRelation(dr) == null)
{
table.Relations.Add(dr);
}
}
reader.ReadEndElement();
break;
default:
// 这里必须处理，否则加载特殊Xml文件时将会导致死循环
reader.Read();
break;
}
}
//if (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement) reader.Read();
//reader.ReadEndElement();
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
return(table);
}
protected void Process(CXmlBase rParentNode)
{
CXmlNode rNewNode;
while (true)
{
//We want to pop if Read() returns false, aka EOF
if (_fReadNode)
{
if (!_rXmlReader.Read())
{
DebugTrace("Read() == false");
return;
}
}
else
{
if (!_rXmlReader.ReadAttributeValue())
{
DebugTrace("ReadAttributeValue() == false");
return;
}
}
DebugTrace(_rXmlReader);
//We also want to pop if we get an EndElement or EndEntity
if (_rXmlReader.NodeType == XmlNodeType.EndElement ||
_rXmlReader.NodeType == XmlNodeType.EndEntity)
{
DebugTrace("NodeType == EndElement or EndEntity");
return;
}
rNewNode = GetNewNode(_rXmlReader);
rNewNode._nDepth = _rXmlReader.Depth;
// Test for MixedContent and set Indent if necessary
if ((rParentNode.Flags & NodeFlags.MixedContent) != 0)
{
rNewNode._eFlags |= NodeFlags.MixedContent;
// Indent is off for all new nodes
}
else
{
rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent for current Node
}
// Set all Depth 0 nodes to No Mixed Content and Indent True
if (_rXmlReader.Depth == 0)
{
rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent
rNewNode._eFlags &= ~NodeFlags.MixedContent; // Turn off MixedContent
}
rParentNode.InsertNode(rNewNode);
//Do some special stuff based on NodeType
switch (_rXmlReader.NodeType)
{
case XmlNodeType.EntityReference:
if (_eValidationMode == ValidationType.DTD)
{
_rXmlReader.ResolveEntity();
Process(rNewNode);
}
break;
case XmlNodeType.Element:
if (_rXmlReader.MoveToFirstAttribute())
{
do
{
CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader);
rNewNode.AddAttribute(rNewAttribute);
if (_fExpandAttributeValues)
{
DebugTrace("Attribute: " + _rXmlReader.Name);
_fReadNode = false;
Process(rNewAttribute);
_fReadNode = true;
}
else
{
CXmlNode rValueNode = new CXmlNode("", "", XmlNodeType.Text);
rValueNode._eFlags = _eDefaultFlags | NodeFlags.HasValue;
rValueNode._strValue = _rXmlReader.Value;
DebugTrace(" Value=" + rValueNode.Value, _rXmlReader.Depth + 1);
rNewAttribute.InsertNode(rValueNode);
}
} while (_rXmlReader.MoveToNextAttribute());
}
if ((rNewNode.Flags & NodeFlags.EmptyElement) == 0)
{
Process(rNewNode);
}
break;
case XmlNodeType.XmlDeclaration:
if (_rXmlReader is XmlTextReader)
{
_eEncoding = ((XmlTextReader)_rXmlReader).Encoding;
}
#pragma warning disable 0618
else if (_rXmlReader is XmlValidatingReader)
{
_eEncoding = ((XmlValidatingReader)_rXmlReader).Encoding;
}
#pragma warning restore 0618
else
{
string strValue = rNewNode.NodeValue;
int nPos = strValue.IndexOf("encoding");
if (nPos != -1)
{
int nEnd;
nPos = strValue.IndexOf("=", nPos); //Find the = sign
nEnd = strValue.IndexOf("\"", nPos) + 1; //Find the next " character
nPos = strValue.IndexOf("'", nPos) + 1; //Find the next ' character
if (nEnd == 0 || (nPos < nEnd && nPos > 0)) //Pick the one that's closer to the = sign
{
nEnd = strValue.IndexOf("'", nPos);
}
else
{
nPos = nEnd;
nEnd = strValue.IndexOf("\"", nPos);
}
string sEncodeName = strValue.Substring(nPos, nEnd - nPos);
DebugTrace("XMLDecl contains encoding " + sEncodeName);
if (sEncodeName.ToUpper() == "UCS-2")
{
sEncodeName = "unicode";
}
_eEncoding = System.Text.Encoding.GetEncoding(sEncodeName);
}
}
break;
case XmlNodeType.ProcessingInstruction:
break;
case XmlNodeType.Text:
if (!_fReadNode)
{
rNewNode._eFlags = _eDefaultFlags | NodeFlags.AttributeTextNode;
}
rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node
rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node
rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.CDATA:
rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node
rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node
rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node
break;
case XmlNodeType.Comment:
case XmlNodeType.Notation:
break;
case XmlNodeType.DocumentType:
if (_rXmlReader.MoveToFirstAttribute())
{
do
{
CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader);
rNewNode.AddAttribute(rNewAttribute);
CXmlNode rValueNode = new CXmlNode(_rXmlReader);
rValueNode._strValue = _rXmlReader.Value;
rNewAttribute.InsertNode(rValueNode);
} while (_rXmlReader.MoveToNextAttribute());
}
break;
default:
_output.WriteLine("UNHANDLED TYPE, " + _rXmlReader.NodeType.ToString() + " IN Process()!");
break;
}
}
}
private object ParseReadXmlDefault(XmlReader reader, Type valueType)
{
var key = "";
var values = new Dictionary <string, string>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
values.Add(reader.Name, reader.Value);
while (reader.MoveToNextAttribute())
{
goto case XmlNodeType.Attribute;
}
reader.MoveToElement();
break;
case XmlNodeType.Element:
if (reader.Depth == 0)
{
continue;
}
key = reader.Name;
if (reader.HasAttributes)
{
if (reader.MoveToFirstAttribute())
{
goto case XmlNodeType.Attribute;
}
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
values.AddOrUpdate(key, reader.Value);
break;
}
}
var constructors = valueType.GetConstructors(ReflectionUtility.BindingInstancePublicAndPrivate).ToList();
var properties = valueType.GetProperties(ReflectionUtility.BindingInstancePublicAndPrivate).Where(info => info.CanWrite).ToDictionary(info => info.Name);
var propertyNames = properties.Select(info => info.Key).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).ToList();
List <object> args = new List <object>();
foreach (var ctr in constructors)
{
var arguments = ctr.GetParameters();
var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count();
if (arguments.Length == argumentsLength)
{
foreach (var arg in arguments)
{
args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType));
}
break;
}
}
if (args.Count == 0)
{
var staticMethods = valueType.GetMethods(ReflectionUtility.BindingInstancePublicAndPrivateNoneInheritedIncludeStatic).Where(info => info.ReturnType == valueType && info.IsStatic && !info.IsSpecialName).ToList();
foreach (var method in staticMethods)
{
var arguments = method.GetParameters();
var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count();
if (arguments.Length == argumentsLength)
{
foreach (var arg in arguments)
{
args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType));
}
return(method.Invoke(null, args.ToArray()));
}
}
throw new SerializationException("Unable to find a suitable constructor or static method for deserialization.");
}
var instance = Activator.CreateInstance(valueType, args.ToArray());
foreach (var propertyName in propertyNames)
{
var property = properties[propertyName];
property.SetValue(instance, ObjectConverter.ChangeType(values.First(pair => pair.Key == propertyName).Value, property.PropertyType));
}
return(instance);
}
internal static string GetComparableForm(StringBuilder builder, XmlReader reader)
{
List <Attr> attrSet = new List <Attr>();
int valueLength = -1;
while (!reader.EOF)
{
XmlNodeType type = reader.MoveToContent();
switch (type)
{
case XmlNodeType.Element:
CompleteValue(builder, valueLength);
valueLength = -1;
builder.Append("<");
AppendString(builder, reader.LocalName);
builder.Append(":");
AppendString(builder, reader.NamespaceURI);
builder.Append(" ");
// Scan attributes
attrSet.Clear();
if (reader.MoveToFirstAttribute())
{
do
{
// Ignore namespaces
if (reader.Prefix == "xmlns" || reader.Name == "xmlns")
{
continue;
}
if (reader.LocalName == AddressingStrings.IsReferenceParameter && reader.NamespaceURI == Addressing10Strings.Namespace)
{
continue; // ignore IsReferenceParameter
}
string val = reader.Value;
if ((reader.LocalName == TypeLN && reader.NamespaceURI == XsiNs) ||
(reader.NamespaceURI == SerNs && (reader.LocalName == ItemTypeLN || reader.LocalName == FactoryTypeLN)))
{
XmlUtil.ParseQName(reader, val, out string local, out string ns);
val = local + "^" + local.Length.ToString(CultureInfo.InvariantCulture) + ":" + ns + "^" + ns.Length.ToString(CultureInfo.InvariantCulture);
}
else if (reader.LocalName == XD.UtilityDictionary.IdAttribute.Value && reader.NamespaceURI == XD.UtilityDictionary.Namespace.Value)
{
// ignore wsu:Id attributes added by security to sign the header
continue;
}
attrSet.Add(new Attr(reader.LocalName, reader.NamespaceURI, val));
} while (reader.MoveToNextAttribute());
}
reader.MoveToElement();
if (attrSet.Count > 0)
{
attrSet.Sort();
for (int i = 0; i < attrSet.Count; ++i)
{
Attr a = attrSet[i];
AppendString(builder, a._local);
builder.Append(":");
AppendString(builder, a._ns);
builder.Append("=\"");
AppendString(builder, a._val);
builder.Append("\" ");
}
}
if (reader.IsEmptyElement)
{
builder.Append("></>"); // Should be the same as an empty tag.
}
else
{
builder.Append(">");
}
break;
case XmlNodeType.EndElement:
CompleteValue(builder, valueLength);
valueLength = -1;
builder.Append("</>");
break;
// Need to escape CDATA values
case XmlNodeType.CDATA:
CompleteValue(builder, valueLength);
valueLength = -1;
builder.Append("<![CDATA[");
AppendString(builder, reader.Value);
builder.Append("]]>");
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Text:
if (valueLength < 0)
{
valueLength = builder.Length;
}
builder.Append(reader.Value);
break;
default:
// Do nothing
break;
}
reader.Read();
}
return(builder.ToString());
}
private void getModels(string filePath)
{
Stream stream = null;
ImportedModel currentModel = null;
IParameterSet currentSet = null;
IGroup group = null;
bool parametersXmlArea = true;
//int i = 0;
try {
using (XmlReader reader = ProjectBase.getXmlReader(filePath, out stream)) {
string modelClass;
string name;
//reader.ReadToFollowing("models");
while (reader.Read() && parametersXmlArea)
{
switch (reader.Name)
{
case "spectra":
if (reader.MoveToFirstAttribute())
{
modelClass = String.Empty;
name = String.Empty;
do
{
switch (reader.Name)
{
case "name": name = reader.Value; break;
case "class": modelClass = reader.Value; break; // AvailableAssemblies.getModel(reader.Value); break;
}
} while (reader.MoveToNextAttribute());
if (name != String.Empty && modelClass != String.Empty)
{
_importedModels.Add(currentModel = new ImportedModel(modelClass, name));
_modelNames.Add(name);
}
}
reader.MoveToElement();
break;
case "spectrum":
//only start elemement has attributes. end elements are not analysed
if (reader.IsStartElement())
{
if (currentModel == null)
{
throw new Exception();
}
//if (currentSet != null)
// currentModel.parameters.Add(currentSet);
if (reader.ReadToFollowing("ps"))
{
currentSet = new ParameterSet();
}
}
else
{
currentModel.parameters.Add(currentSet);
reader.MoveToElement();
currentSet = null;
}
break;
case "group":
if (reader.HasAttributes)
{
if (currentSet == null)
{
throw new Exception();
}
//while (reader.Read()) { //groups
if (reader.Name == "group")
{
XmlReader groupReader = reader.ReadSubtree();
group = SpectrumBase.getGroup(groupReader, null, currentModel.model);
currentSet.addGroup(group);
groupReader.Close();
}
}
break;
case "models": if (!reader.HasAttributes)
{
parametersXmlArea = false;
}
break;
}
}
if (_modelNames.Count > 0)
{
_modelNames.Insert(0, "(none)");
}
}
} catch (Exception) {
throw new ImportException(String.Format("Failed to import parameters from {0}", filePath));
} finally {
if (stream != null)
{
stream.Close();
}
}
if (_modelNames.Count == 0)
{
throw new ImportException(String.Format("{0}\ndoesn't contain any importable parameter values.", filePath));
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">
/// The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.
/// </param>
public void ReadXml(XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
// var isSimpleKey = false;
bool isSimpleKey = _overide ? false : typeof(TKey) == typeof(int) || typeof(TKey) == typeof(string);
while (reader.NodeType != XmlNodeType.EndElement)
{
if (isSimpleKey)
{
TKey key = default(TKey);
reader.Read();
reader.MoveToFirstAttribute();
if (typeof(TKey) == typeof(int))
{
int realKey;
if (int.TryParse(reader.Value, out realKey))
{
key = (TKey)(object)realKey;
}
}
else
{
key = (TKey)(object)reader.Value;
}
Console.WriteLine(key);
reader.MoveToContent();
reader.Read();
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.Read();
reader.ReadEndElement();
Add(key, value);
}
else
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
}
if (!isSimpleKey)
{
reader.ReadEndElement();
}
}
public override bool MoveToFirstAttribute()
{
return(_me.MoveToFirstAttribute());
}
public bool parse(string pszFile)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
CCContent data = CCApplication.sharedApplication().content.Load <CCContent>(pszFile);
string str = data.Content;
if (data == null)
{
return(false);
}
TextReader textReader = new StringReader(str);
XmlReaderSettings setting = new XmlReaderSettings();
setting.DtdProcessing = DtdProcessing.Ignore;
XmlReader xmlReader = XmlReader.Create(textReader, setting);
int dataindex = 0;
int Width = 0;
int Height = 0;;
while (xmlReader.Read())
{
string name = xmlReader.Name;
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
string[] attrs = null;
if (name == "map")
{
Width = ccUtils.ccParseInt(xmlReader.GetAttribute("width"));
Height = ccUtils.ccParseInt(xmlReader.GetAttribute("height"));
}
if (xmlReader.HasAttributes)
{
attrs = new string[xmlReader.AttributeCount * 2];
xmlReader.MoveToFirstAttribute();
int i = 0;
attrs[0] = xmlReader.Name;
attrs[1] = xmlReader.Value;
i += 2;
while (xmlReader.MoveToNextAttribute())
{
attrs[i] = xmlReader.Name;
attrs[i + 1] = xmlReader.Value;
i += 2;
}
// Move the reader back to the element node.
xmlReader.MoveToElement();
}
startElement(this, name, attrs);
byte[] buffer = null;
//read data content of tmx file
if (name == "data")
{
if (attrs != null)
{
string encoding = "";
for (int i = 0; i < attrs.Length; i++)
{
if (attrs[i] == "encoding")
{
encoding = attrs[i + 1];
}
}
if (encoding == "base64")
{
int dataSize = (Width * Height * 4) + 1024;
buffer = new byte[dataSize];
xmlReader.ReadElementContentAsBase64(buffer, 0, dataSize);
}
else
{
string value = xmlReader.ReadElementContentAsString();
buffer = Encoding.UTF8.GetBytes(value);
}
}
textHandler(this, buffer, buffer.Length);
endElement(this, name);
}
else
if (name == "key" || name == "integer" || name == "real" || name == "string" || name == "true" || name == "false") // http://www.cocos2d-x.org/boards/17/topics/11355
{
string value = xmlReader.ReadElementContentAsString();
buffer = Encoding.UTF8.GetBytes(value);
textHandler(this, buffer, buffer.Length);
endElement(this, name);
}
else
{
IXmlLineInfo info = (IXmlLineInfo)xmlReader;
CCLog.Log("Failed to handle XML tag: " + name + " in " + info.LineNumber + "@" + info.LinePosition + ":" + pszFile);
}
break;
case XmlNodeType.EndElement:
endElement(this, xmlReader.Name);
dataindex++;
break;
default:
break;
}
}
return(true);
}
public override bool MoveToFirstAttribute()
{
return(innerReader.MoveToFirstAttribute());
}
// read
void ReadXml(XmlReader reader, bool fromSerializable)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
SetItem(CreateItemInstance());
reader.MoveToContent();
if (reader.MoveToFirstAttribute())
{
do
{
if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
continue;
}
if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, Item, Version) && PreserveAttributeExtensions)
{
Item.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
} while (reader.MoveToNextAttribute());
}
reader.ReadStartElement();
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (reader.NodeType != XmlNodeType.Element)
{
throw new XmlException("Only element node is expected under 'entry' element");
}
if (reader.NamespaceURI == AtomNamespace)
{
switch (reader.LocalName)
{
case "author":
SyndicationPerson p = Item.CreatePerson();
ReadPerson(reader, p);
Item.Authors.Add(p);
continue;
case "category":
SyndicationCategory c = Item.CreateCategory();
ReadCategory(reader, c);
Item.Categories.Add(c);
continue;
case "contributor":
p = Item.CreatePerson();
ReadPerson(reader, p);
Item.Contributors.Add(p);
continue;
case "id":
Item.Id = reader.ReadElementContentAsString();
continue;
case "link":
SyndicationLink l = Item.CreateLink();
ReadLink(reader, l);
Item.Links.Add(l);
continue;
case "published":
Item.PublishDate = XmlConvert.ToDateTimeOffset(reader.ReadElementContentAsString());
continue;
case "rights":
Item.Copyright = ReadTextSyndicationContent(reader);
continue;
case "source":
Item.SourceFeed = ReadSourceFeed(reader);
continue;
case "summary":
Item.Summary = ReadTextSyndicationContent(reader);
continue;
case "title":
Item.Title = ReadTextSyndicationContent(reader);
continue;
case "updated":
Item.LastUpdatedTime = XmlConvert.ToDateTimeOffset(reader.ReadElementContentAsString());
continue;
// Atom 1.0 does not specify "content" element, but it is required to distinguish Content property from extension elements.
case "content":
if (reader.GetAttribute("src") != null)
{
Item.Content = new UrlSyndicationContent(CreateUri(reader.GetAttribute("src")), reader.GetAttribute("type"));
reader.Skip();
continue;
}
switch (reader.GetAttribute("type"))
{
case "text":
case "html":
case "xhtml":
Item.Content = ReadTextSyndicationContent(reader);
continue;
default:
SyndicationContent content;
if (!TryParseContent(reader, Item, reader.GetAttribute("type"), Version, out content))
{
Item.Content = new XmlSyndicationContent(reader);
}
continue;
}
}
}
if (!TryParseElement(reader, Item, Version))
{
if (PreserveElementExtensions)
{
// FIXME: what to specify for maxExtensionSize
LoadElementExtensions(reader, Item, int.MaxValue);
}
else
{
reader.Skip();
}
}
}
reader.ReadEndElement(); // </item>
}
/// <summary>
/// Processes a GPX file, invoking callbacks on a <see cref="GpxVisitorBase"/> instance as
/// elements are observed.
/// </summary>
/// <param name="reader">
/// The <see cref="XmlReader"/> to read from.
/// </param>
/// <param name="settings">
/// The <see cref="GpxReaderSettings"/> instance to use to control how GPX instances get
/// read in, or <c>null</c> to use a general-purpose default.
/// </param>
/// <param name="visitor">
/// The <see cref="GpxVisitorBase"/> instance that will receive callbacks.
/// </param>
/// <remarks>
/// This method is the "core" reading method; everything else builds off of this.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// Thrown when <paramref name="reader"/> or <paramref name="visitor"/> is
/// <see langword="null"/>.
/// </exception>
/// <exception cref="XmlException">
/// Thrown when <paramref name="reader"/> does not specify a valid GPX file (i.e., cases
/// where XSD schema validation would fail, and/or some values are <b>well</b> outside of
/// the slightly stricter, but still completely reasonable, limits imposed by the idiomatic
/// .NET data types above and beyond the XSD limits).
/// </exception>
public static void Read(XmlReader reader, GpxReaderSettings settings, GpxVisitorBase visitor)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
if (visitor is null)
{
throw new ArgumentNullException(nameof(visitor));
}
settings = settings ?? new GpxReaderSettings();
while (reader.ReadToFollowing("gpx", Helpers.GpxNamespace))
{
string version = null;
string creator = settings.DefaultCreatorIfMissing;
for (bool hasAttribute = reader.MoveToFirstAttribute(); hasAttribute; hasAttribute = reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "version":
version = reader.Value;
break;
case "creator":
creator = reader.Value;
break;
}
}
if (version != "1.1" && !settings.IgnoreVersionAttribute)
{
throw new XmlException("'version' must be '1.1'");
}
if (creator is null)
{
throw new XmlException("'creator' must be specified");
}
if (!ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement))
{
visitor.VisitMetadata(new GpxMetadata(creator));
break;
}
bool expectingMetadata = true;
bool expectingExtensions = true;
do
{
if (expectingMetadata)
{
expectingMetadata = false;
if (reader.Name == "metadata")
{
ReadMetadata(reader, settings, creator, visitor);
}
else
{
visitor.VisitMetadata(new GpxMetadata(creator));
}
}
switch (reader.Name)
{
// ideally, it should all be in this order, since the XSD validation
// would fail otherwise, but whatever.
case "wpt":
ReadWaypoint(reader, settings, visitor);
break;
case "rte":
ReadRoute(reader, settings, visitor);
break;
case "trk":
ReadTrack(reader, settings, visitor);
break;
case "extensions" when expectingExtensions:
expectingExtensions = false;
var extensionElement = (XElement)XNode.ReadFrom(reader);
object extensions = settings.ExtensionReader.ConvertGpxExtensionElement(extensionElement.Elements());
if (!(extensions is null))
{
visitor.VisitExtensions(extensions);
}
break;
}
}while (ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement));
}
}
void ReadLink(XmlReader reader, SyndicationLink link)
{
if (reader.MoveToFirstAttribute())
{
do
{
if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
continue;
}
if (reader.NamespaceURI == String.Empty)
{
switch (reader.LocalName)
{
case "href":
link.Uri = CreateUri(reader.Value);
continue;
case "rel":
link.RelationshipType = reader.Value;
continue;
case "type":
link.MediaType = reader.Value;
continue;
case "length":
link.Length = XmlConvert.ToInt64(reader.Value);
continue;
case "title":
link.Title = reader.Value;
continue;
}
}
if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, link, Version) && PreserveAttributeExtensions)
{
link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
if (!reader.IsEmptyElement)
{
reader.Read();
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (!TryParseElement(reader, link, Version))
{
if (PreserveElementExtensions)
{
// FIXME: what should be used for maxExtenswionSize
LoadElementExtensions(reader, link, int.MaxValue);
}
else
{
reader.Skip();
}
}
}
}
reader.Read(); // </link> or <link ... />
}
