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)); }