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");
}
}
private static OutputGroup ReadOutputElement(XmlReader reader)
{
var outputNode = new OutputGroup();
while (reader.Read())
{
// get the attributes
if (reader.Name == OutputElementName && reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case PathAttributeName:
outputNode.Path = reader.Value;
break;
case EncodingAttributeName:
outputNode.EncodingName = reader.Value;
break;
case TypeAttributeName:
switch (reader.Value.ToUpperInvariant())
{
case "JS":
case "JAVASCRIPT":
case "JSCRIPT":
outputNode.CodeType = CodeType.JavaScript;
break;
case "CSS":
case "STYLESHEET":
case "STYLESHEETS":
outputNode.CodeType = CodeType.StyleSheet;
break;
}
break;
case MapPathAttributeName:
outputNode.SymbolMap = new SymbolMap()
{
Path = reader.Value
};
break;
}
}
// back to element
reader.MoveToElement();
}
// process child elements
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case ArgumentsElementName:
ReadArgumentsElement(reader.ReadSubtree(), outputNode.Arguments);
break;
case RenameElementName:
ReadRenameElement(reader.ReadSubtree(), outputNode.RenameIdentifiers);
break;
case NoRenameElementName:
ReadNoRenameElement(reader.ReadSubtree(), outputNode.NoRenameIdentifiers);
break;
case SymbolMapElementName:
outputNode.SymbolMap = ReadSymbolMapElement(reader.ReadSubtree());
break;
case ResourceElementName:
outputNode.Resources.Add(ReadResourceElement(reader.ReadSubtree()));
break;
case InputElementName:
outputNode.Inputs.Add(ReadInputElement(reader.ReadSubtree()));
break;
}
}
}
reader.Close();
return(outputNode);
}
private void AdvanceParser()
{
if (!_canPush)
{
return;
}
// Check for pending events
if (_pendingEvent != null)
{
Push(_pendingEvent);
if (_pendingEvent is EndDocument)
{
_documentStarted = false;
}
_pendingEvent = null;
return;
}
// Check for empty buffer condition.
// XmlParser requires that there are at least 6 characters in the stream,
// or it will read the stream multiple times to get more data,
// which will result in premature EOF in our case.
if (_feeder.Length - _feeder.Position < 7 && DataAvailable)
{
GetNextStreamBuffer();
return;
}
if (_parser == null)
{
_parser = XmlReader.Create(_feeder, new XmlReaderSettings
{
IgnoreComments = false,
IgnoreProcessingInstructions = false,
IgnoreWhitespace = true,
CloseInput = false,
ConformanceLevel = ConformanceLevel.Fragment
});
}
try
{
_hasNext = _parser.Read();
}
catch (Exception e)
{
FailStage(e);
return;
}
if (!_hasNext)
{
if (!_parser.EOF)
{
if (IsClosed(_stage.In))
{
_parser.Close();
FailStage(new IllegalStateException("Stream finished before event was fully parsed."));
}
else
{
_parser.Close();
FailStage(new IllegalStateException("Unknown error occured. Parsing finished before stream was finished."));
}
}
CompleteStage();
return;
}
switch (_parser.NodeType)
{
// START_ELEMENT
case XmlNodeType.Element:
var attributes = new Dictionary <string, string>();
while (_parser.MoveToNextAttribute())
{
attributes.Add(_parser.LocalName, _parser.Value);
}
_parser.MoveToElement();
if (_parser.Depth == 0 && !_documentStarted)
{
// START_DOCUMENT
_documentStarted = true;
Push(StartDocument.Instance);
_pendingEvent = new StartElement(_parser.LocalName, attributes);
}
else
{
Push(new StartElement(_parser.LocalName, attributes));
}
return;
// END_ELEMENT
case XmlNodeType.EndElement:
Push(new EndElement(_parser.LocalName));
if (_parser.Depth == 0)
{
// END_DOCUMENT
_pendingEvent = EndDocument.Instance;
}
return;
// CHARACTERS
case XmlNodeType.Text:
Push(new Characters(_parser.Value));
return;
// PROCESSING_INSTRUCTION
case XmlNodeType.ProcessingInstruction:
if (_parser.Depth == 0 && !_documentStarted)
{
// START_DOCUMENT
_documentStarted = true;
Push(StartDocument.Instance);
_pendingEvent = new ProcessingInstruction(_parser.Name, _parser.Value);
}
else
{
Push(new ProcessingInstruction(_parser.Name, _parser.Value));
}
return;
// COMMENT
case XmlNodeType.Comment:
Push(new Comment(_parser.Value));
return;
// CDATA
case XmlNodeType.CDATA:
Push(new CData(_parser.Value));
return;
// Do not support DTD, SPACE, NAMESPACE, NOTATION_DECLARATION, ENTITY_DECLARATION
// ATTRIBUTE is handled in START_ELEMENT implicitly
// EVENT_INCOMPLETE is handled directly in AsyncXmlStream
default:
if (_feeder.Length - _feeder.Position < 7 && DataAvailable)
{
GetNextStreamBuffer();
return;
}
AdvanceParser();
return;
}
}
public void ValidateWithXmlReader(XmlSchemaSet schemas, string xml, string xsd)
{
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
XmlSchemaValidationFlags validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints |
XmlSchemaValidationFlags.AllowXmlAttributes;
XmlSchemaValidator validator = new XmlSchemaValidator(namespaceManager.NameTable, schemas, namespaceManager, validationFlags);
validator.Initialize();
using (XmlReader r = XmlReader.Create(xsd))
{
while (r.Read())
{
switch (r.NodeType)
{
case XmlNodeType.Element:
namespaceManager.PushScope();
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
namespaceManager.AddNamespace(r.LocalName, r.Value);
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
validator.ValidateElement(r.LocalName, r.NamespaceURI, null, null, null, null, null);
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI != "http://www.w3.org/2000/xmlns/")
{
validator.ValidateAttribute(r.LocalName, r.NamespaceURI, r.Value, null);
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
validator.ValidateEndOfAttributes(null);
if (r.IsEmptyElement)
{
goto case XmlNodeType.EndElement;
}
break;
case XmlNodeType.EndElement:
validator.ValidateEndElement(null);
namespaceManager.PopScope();
break;
case XmlNodeType.Text:
validator.ValidateText(r.Value);
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
validator.ValidateWhitespace(r.Value);
break;
default:
break;
}
}
validator.EndValidation();
}
XmlReaderSettings rs = new XmlReaderSettings();
rs.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
rs.ValidationType = ValidationType.Schema;
rs.Schemas.XmlResolver = new XmlUrlResolver();
rs.Schemas.Add(null, XmlReader.Create(xsd));
using (XmlReader r = XmlReader.Create(xml, rs))
{
while (r.Read())
{
;
}
}
Assert.Equal(warningCount, 0);
Assert.Equal(errorCount, 0);
}
static IList <KeyValuePair <XmlName, INode> > ParseXamlAttributes(XmlReader reader, out IList <KeyValuePair <string, string> > xmlns)
{
Debug.Assert(reader.NodeType == XmlNodeType.Element);
var attributes = new List <KeyValuePair <XmlName, INode> >();
xmlns = new List <KeyValuePair <string, string> >();
for (var i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
//skip xmlns
if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
xmlns.Add(new KeyValuePair <string, string>(reader.LocalName, reader.Value));
continue;
}
var namespaceUri = reader.NamespaceURI;
if (reader.LocalName.Contains(".") && namespaceUri == "")
{
namespaceUri = ((IXmlNamespaceResolver)reader).LookupNamespace("");
}
var propertyName = new XmlName(namespaceUri, reader.LocalName);
object value = reader.Value;
if (reader.NamespaceURI == X2006Uri)
{
switch (reader.LocalName)
{
case "Key":
propertyName = XmlName.xKey;
break;
case "Name":
propertyName = XmlName.xName;
break;
case "Class":
case "FieldModifier":
continue;
default:
Debug.WriteLine("Unhandled attribute {0}", reader.Name);
continue;
}
}
if (reader.NamespaceURI == X2009Uri)
{
switch (reader.LocalName)
{
case "Key":
propertyName = XmlName.xKey;
break;
case "Name":
propertyName = XmlName.xName;
break;
case "TypeArguments":
propertyName = XmlName.xTypeArguments;
value = TypeArgumentsParser.ParseExpression((string)value, (IXmlNamespaceResolver)reader, (IXmlLineInfo)reader);
break;
case "DataType":
propertyName = XmlName.xDataType;
break;
case "Class":
case "FieldModifier":
continue;
case "FactoryMethod":
propertyName = XmlName.xFactoryMethod;
break;
case "Arguments":
propertyName = XmlName.xArguments;
break;
default:
Debug.WriteLine("Unhandled attribute {0}", reader.Name);
continue;
}
}
var propertyNode = GetValueNode(value, reader);
attributes.Add(new KeyValuePair <XmlName, INode>(propertyName, propertyNode));
}
reader.MoveToElement();
return(attributes);
}
public void XmlSchemaValidatorDoesNotEnforceIdentityConstraintsOnDefaultAttributesInSomeCases()
{
Initialize();
string xml = @"<?xml version='1.0'?>
<root xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:noNamespaceSchemaLocation='idF016.xsd'>
<uid val='test'/> <uid/></root>" ;
string xsd = @"<?xml version='1.0'?>
<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema' elementFormDefault='qualified'>
<xsd:element name='root'>
<xsd:complexType>
<xsd:sequence>
<xsd:element ref='uid' maxOccurs='unbounded'/>
</xsd:sequence>
</xsd:complexType>
<xsd:unique id='foo123' name='uuid'>
<xsd:selector xpath='.//uid'/>
<xsd:field xpath='@val'/>
</xsd:unique>
</xsd:element>
<xsd:element name='uid' nillable='true'>
<xsd:complexType>
<xsd:attribute name='val' type='xsd:string' default='test'/>
</xsd:complexType>
</xsd:element>
</xsd:schema>";
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add(null, XmlReader.Create(new StringReader(xsd)));
schemas.Compile();
XmlSchemaValidationFlags validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints |
XmlSchemaValidationFlags.AllowXmlAttributes;
XmlSchemaValidator validator = new XmlSchemaValidator(namespaceManager.NameTable, schemas, namespaceManager, validationFlags);
validator.Initialize();
using (XmlReader r = XmlReader.Create(new StringReader(xsd)))
{
while (r.Read())
{
switch (r.NodeType)
{
case XmlNodeType.Element:
namespaceManager.PushScope();
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
namespaceManager.AddNamespace(r.LocalName, r.Value);
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
validator.ValidateElement(r.LocalName, r.NamespaceURI, null, null, null, null, null);
if (r.MoveToFirstAttribute())
{
do
{
if (r.NamespaceURI != "http://www.w3.org/2000/xmlns/")
{
validator.ValidateAttribute(r.LocalName, r.NamespaceURI, r.Value, null);
}
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
validator.ValidateEndOfAttributes(null);
if (r.IsEmptyElement)
{
goto case XmlNodeType.EndElement;
}
break;
case XmlNodeType.EndElement:
validator.ValidateEndElement(null);
namespaceManager.PopScope();
break;
case XmlNodeType.Text:
validator.ValidateText(r.Value);
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
validator.ValidateWhitespace(r.Value);
break;
default:
break;
}
}
validator.EndValidation();
}
XmlReaderSettings rs = new XmlReaderSettings();
rs.ValidationType = ValidationType.Schema;
rs.Schemas.Add(null, XmlReader.Create(new StringReader(xsd)));
using (XmlReader r = XmlReader.Create(new StringReader(xml), rs))
{
try
{
while (r.Read())
{
;
}
}
catch (XmlSchemaValidationException e) { _output.WriteLine(e.Message); return; }
}
Assert.True(false);
}
public override bool MoveToElement()
{
this.IsCalled = true; return(_wrappedreader.MoveToElement());
}
public override bool MoveToElement()
{
return(initial ? false : Reader.MoveToElement());
}
/// <summary>
/// Global eventing Subscribe stub.
/// </summary>
/// <param name="header">Header object.</param>
/// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param>
/// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param>
/// <returns>Byte array containing a Subscribe response.</returns>
internal byte[] Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
{
// Parse Subscribe Request
/////////////////////////////
DpwsWseEventSink eventSink = new DpwsWseEventSink();
try
{
reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.EndTo = new WsWsaEndpointRef(reader);
}
reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.NotifyTo = new WsWsaEndpointRef(reader);
}
else
{
throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable);
}
reader.ReadEndElement();
if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
{
long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds;
if (expires > 0)
{
eventSink.Expires = expires;
}
else
{
throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
}
}
else
{
// Never Expires
eventSink.Expires = -1;
}
if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri))
{
if (reader.MoveToAttribute("Dialect") == false || reader.Value != "http://schemas.xmlsoap.org/ws/2006/02/devprof/Action")
{
throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable);
}
reader.MoveToElement();
String filters = reader.ReadElementString();
if (filters != String.Empty)
{
eventSink.Filters = filters.Split(' ');
}
}
XmlReaderHelper.SkipAllSiblings(reader);
reader.ReadEndElement(); // Subscribe
}
catch (XmlException e)
{
throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
}
// Parse urn:uuid from the To address
string endpointAddress = FixToAddress(header.To);
// Build a temporary collection of device services that match the specified endpoint address.
WsServiceEndpoints matchingServices = new WsServiceEndpoints();
for (int i = 0; i < serviceEndpoints.Count; ++i)
{
if (serviceEndpoints[i].EndpointAddress == endpointAddress)
{
matchingServices.Add(serviceEndpoints[i]);
}
}
// For each service with a matching endpoint and event sources add an event sink to the
// event source collection
for (int i = 0; i < matchingServices.Count; ++i)
{
DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources;
// Set the EventSinkID
eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString();
// If subscribing to all event sources
if (eventSink.Filters == null)
{
int count = eventSources.Count;
for (int ii = 0; i < count; i++)
{
DpwsWseEventSource eventSource = eventSources[ii];
eventSink.StartTime = DateTime.Now.Ticks;
eventSource.EventSinks.Add(eventSink);
}
}
else
{
// If subscribing to a specific event based on an event filter.
DpwsWseEventSource eventSource;
string[] filterList = eventSink.Filters;
int length = filterList.Length;
for (int ii = 0; i < length; i++)
{
if ((eventSource = eventSources[filterList[ii]]) != null)
{
eventSink.StartTime = DateTime.Now.Ticks;
eventSource.EventSinks.Add(eventSink);
}
else
{
throw new Exception("Event source " + filterList[ii] + " was not found.");
}
}
}
}
// Generate Response
//////////////////////////
MemoryStream soapStream = new MemoryStream();
XmlWriter xmlWriter = XmlWriter.Create(soapStream);
WsWsaHeader responseHeader = new WsWsaHeader(
WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse", // Action
header.MessageID, // RelatesTo
header.ReplyTo.Address.AbsoluteUri, // To
null, null, null); // ReplyTo, From, Any
WsSoapMessageWriter.WriteSoapMessageStart(xmlWriter,
WsSoapMessageWriter.Prefixes.Wse, // Prefix
null, // Additional Prefix
responseHeader, // Header
new WsSoapMessageWriter.AppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence
// write body
xmlWriter.WriteStartElement("wse", "SubscribeResponse", null);
xmlWriter.WriteStartElement("wse", "SubscriptionManager", null);
xmlWriter.WriteStartElement("wsa", "Address", null);
// Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint
Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress);
xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath);
xmlWriter.WriteEndElement(); // End Address
xmlWriter.WriteStartElement("wsa", "ReferenceParameters", null);
xmlWriter.WriteStartElement("wse", "Identifier", null);
xmlWriter.WriteString(eventSink.ID);
xmlWriter.WriteEndElement(); // End Identifier
xmlWriter.WriteEndElement(); // End ReferenceParameters
xmlWriter.WriteEndElement(); // End SubscriptionManager
xmlWriter.WriteStartElement("wse", "Expires", null);
xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString);
xmlWriter.WriteEndElement(); // End Expires
xmlWriter.WriteEndElement(); // End SubscribeResponse
WsSoapMessageWriter.WriteSoapMessageEnd(xmlWriter);
// Flush and close writer. Return stream buffer
xmlWriter.Flush();
xmlWriter.Close();
return(soapStream.ToArray());
}
private static object Deserialize(Type type, XmlReader reader, bool needMoveReader)
{
object result = null;
while (true)
{
if (needMoveReader)
{
if (!reader.Read())
{
break;
}
}
needMoveReader = true;
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (result == null)
{
result = type.GetConstructor(Empty.Array <Type>())?.InvokeEx() ?? Activator.CreateInstance(type);
for (int attInd = 0; attInd < reader.AttributeCount; attInd++)
{
reader.MoveToAttribute(attInd);
var property = type.GetProperty(reader.Name, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (property != null)
{
property.SetValueEx(result, reader.Value);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(result);
}
}
else
{
Type elementType = null;
bool isList = false;
var propertyInfo = type.GetProperty(reader.Name, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (propertyInfo != null)
{
elementType = propertyInfo.PropertyType;
}
else
{
propertyInfo = type.GetProperty("Items", BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (propertyInfo != null)
{
elementType = propertyInfo.PropertyType.GenericTypeArguments[0];
isList = true;
}
}
if (elementType != null)
{
var item = Deserialize(elementType, reader, false);
if (isList)
{
var items = propertyInfo.GetValueEx <IList>(result);
if (items == null)
{
items = (IList)(propertyInfo.PropertyType.GetConstructor(Empty.Array <Type>())?.InvokeEx() ?? Activator.CreateInstance(propertyInfo.PropertyType));
propertyInfo.SetValueEx(result, items);
}
items.Add(item);
}
else
{
propertyInfo.SetValueEx(result, item);
}
}
}
break;
case XmlNodeType.EndElement:
return(result);
}
}
return(result);
}
/// <summary>
/// Reads XML from the xml file.
/// </summary>
/// <param name="reader">The XmlReader that reads from the xml file.</param>
/// <param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false.</param>
protected internal virtual void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
{
Hashtable readProps = new Hashtable();
reader.MoveToContent();
while (reader.MoveToNextAttribute())
{
APXmlPropertyInformation prop = ElementInformation.Properties[reader.LocalName];
if (prop == null || (serializeCollectionKey && !prop.IsKey))
{
if (reader.LocalName == "xmlns")
{
// Ignore
}
else if (!OnDeserializeUnrecognizedAttribute(reader.LocalName, reader.Value))
{
throw new APXmlException(APResource.GetString(APResource.APXml_UnrecognizedAttribute, reader.LocalName));
}
continue;
}
if (readProps.ContainsKey(prop))
{
throw new APXmlException(APResource.GetString(APResource.APXml_DuplicateAttribute, prop.Name));
}
string value = null;
try
{
value = reader.Value;
ValidateValue(prop.Property, value);
prop.SetStringValue(value);
}
catch (APXmlException)
{
throw;
}
catch (Exception ex)
{
throw new APXmlException(APResource.GetString(APResource.APXml_PropertyCannotBeParsed, prop.Name), ex, reader);
}
readProps[prop] = prop.Name;
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
int depth = reader.Depth;
reader.ReadStartElement();
reader.MoveToContent();
do
{
if (reader.NodeType != XmlNodeType.Element)
{
reader.Skip();
continue;
}
APXmlPropertyInformation prop = ElementInformation.Properties[reader.LocalName];
if (prop == null || (serializeCollectionKey && !prop.IsKey))
{
if (!OnDeserializeUnrecognizedElement(reader.LocalName, reader))
{
if (prop == null)
{
APXmlElementCollection collection = GetDefaultCollection();
if (collection != null && collection.OnDeserializeUnrecognizedElement(reader.LocalName, reader))
{
continue;
}
}
throw new APXmlException(APResource.GetString(APResource.APXml_UnrecognizedElement, reader.LocalName));
}
continue;
}
if (!prop.IsElement)
{
throw new APXmlException(APResource.GetString(APResource.APXml_NotAElement, prop.Name));
}
if (readProps.Contains(prop))
{
throw new APXmlException(APResource.GetString(APResource.APXml_DuplicateElement, prop.Name));
}
APXmlElement val = prop.Value as APXmlElement;
val.DeserializeElement(reader, serializeCollectionKey);
readProps[prop] = prop.Name;
} while (depth < reader.Depth);
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.Read();
}
}
foreach (APXmlPropertyInformation prop in ElementInformation.Properties)
{
if (!String.IsNullOrEmpty(prop.Name) && prop.IsRequired && !readProps.ContainsKey(prop))
{
APXmlPropertyInformation property = ElementInformation.Properties[prop.Name];
if (property == null)
{
object val = OnRequiredPropertyNotFound(prop.Name);
if (!object.Equals(val, prop.DefaultValue))
{
prop.Value = val;
}
}
}
}
PostDeserialize();
}
/// <summary>
/// Reads attributes of the current xaml element and converts them into appropriate html attributes or css styles
/// </summary>
/// <param name="xamlReader">
/// XmlTextReader which is expected to be at XmlNodeType.Element (opening element tag) position.
/// The reader will remain at the same level after function complete.</param>
/// <param name="htmlWriter">
/// XmlTextWriter for output html, which is expected to be in after WriteStartElement state.
/// </param>
/// <param name="inlineStyle">
/// String builder for collecting css properties for inline STYLE attribute.
/// </param>
private static void WriteFormattingProperties(XmlReader xamlReader, XmlWriter htmlWriter, StringBuilder inlineStyle)
{
if (xamlReader == null)
{
throw new ArgumentNullException("xamlReader");
}
// Clear string builder for the inline style
inlineStyle.Remove(0, inlineStyle.Length);
if (!xamlReader.HasAttributes)
{
return;
}
var borderSet = false;
while (xamlReader.MoveToNextAttribute())
{
string css = null;
switch (xamlReader.Name)
{
// Character fomatting properties
// ------------------------------
case "Background":
css = "background-color:" + ParseXamlColor(xamlReader.Value) + ";";
break;
case "FontFamily":
css = "font-family:" + xamlReader.Value + ";";
break;
case "FontStyle":
css = "font-style:" + xamlReader.Value.ToLower() + ";";
break;
case "FontWeight":
css = "font-weight:" + xamlReader.Value.ToLower() + ";";
break;
case "FontStretch":
break;
case "FontSize":
css = "font-size:" + xamlReader.Value + ";";
break;
case "Foreground":
css = "color:" + ParseXamlColor(xamlReader.Value) + ";";
break;
case "TextDecorations":
css = xamlReader.Value.ToLower() == "strikethrough"
? "text-decoration:line-through;"
: "text-decoration:underline;";
break;
case "TextEffects":
break;
case "Emphasis":
break;
case "StandardLigatures":
break;
case "Variants":
break;
case "Capitals":
break;
case "Fraction":
break;
// Paragraph formatting properties
// -------------------------------
case "Padding":
css = "padding:" + ParseXamlThickness(xamlReader.Value) + ";";
break;
case "Margin":
css = "margin:" + ParseXamlThickness(xamlReader.Value) + ";";
break;
case "BorderThickness":
css = "border-width:" + ParseXamlThickness(xamlReader.Value) + ";";
borderSet = true;
break;
case "BorderBrush":
css = "border-color:" + ParseXamlColor(xamlReader.Value) + ";";
borderSet = true;
break;
case "LineHeight":
break;
case "TextIndent":
css = "text-indent:" + xamlReader.Value + ";";
break;
case "TextAlignment":
css = "text-align:" + xamlReader.Value + ";";
break;
case "IsKeptTogether":
break;
case "IsKeptWithNext":
break;
case "ColumnBreakBefore":
break;
case "PageBreakBefore":
break;
case "FlowDirection":
break;
// Table attributes
// ----------------
case "CellSpacing":
css = "border-spacing: " + xamlReader.Value + ";";
break;
case "Width":
css = "width:" + xamlReader.Value + "px; height:auto;";
break;
case "ColumnSpan":
htmlWriter.WriteAttributeString("colspan", xamlReader.Value);
break;
case "RowSpan":
htmlWriter.WriteAttributeString("rowspan", xamlReader.Value);
break;
// Hyperlink Attributes
case "NavigateUri":
htmlWriter.WriteAttributeString("href", xamlReader.Value);
break;
case "TargetName":
htmlWriter.WriteAttributeString("target", xamlReader.Value);
break;
}
if (css != null)
{
inlineStyle.Append(css);
}
}
if (borderSet)
{
inlineStyle.Append("border-style:solid;mso-element:para-border-div;");
}
// Return the xamlReader back to element level
xamlReader.MoveToElement();
}
internal bool MoveToElement()
{
return(isEndOfEmptyElement ? false : reader.MoveToElement());
}
internal static string GetComparableForm(StringBuilder builder, XmlReader reader)
{
List <Attr> list = new List <Attr>();
int startLength = -1;
while (!reader.EOF)
{
switch (reader.MoveToContent())
{
case XmlNodeType.Element:
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
if (startLength < 0)
{
startLength = builder.Length;
}
builder.Append(reader.Value);
goto Label_0325;
case XmlNodeType.CDATA:
CompleteValue(builder, startLength);
startLength = -1;
builder.Append("<![CDATA[");
AppendString(builder, reader.Value);
builder.Append("]]>");
goto Label_0325;
case XmlNodeType.EndElement:
CompleteValue(builder, startLength);
startLength = -1;
builder.Append("</>");
goto Label_0325;
default:
goto Label_0325;
}
CompleteValue(builder, startLength);
startLength = -1;
builder.Append("<");
AppendString(builder, reader.LocalName);
builder.Append(":");
AppendString(builder, reader.NamespaceURI);
builder.Append(" ");
list.Clear();
if (!reader.MoveToFirstAttribute())
{
goto Label_0223;
}
Label_009D:
if (((reader.Prefix != "xmlns") && (reader.Name != "xmlns")) && ((reader.LocalName != "IsReferenceParameter") || (reader.NamespaceURI != "http://www.w3.org/2005/08/addressing")))
{
string qname = reader.Value;
if (((reader.LocalName == "type") && (reader.NamespaceURI == XsiNs)) || ((reader.NamespaceURI == "http://schemas.microsoft.com/2003/10/Serialization/") && ((reader.LocalName == "ItemType") || (reader.LocalName == "FactoryType"))))
{
string str2;
string str3;
XmlUtil.ParseQName(reader, qname, out str2, out str3);
qname = str2 + "^" + str2.Length.ToString(CultureInfo.InvariantCulture) + ":" + str3 + "^" + str3.Length.ToString(CultureInfo.InvariantCulture);
}
else if ((reader.LocalName == XD.UtilityDictionary.IdAttribute.Value) && (reader.NamespaceURI == XD.UtilityDictionary.Namespace.Value))
{
goto Label_0218;
}
list.Add(new Attr(reader.LocalName, reader.NamespaceURI, qname));
}
Label_0218:
if (reader.MoveToNextAttribute())
{
goto Label_009D;
}
Label_0223:
reader.MoveToElement();
if (list.Count > 0)
{
list.Sort();
for (int i = 0; i < list.Count; i++)
{
Attr attr = list[i];
AppendString(builder, attr.local);
builder.Append(":");
AppendString(builder, attr.ns);
builder.Append("=\"");
AppendString(builder, attr.val);
builder.Append("\" ");
}
}
if (reader.IsEmptyElement)
{
builder.Append("></>");
}
else
{
builder.Append(">");
}
Label_0325:
reader.Read();
}
return(builder.ToString());
}
public override bool MoveToElement()
{
return(innerReader.MoveToElement());
}
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());
}
private static void ConvertPost(SiteUris uris, XmlReader r, SequentialTurtleWriter w, UnknownValueStore <string> unknownPostTypeIds)
{
Uri subjectUri;
if (r.MoveToAttribute("Id"))
{
subjectUri = uris.CreatePostUri(r.Value);
w.StartTriple(subjectUri);
}
else
{
r.MoveToElement();
ConsoleHelper.WriteErrorLine("No Id attribute found on element {0}. Skipping element.", r.ReadOuterXml());
return;
}
if (r.MoveToAttribute("PostTypeId"))
{
switch (r.Value)
{
case "1": // question
w.AddToTriple(uris.GeneralUris.TypeProperty, uris.GeneralUris.QuestionType);
uris.LinkToSite(w);
if (r.MoveToAttribute("AcceptedAnswerId"))
{
w.AddToTriple(uris.GeneralUris.AcceptedAnswerProperty, uris.CreatePostUri(r.Value));
}
if (r.MoveToAttribute("ViewCount"))
{
w.AddToTriple(uris.GeneralUris.ViewCountProperty, long.Parse(r.Value));
}
if (r.MoveToAttribute("Title"))
{
w.AddToTriple(uris.GeneralUris.TitleProperty, r.Value);
w.AddToTriple(uris.GeneralUris.LabelProperty, r.Value);
}
if (r.MoveToAttribute("Score"))
{
w.AddToTriple(uris.GeneralUris.ScoreProperty, long.Parse(r.Value));
}
break;
case "2": // answer
w.AddToTriple(uris.GeneralUris.TypeProperty, uris.GeneralUris.AnswerType);
uris.LinkToSite(w);
if (r.MoveToAttribute("ParentId"))
{
w.StartTriple(uris.CreatePostUri(r.Value));
w.AddToTriple(uris.GeneralUris.AnswerProperty, subjectUri);
w.StartTriple(subjectUri);
}
else
{
ConsoleHelper.WriteWarningLine("Orphaned answer: {0}", subjectUri);
}
if (r.MoveToAttribute("Score"))
{
w.AddToTriple(uris.GeneralUris.ScoreProperty, long.Parse(r.Value));
}
break;
case "3": // orphaned tag wiki
break;
case "4": // tag info excerpt
w.AddToTriple(uris.GeneralUris.TypeProperty, uris.GeneralUris.TagExcerptType);
break;
case "5": // tag description
w.AddToTriple(uris.GeneralUris.TypeProperty, uris.GeneralUris.TagDescriptionType);
break;
case "6": // moderator nomination
break;
case "7": // "Wiki placeholder" (seems to only be the election description)
//w.AddToTriple(uris.GeneralUris.TypeProperty, uris.GeneralUris.SiteInfoType);
break;
default:
unknownPostTypeIds.RegisterUnknownValue(r.Value);
break;
}
if (r.MoveToAttribute("CreationDate"))
{
w.AddToTriple(uris.GeneralUris.DateProperty, DateTime.Parse(r.Value, System.Globalization.CultureInfo.InvariantCulture));
}
if (r.MoveToAttribute("LastEditDate"))
{
w.AddToTriple(uris.GeneralUris.LastEditDateProperty, DateTime.Parse(r.Value, System.Globalization.CultureInfo.InvariantCulture));
}
if (r.MoveToAttribute("LastActivity"))
{
w.AddToTriple(uris.GeneralUris.LastActivityDateProperty, DateTime.Parse(r.Value, System.Globalization.CultureInfo.InvariantCulture));
}
if (r.MoveToAttribute("OwnerUserId"))
{
w.AddToTriple(uris.GeneralUris.OwnerProperty, uris.CreateUserUri(r.Value));
}
// TODO: LastEditorUserId (given in post history)
// TODO: FavoriteCount (linked to users?)
if (r.MoveToAttribute("Body"))
{
w.AddToTriple(uris.GeneralUris.DescriptionProperty, r.Value);
}
if (r.MoveToAttribute("Tags"))
{
w.AddToTriple(uris.GeneralUris.TagProperty,
tagRegex.Matches(r.Value).Cast <Match>().Select(m => uris.CreateTagUri(m.Groups[1].Value)));
}
}
else
{
r.MoveToElement();
ConsoleHelper.WriteErrorLine("No PostTypeId attribute found on element {0}. Skipping element.", r.ReadOuterXml());
}
}
public override bool MoveToElement()
{
return(_wrappedReader.MoveToElement());
}
internal void Parse(XmlReader reader)
{
int buflen = 500;
char[] buffer = new char[buflen];
try
{
object nsuri = reader.NameTable.Add("http://www.w3.org/2000/xmlns/");
FonetDriver.ActiveDriver.FireFonetInfo("Building formatting object tree");
streamRenderer.StartRenderer();
var sw = System.Diagnostics.Stopwatch.StartNew();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
Attributes atts = new Attributes();
while (reader.MoveToNextAttribute())
{
if (!reader.NamespaceURI.Equals(nsuri))
{
SaxAttribute newAtt = new SaxAttribute();
newAtt.Name = reader.Name;
newAtt.NamespaceURI = reader.NamespaceURI;
newAtt.Value = reader.Value;
atts.attArray.Add(newAtt);
}
}
reader.MoveToElement();
StartElement(reader.NamespaceURI, reader.LocalName, atts.TrimArray());
if (reader.IsEmptyElement)
{
EndElement();
}
break;
case XmlNodeType.EndElement:
EndElement();
break;
case XmlNodeType.Text:
char[] chars = reader.ReadString().ToCharArray();
if (currentFObj != null)
{
currentFObj.AddCharacters(chars, 0, chars.Length);
}
if (reader.NodeType == XmlNodeType.Element)
{
goto case XmlNodeType.Element;
}
if (reader.NodeType == XmlNodeType.EndElement)
{
goto case XmlNodeType.EndElement;
}
break;
default:
break;
}
}
FonetDriver.ActiveDriver.FireFonetInfo(String.Format("Parsing completed in [{0}] seconds.", sw.Elapsed.TotalSeconds));
FonetDriver.ActiveDriver.FireFonetInfo("Parsing of document complete, stopping renderer.");
streamRenderer.StopRenderer();
}
catch (Exception exception)
{
FonetDriver.ActiveDriver.FireFonetError(exception.ToString());
}
finally
{
if (reader.ReadState != ReadState.Closed)
{
reader.Close();
}
}
}
/// <summary>
/// Creates an instance of a DpwsMetadata class.
/// </summary>
public DpwsMetadata(XmlReader reader)
{
reader.ReadStartElement("Metadata", WsWellKnownUri.WsxNamespaceUri);
while (reader.IsStartElement("MetadataSection", WsWellKnownUri.WsxNamespaceUri))
{
reader.MoveToAttribute("Dialect");
String dialect = reader.Value;
reader.MoveToElement();
reader.Read(); // MetadataSection
if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisModel")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisModel = new DpwsThisModel(reader);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisDevice")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisDevice = new DpwsThisDevice(reader);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/Relationship")
{
#if DEBUG
int depth = reader.Depth;
#endif
if (this.Relationship == null)
{
this.Relationship = new DpwsRelationship(reader);
}
else
{
this.Relationship.Append(reader);
}
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else // known dialect
{
reader.Skip();
}
reader.ReadEndElement(); // MetadataSection
}
if (this.ThisModel == null || this.ThisDevice == null || this.Relationship == null)
{
// Metadata must include ThisModel (R2038, R2012), ThisDevice(R2039, R2014),
// at least one Relationship(R2040, R2029)
throw new XmlException();
}
XmlReaderHelper.SkipAllSiblings(reader); // xs:any
reader.ReadEndElement(); // Metadata
}
public override bool MoveToElement()
{
return(_reader.MoveToElement());
}
private static void ReadReferencedCategories(XmlReader reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, int maxExtensionSize)
{
referencedCategories.BaseUri = baseUri;
referencedCategories.Link = link;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value);
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.Language = reader.Value;
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
continue;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, referencedCategories, version))
{
referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
reader.MoveToElement();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (!TryParseElement(reader, referencedCategories, version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, referencedCategories);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
}
}
public static ListArray <T> Deserialize(string str, Deserialize <T> deserialize)
{
string type_string = Meta.ConvertTypeToCsharpSource(typeof(T));
string type_string_xml = type_string.Replace("<", "-").Replace(">", "-");
T[] list;
Equate <T> equate = null;
int count = 0;
using (XmlReader xmlReader = XmlReader.Create(new StringReader(str)))
{
if (!xmlReader.Read() ||
!xmlReader.IsStartElement() ||
xmlReader.IsEmptyElement ||
!xmlReader.Name.Equals("ListArray"))
{
throw new FormatException("Invalid input during ListArray deserialization.");
}
bool typeExists = false;
bool equateExists = false;
bool countExists = false;
while (xmlReader.MoveToNextAttribute())
{
switch (xmlReader.Name)
{
case "Type":
string typeFromXml = xmlReader.Value;
if (!type_string_xml.Equals(typeFromXml))
{
throw new FormatException("Type mismatch during a ListArray deserialization (ListArray<T>: T does not match the type in the string to deserialize).");
}
typeExists = true;
break;
case "Equate":
if (string.IsNullOrWhiteSpace(xmlReader.Value))
{
throw new FormatException("Invalid input during ListArray deserialization (Equate attribute is invalid or missing a value).");
}
string[] splits = xmlReader.Value.Split(',');
if (splits.Length != 3)
{
throw new FormatException("Invalid input during ListArray deserialization (Equate attribute has an invalid value).");
}
string methodName = splits[0];
string declaringTypeFullName = splits[1];
string assembly = splits[2];
equate = Meta.Compile <Equate <T> >(string.Concat(declaringTypeFullName, ".", methodName));
equateExists = true;
break;
case "Count":
if (string.IsNullOrWhiteSpace(xmlReader.Value))
{
throw new FormatException("Invalid input during ListArray deserialization (Count attribute is invalid or missing a value).");
}
if (!int.TryParse(xmlReader.Value, out count) || count < 0)
{
throw new FormatException("Invalid input during ListArray deserialization (Count attribute is invalid).");
}
countExists = true;
break;
default:
continue;
}
}
if (!equateExists)
{
throw new FormatException("Invalid input during ListArray deserialization (required attribute Equate does not exist).");
}
if (!countExists)
{
throw new FormatException("Invalid input during ListArray deserialization (required attribute Count does not exist).");
}
if (!typeExists)
{
throw new FormatException("Invalid input during ListArray deserialization (required attribute Type does not exist).");
}
xmlReader.MoveToElement();
list = new T[count];
for (int i = 0; i < count; i++)
{
while (xmlReader.Name == null || !xmlReader.Name.Equals("Item"))
{
xmlReader.Read();
}
if (!xmlReader.IsStartElement() ||
xmlReader.IsEmptyElement)
{
throw new FormatException("Invalid input during ListArray deserialization.");
}
if (xmlReader.Value == null)
{
throw new FormatException("Invalid input during ListArray deserialization (missing or invalid contents of Item #" + i + ").");
}
int index;
bool indexExists = false;
while (xmlReader.MoveToNextAttribute())
{
if (string.IsNullOrWhiteSpace(xmlReader.Name))
{
throw new FormatException("Invalid input during ListArray deserialization (invalid attribute of Item #" + i + ").");
}
if (!xmlReader.Name.Equals("Index"))
{
continue;
}
if (string.IsNullOrWhiteSpace(xmlReader.Value) ||
!int.TryParse(xmlReader.Value, out index) ||
index != i)
{
throw new FormatException("Invalid input during ListArray deserialization (invalid index attribute of Item #" + i + ").");
}
indexExists = true;
}
if (!indexExists)
{
throw new FormatException("Invalid input during ListArray deserialization (missing required Index attribute for Item #" + i + ").");
}
xmlReader.MoveToElement();
string item_string = xmlReader.ReadString().Trim();
list[i] = deserialize(item_string);
if (i < count - 1 && !xmlReader.ReadToNextSibling("Item"))
{
throw new FormatException("Invalid input during ListArray deserialization (count attribute and amount of data provided do not match).");
}
}
}
return(new ListArray <T>(list, count, equate));
}
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());
}
private static void StartTag()
{
var ht = new Hashtable();
if (_reader.HasAttributes)
{
while (_reader.MoveToNextAttribute())
{
if (_reader.Prefix.Equals("xmlns"))
{
NamespaceManager.AddNamespace(_reader.LocalName, _reader.Value);
}
else if (_reader.Name.Equals("xmlns"))
{
NamespaceManager.AddNamespace(string.Empty, _reader.Value);
}
else
{
ht.Add(_reader.Name, _reader.Value);
}
}
_reader.MoveToElement();
}
string ns = NamespaceManager.LookupNamespace(_reader.Prefix);
var q = new XmlQualifiedName(_reader.LocalName, ns);
XmlElement elem = TagRegistry.GetTag <Tag>(q);
foreach (string attrname in ht.Keys)
{
int colon = attrname.IndexOf(':');
if (colon > 0)
{
string prefix = attrname.Substring(0, colon);
string name = attrname.Substring(colon + 1);
XmlAttribute attr = ProtocolState.Document.CreateAttribute(prefix, name,
NamespaceManager.LookupNamespace(prefix));
attr.InnerXml = (string)ht[attrname];
elem.SetAttributeNode(attr);
}
else
{
XmlAttribute attr = ProtocolState.Document.CreateAttribute(attrname);
attr.InnerXml = (string)ht[attrname];
elem.SetAttributeNode(attr);
}
}
if (_root == null)
{
if (elem.Name != "stream:stream")
{
ProtocolState.Events.Error(null, ErrorType.WrongProtocolVersion, ErrorSeverity.Fatal, "Missing proper stream:stream header from server.");
return;
}
_root = elem;
}
else
{
_element?.AppendChild(elem);
_element = elem;
}
}
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());
}
private void dataGridView1_RowEnter(object sender, DataGridViewCellEventArgs e)
{
if (dataGridView1.ColumnCount < typecoloum)
{
return;
}
try
{
// number the coloums
int a = -typecoloum;
foreach (DataGridViewColumn col in dataGridView1.Columns)
{
col.HeaderText = a.ToString();
a++;
}
}
catch { }
try
{
// process the line type
string option = dataGridView1[typecoloum, e.RowIndex].EditedFormattedValue.ToString();
// new self describing log
if (DFLog.logformat.ContainsKey(option))
{
int a = typecoloum + 1;
foreach (string name in DFLog.logformat[option].FieldNames)
{
dataGridView1.Columns[a].HeaderText = name;
a++;
}
for (; a < dataGridView1.Columns.Count; a++)
{
dataGridView1.Columns[a].HeaderText = "";
}
if (option == "GPS")
{
// display current gps point
var ans = getPointLatLng(logdata.Find(x => { return(x.lineno.ToString() == dataGridView1[0, e.RowIndex].Value.ToString()); }));// dataGridView1.Rows[e.RowIndex]);
if (ans.HasValue)
{
mapoverlay.Markers.Clear();
mapoverlay.Markers.Add(new GMarkerGoogle(ans.Value, GMarkerGoogleType.red));
myGMAP1.MarkersEnabled = true;
}
else
{
// mapoverlay.Markers.Clear();
}
}
return;
}
if (option.StartsWith("PID-"))
{
option = "PID-1";
}
using (XmlReader reader = XmlReader.Create(Path.GetDirectoryName(Application.ExecutablePath) + Path.DirectorySeparatorChar + "dataflashlog.xml"))
{
reader.Read();
reader.ReadStartElement("LOGFORMAT");
if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduPlane)
{
reader.ReadToFollowing("APM");
}
else if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduRover)
{
reader.ReadToFollowing("APRover");
}
else
{
reader.ReadToFollowing("AC2");
}
reader.ReadToFollowing(option);
dataGridView1.Columns[1].HeaderText = "";
if (reader.NodeType == XmlNodeType.None)
{
return;
}
XmlReader inner = reader.ReadSubtree();
inner.MoveToElement();
int a = 2;
while (inner.Read())
{
inner.MoveToElement();
if (inner.IsStartElement())
{
if (inner.Name.StartsWith("F"))
{
dataGridView1.Columns[a].HeaderText = inner.ReadString();
log.Info(a + " " + dataGridView1.Columns[a].HeaderText);
a++;
}
}
}
for (; a < dataGridView1.Columns.Count; a++)
{
dataGridView1.Columns[a].HeaderText = "";
}
}
}
catch { log.Info("DGV logbrowse error"); }
}
public override bool MoveToElement()
{
return(m_source.MoveToElement());
}
private void dataGridView1_RowEnter(object sender, DataGridViewCellEventArgs e)
{
try
{
// number the coloums
int a = -1;
foreach (DataGridViewColumn col in dataGridView1.Columns)
{
col.HeaderText = a.ToString();
a++;
}
}
catch { }
try
{
// process the line type
string option = dataGridView1[1, e.RowIndex].EditedFormattedValue.ToString();
// new self describing log
if (logformat.ContainsKey(option))
{
int a = 2;
foreach (string name in logformat[option].FieldNames)
{
dataGridView1.Columns[a].HeaderText = name;
a++;
}
for (; a < dataGridView1.Columns.Count; a++)
{
dataGridView1.Columns[a].HeaderText = "";
}
return;
}
if (option.StartsWith("PID-"))
{
option = "PID-1";
}
using (XmlReader reader = XmlReader.Create(Path.GetDirectoryName(Application.ExecutablePath) + Path.DirectorySeparatorChar + "dataflashlog.xml"))
{
reader.Read();
reader.ReadStartElement("LOGFORMAT");
if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduPlane)
{
reader.ReadToFollowing("APM");
}
else if (MainV2.comPort.MAV.cs.firmware == MainV2.Firmwares.ArduRover)
{
reader.ReadToFollowing("APRover");
}
else
{
reader.ReadToFollowing("AC2");
}
reader.ReadToFollowing(option);
dataGridView1.Columns[1].HeaderText = "";
XmlReader inner = reader.ReadSubtree();
inner.MoveToElement();
int a = 2;
while (inner.Read())
{
inner.MoveToElement();
if (inner.IsStartElement())
{
if (inner.Name.StartsWith("F"))
{
dataGridView1.Columns[a].HeaderText = inner.ReadString();
log.Info(a + " " + dataGridView1.Columns[a].HeaderText);
a++;
}
}
}
for (; a < dataGridView1.Columns.Count; a++)
{
dataGridView1.Columns[a].HeaderText = "";
}
}
}
catch { log.Info("DGV logbrowse error"); }
}
public MFTestResults SPOTXml_XmlReader_MethodsTest3()
{
/// <summary>
/// Tests all of the XmlReader methods in SPOT.Xml
/// </summary>
///
bool testResult = true;
try
{
Log.Comment("Creating XmlReader with Stream");
XmlReader testReader = XmlReader.Create(new TestStream());
Log.Comment("Close");
testReader.Close();
if (testReader.ReadState != ReadState.Closed)
{
testResult = false;
Log.Exception("Close did not function properly");
}
testReader = XmlReader.Create(new TestStream());
Log.Comment("GetAttribute");
try
{
if ("" == testReader.GetAttribute(0))
{
testResult = false;
Log.Exception("GetAttribute succeeded with 0 attributes");
}
}
catch (ArgumentOutOfRangeException e) {
Log.Exception("ArgumentOutOfRangeException caught in SPOTXml_XmlReader_MethodsTest3::GetAttribute(0): ", e);
}
// Add Additional tests for the overloaded GetAttribute
// public abstract string GetAttribute(string name);
// public abstract string GetAttribute(string name, string namespaceURI);
Log.Comment("IsStartElement");
if (!testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned false before read");
}
testReader.Read();
if (!testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned false after read to 1st elt");
}
testReader.Read();
testReader.Read();
if (testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned true after read to an end elt");
}
testReader = XmlReader.Create(new TestStream());
if (!testReader.IsStartElement("root"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned false for root");
}
if (testReader.IsStartElement("TestElement1"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned true for TestElement1");
}
if (testReader.IsStartElement("FakeData"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned true for FakeData");
}
testReader = XmlReader.Create(new TestStream());
if (!testReader.IsStartElement("root", ""))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned false for root, namespace");
}
if (testReader.IsStartElement("root", "FakeNamespaceURI"))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned true for root, FakeNamespaceURI");
}
if (testReader.IsStartElement("TestElement1", ""))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned true for TestElement1");
}
testReader = XmlReader.Create(new TestStream());
if (testReader.LookupNamespace("XT") != null)
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data");
}
testResult &= testReader.Read();
if (testReader.LookupNamespace("XT") != "TestNS")
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data after read");
}
if (testReader.LookupNamespace("") != "")
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data for bad arg after read");
}
testReader = XmlReader.Create(new TestStream());
Log.Comment("MoveToX methods");
testReader.MoveToContent();
if (testReader.Name != "root")
{
testResult = false;
Log.Exception("MoveToContent went to wrong node");
}
testReader.MoveToElement();
if (testReader.Name != "root")
{
testResult = false;
Log.Exception("MoveToElementwent to wrong node");
}
testResult &= testReader.MoveToFirstAttribute();
if (testReader.Name != "xmlns:XT")
{
testResult = false;
Log.Exception("MoveToFirstAttribute went to wrong node");
}
testResult &= testReader.MoveToNextAttribute();
if (testReader.Name != "XT:TestLocalName")
{
testResult = false;
Log.Exception("MoveToFirstAttribute went to wrong node");
}
Log.Comment("ReadElementString");
testReader = XmlReader.Create(new TestStream());
//TODO: Exception testing here under investigation
//testReader.ReadElementString();
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString() != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString() != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadString() != "")
{
testResult = false;
Log.Exception("ReadString returned bad data for empty node");
}
testReader.Read();
testReader.Read();
if (testReader.ReadString() != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString("ChildOfTestElement1") != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString("TestElement2") != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString("ChildOfTestElement1", "") != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString("TestElement2", "") != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
//Add tests for overloaded ReadStartElement
// public virtual void ReadStartElement(string name);
// public virtual void ReadStartElement(string localname, string ns);
testReader.ReadStartElement();
if (testReader.Name != "TestElement1")
{
testResult = false;
Log.Exception("ReadStartElement failed on start element");
}
try
{
testReader.ReadEndElement();
testResult = false;
Log.Comment("FAILURE - ReadEndElement succeded on Start element ");
}
catch (XmlException e) {
Log.Exception("XMLException - ReadEndElement succeeded on Start element ", e);
}
testReader.Read();
testReader.Read();
testReader.ReadEndElement();
if (testReader.Name != "TestElement2")
{
testResult = false;
Log.Exception("ReadEndElement failed on end element");
}
testReader.Read();
try
{
testReader.ReadStartElement();
testResult = false;
Log.Comment("FAILURE - ReadStartElement succeeded on end element ");
}
catch (XmlException e) {
Log.Exception("ReadStartElement failed on end element", e);
}
testReader = XmlReader.Create(new TestStream());
//Add tests for the overloaded ReadToDescendant
// public virtual bool ReadToDescendant(string localName, string namespaceURI);
testReader.ReadToDescendant("ChildOfTestElement1");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToDescendant read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
// public virtual bool ReadToDescendant(string Name)
// passing in empty string.
try
{
testReader.ReadToDescendant("");
}
catch (ArgumentException e)
{
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant read to a location erroneously ", e);
}
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement2");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement1", "");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToDescendant with namesapce read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement2", "");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant with namesapce read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
//Add tests for the overloaded ReadToDescendant
// public virtual bool ReadToFollowing(string localName, string namespaceURI);
testReader.ReadToFollowing("ChildOfTestElement1");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToFollowing read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement2");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToFollowing read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement1", "");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToFollowing with namesapce read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement2", "");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToFollowing with namesapce read to a location erroneously");
}
Log.Comment("ReadToNextSibling method");
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
if (!testReader.ReadToNextSibling("TestElement2"))
{
testResult = false;
Log.Exception("ReadToNextSibling return false for TestElement2");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
if (testReader.ReadToNextSibling("TestElement1", ""))
{
testResult = false;
Log.Exception("Bug 57189: ReadToNextSibling return true for TestElement1");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
if (!testReader.ReadToNextSibling("TestElement2", ""))
{
testResult = false;
Log.Exception("ReadToNextSibling return false for TestElement2");
}
Log.Comment("Skip");
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Skip();
if (testReader.Name != "TestElement2")
{
testResult = false;
Log.Exception("Skip failed to advance to correct node");
}
}
catch (Exception e)
{
testResult = false;
Log.Exception("Incorrect exception caught: ", e);
}
return(testResult ? MFTestResults.Pass : MFTestResults.Fail);
}
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>
/// Converts the XML hierarchy of an <see cref="XmlReader"/> into an <see cref="IHierarchy{T}"/>.
/// </summary>
/// <param name="reader">The reader to convert.</param>
/// <returns>An <see cref="IHierarchy{T}"/> implementation that uses <see cref="DataPair"/>.</returns>
public static IHierarchy <DataPair> ToHierarchy(this XmlReader reader)
{
var index = 0;
var depthIndexes = new Dictionary <int, Dictionary <int, int> >();
var dimension = 0;
IHierarchy <DataPair> hierarchy = new Hierarchy <DataPair>();
List <DataPair> attributes = null;
while (reader.Read())
{
object typeStrongValue;
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
typeStrongValue = ObjectConverter.FromString(reader.Value);
attributes.Add(new DataPair(reader.Name, typeStrongValue, typeStrongValue.GetType()));
while (reader.MoveToNextAttribute())
{
goto case XmlNodeType.Attribute;
}
foreach (var attribute in attributes)
{
hierarchy[index].Add(attribute);
index++;
}
reader.MoveToElement();
break;
case XmlNodeType.Element:
attributes = new List <DataPair>();
if (reader.Depth == 0)
{
hierarchy.Add(new DataPair(reader.Name, null, typeof(string))).Data.Add(XmlReaderKey, reader.Name);
continue;
}
hierarchy[depthIndexes.GetDepthIndex(reader, index, dimension)].Add(new DataPair(reader.Name, null, typeof(string))).Data.Add(XmlReaderKey, reader.Name);
index++;
if (reader.HasAttributes)
{
if (reader.MoveToFirstAttribute())
{
goto case XmlNodeType.Attribute;
}
}
break;
case XmlNodeType.EndElement:
if (reader.Depth == 1)
{
dimension++;
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
typeStrongValue = ObjectConverter.FromString(reader.Value);
hierarchy[index].Replace(new DataPair(hierarchy[index].Data[XmlReaderKey]?.ToString(), typeStrongValue, typeStrongValue.GetType()));
hierarchy[index].Data.Remove(XmlReaderKey);
break;
}
}
return(hierarchy);
}
/// <summary>
/// Reads a specific data tag from the xml document.
/// </summary>
/// <param name='reader'>
/// Reader.
/// </param>
private void ReadData(XmlReader reader)
{
//If these values are not being set,
//something is wrong.
string key = "ERROR";
string value = "ERROR";
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.Name == "name")
{
key = reader.Value;
}
}
}
//Move back to the element
reader.MoveToElement();
//Read the child nodes
if (reader.ReadToDescendant("value"))
{
do
{
value = reader.ReadString();
}
while (reader.ReadToNextSibling("value"));
}
//Add the raw values to the dictionary
textDataBase.Add(key, value);
//Add the localized parsed values to the localizedObjectDataBase
LocalizedObject newLocalizedObject = new LocalizedObject();
newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key);
newLocalizedObject.TextValue = value;
localizedObjectDataBase.Add(LocalizedObject.GetCleanKey(key,newLocalizedObject.ObjectType), newLocalizedObject);
}
private ProtectedBinary ReadProtectedBinary(XmlReader xr)
{
if (xr.MoveToAttribute(AttrRef))
{
string strRef = xr.Value;
if (!string.IsNullOrEmpty(strRef))
{
int iRef;
if (StrUtil.TryParseIntInvariant(strRef, out iRef))
{
ProtectedBinary pb = m_pbsBinaries.Get(iRef);
if (pb != null)
{
// https://sourceforge.net/p/keepass/feature-requests/2023/
xr.MoveToElement();
#if DEBUG
string strInner = ReadStringRaw(xr);
Debug.Assert(string.IsNullOrEmpty(strInner));
#else
ReadStringRaw(xr);
#endif
return(pb);
}
else
{
Debug.Assert(false);
}
}
else
{
Debug.Assert(false);
}
}
else
{
Debug.Assert(false);
}
}
bool bCompressed = false;
if (xr.MoveToAttribute(AttrCompressed))
{
bCompressed = (xr.Value == ValTrue);
}
XorredBuffer xb = ProcessNode(xr);
if (xb != null)
{
Debug.Assert(!bCompressed); // See SubWriteValue(ProtectedBinary value)
try { return(new ProtectedBinary(true, xb)); }
finally { xb.Dispose(); }
}
byte[] pbData = ReadBase64(xr, true);
if (pbData.Length == 0)
{
return(new ProtectedBinary());
}
if (bCompressed)
{
pbData = MemUtil.Decompress(pbData);
}
return(new ProtectedBinary(false, pbData));
}
