public static ColorEx ParseColorAttributes(XmlReader r)
{
float R = 0;
float G = 0;
float B = 0;
for (int i = 0; i < r.AttributeCount; i++)
{
r.MoveToAttribute(i);
// set the field in this object based on the element we just read
switch (r.Name)
{
case "R":
R = float.Parse(r.Value);
break;
case "G":
G = float.Parse(r.Value);
break;
case "B":
B = float.Parse(r.Value);
break;
}
}
r.MoveToElement(); //Moves the reader back to the element node.
r.MoveToElement(); //Moves the reader back to the element node.
if (R > 1 || G > 1 || B > 1)
{
R = R / 255;
G = G / 255;
B = B / 255;
}
return new ColorEx(R, G, B);
}
/// <summary>
/// reads the xml file using elment based approach
/// </summary>
/// <param name="element">element to be read</param>
private void ReadElement(Element element)
{
//-----read all attributes
if (_reader.HasAttributes)
{
//-----add all the attributes
while (_reader.MoveToNextAttribute())
{
if (!element.Attributes.ContainsKey(_reader.Name))
{
element.Attributes.Add(_reader.Name, _reader.Value);
}
}
//-----invoke attribute callback
if (OnAttributesRead != null)
{
OnAttributesRead.Invoke(element);
}
_reader.MoveToElement();
}
//-----read elements content
if (!_reader.IsEmptyElement)
{
int depth = _reader.Depth;
while (_reader.Read())
{
//-----read child elements
if (_reader.NodeType == XmlNodeType.Element)
{
Element subElement = new Element()
{
Parent = element, Name = _reader.Name
};
ReadElement(subElement);
}
//-----read text content
else if (_reader.NodeType == XmlNodeType.Text)
{
element.Value = _reader.Value;
}
//-----end element reached, so break if its the current one
else if (_reader.NodeType == XmlNodeType.EndElement)
{
if (_reader.Depth == depth)
{
if (OnElementRead != null)
{
OnElementRead.Invoke(element);
}
break;
}
}
}
}
else if (OnElementRead != null)
{
OnElementRead.Invoke(element);
}
}
/// <summary>
/// Recupera os dados do xml.
/// </summary>
/// <param name="reader"></param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("name"))
{
Name = reader.ReadContentAsString();
reader.MoveToElement();
}
if (reader.MoveToAttribute("address"))
{
Address = reader.ReadContentAsString();
reader.MoveToElement();
}
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "Configuration")
{
if (!reader.IsEmptyElement)
{
var config = new ServiceAddressNode();
config.ReadXml(reader);
Configuration = config;
}
else
{
reader.Skip();
}
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
public static string ReadContent(XmlReader xr)
{
string rlt;
if (xr.NodeType != XmlNodeType.Element)
{
xr.MoveToElement();
}
rlt = xr.ReadString();
xr.MoveToElement();
return rlt;
}
/// <summary>
/// Recupera os dados do xml.
/// </summary>
/// <param name="reader"></param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("name"))
{
Name = reader.ReadContentAsString();
reader.MoveToElement();
}
if (reader.MoveToAttribute("value"))
{
Value = reader.ReadContentAsString();
reader.MoveToElement();
}
reader.Skip();
}
/// <summary>
/// Implementação da leitura de xml para a interface <see cref="IXmlSerializable"/>
/// </summary>
/// <param name="reader"></param>
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (!reader.IsEmptyElement && reader.LocalName == "Result")
{
reader.MoveToElement();
Result = new QueryResult();
((System.Xml.Serialization.IXmlSerializable)Result).ReadXml(reader);
}
else if (!reader.IsEmptyElement && reader.LocalName == "Parameters")
{
reader.ReadStartElement("Parameters", Namespaces.Query);
Parameters = new QueryParameterCollection();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
var parameter = new QueryParameter();
((System.Xml.Serialization.IXmlSerializable)parameter).ReadXml(reader);
Parameters.Add(parameter);
}
reader.ReadEndElement();
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
public static KeyValuePair<string, Property> ReadXml(XmlReader reader)
{
var key = reader.GetAttribute("Key");
var type = reader.GetAttribute("Type");
reader.MoveToElement();
reader.ReadStartElement("PropertyEntry");
Property value = null;
try
{
var t = Type.GetType(type);
value = (Property)GetSerializer(t).Deserialize(reader);
}
catch (Exception ex)
{
Console.WriteLine("Deserialization failed: " + ex.Message);
Console.WriteLine("Property Key: " + key);
Console.WriteLine("Property Type Qualified Name: " + type);
Console.WriteLine("Stacktrace: " + ex.StackTrace);
}
reader.ReadEndElement();
reader.MoveToContent();
if (value == null)
throw new Exception();
return new KeyValuePair<string, Property>(key, value);
}
public static XmlNode[] ReadNodes(XmlReader xmlReader)
{
if (xmlReader == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader");
XmlDocument doc = new XmlDocument();
List<XmlNode> nodeList = new List<XmlNode>();
if (xmlReader.MoveToFirstAttribute())
{
do
{
if (IsValidAttribute(xmlReader))
{
XmlNode node = doc.ReadNode(xmlReader);
if (node == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile)));
nodeList.Add(node);
}
} while (xmlReader.MoveToNextAttribute());
}
xmlReader.MoveToElement();
if (!xmlReader.IsEmptyElement)
{
int startDepth = xmlReader.Depth;
xmlReader.Read();
while (xmlReader.Depth > startDepth && xmlReader.NodeType != XmlNodeType.EndElement)
{
XmlNode node = doc.ReadNode(xmlReader);
if (node == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile)));
nodeList.Add(node);
}
}
return nodeList.ToArray();
}
/// <summary>
/// Creates a policy set id reference using the XmlReader instance provided.
/// </summary>
/// <param name="reader">The XmlReader instance positioned at the "PolicySetIdReference"
/// node</param>
/// <param name="schemaVersion">The version of the schema that will be used to validate.</param>
public PolicySetIdReferenceElementReadWrite(XmlReader reader, XacmlVersion schemaVersion)
: base(XacmlSchema.Policy, schemaVersion)
{
if (reader == null) throw new ArgumentNullException("reader");
if (reader.LocalName == Consts.Schema1.PolicySetIdReferenceElement.PolicySetIdReference &&
ValidateSchema(reader, schemaVersion))
{
if (reader.HasAttributes)
{
// Load all the attributes
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == Consts.Schema2.PolicyReferenceElement.Version)
{
_version = reader.GetAttribute(Consts.Schema2.PolicyReferenceElement.Version);
}
else if (reader.LocalName == Consts.Schema2.PolicyReferenceElement.EarliestVersion)
{
_earliestVersion = reader.GetAttribute(Consts.Schema2.PolicyReferenceElement.EarliestVersion);
}
else if (reader.LocalName == Consts.Schema2.PolicyReferenceElement.LatestVersion)
{
_latestVersion = reader.GetAttribute(Consts.Schema2.PolicyReferenceElement.LatestVersion);
}
}
reader.MoveToElement();
}
_policySetIdReference = reader.ReadElementString();
}
else
{
throw new Exception(string.Format(Properties.Resource.exc_invalid_node_name, reader.LocalName));
}
}
public HeightfieldTerrainGenerator(XmlReader r)
{
for (int i = 0; i < r.AttributeCount; i++)
{
r.MoveToAttribute(i);
switch (r.Name)
{
case "Type":
string type = r.Value;
Debug.Assert(type == "HeightfieldMosaic");
break;
case "MosaicName":
heightfieldName = r.Value;
break;
case "PreloadRadius":
preloadRadius = int.Parse(r.Value);
break;
case "OutsideHeight":
outsideHeight = float.Parse(r.Value);
break;
}
}
r.MoveToElement();
if (!r.IsEmptyElement)
{
do
{
r.Read();
} while (r.NodeType != XmlNodeType.EndElement);
}
Mosaic = new HeightfieldMosaic(heightfieldName, preloadRadius, outsideHeight);
Mosaic.MosaicModificationStateChanged += Mosaic_OnMosaicModificationStateChanged;
Mosaic.MosaicChanged += Mosaic_OnMosaicChanged;
}
public override void ReadXml(XmlReader reader)
{
while (reader.MoveToNextAttribute())
if (!TryReadXmlAttribute(reader))
MapXmlReader.HandleUnexpectedAttribute(reader.LocalName);
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
var isElsePresent = false;
reader.Read();
while (reader.MoveToContent() != XmlNodeType.EndElement)
if (reader.IsStartElement(When.ElementName) && !isElsePresent)
{
var when = new When();
Nodes.Add(when);
when.ReadXml(reader);
}
else if (reader.IsStartElement(Else.ElementName))
{
var elseNode = new Else();
Nodes.Add(elseNode);
elseNode.ReadXml(reader);
isElsePresent = true;
}
else MapXmlReader.HandleUnexpectedElement(reader.LocalName);
}
reader.Read();
}
/// <summary>
/// Creates an instance of the ReadWriteAttributeAssignment using the provided XmlReader.
/// </summary>
/// <param name="reader">The XmlReader positioned at the AttributeAssignament node.</param>
/// <param name="schemaVersion">The version of the schema that was used to validate.</param>
public AttributeAssignmentElementReadWrite(XmlReader reader, XacmlVersion schemaVersion)
: base(XacmlSchema.Policy, schemaVersion)
{
if (reader == null) throw new ArgumentNullException("reader");
if (reader.LocalName == Consts.Schema1.ObligationElement.AttributeAssignment &&
ValidateSchema(reader, schemaVersion))
{
if (reader.HasAttributes)
{
// Load all the attributes
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == Consts.Schema1.AttributeValueElement.DataType)
{
_dataType = reader.GetAttribute(Consts.Schema1.AttributeValueElement.DataType);
}
else if (reader.LocalName == Consts.Schema1.AttributeAssignmentElement.AttributeId)
{
_attributeId = reader.GetAttribute(Consts.Schema1.AttributeAssignmentElement.AttributeId);
}
}
reader.MoveToElement();
}
// Load the node contents
_contents = reader.ReadInnerXml();
}
else
{
throw new Exception(string.Format(Properties.Resource.exc_invalid_node_name, reader.LocalName));
}
}
public static Quaternion ParseQuaternion(XmlReader r)
{
float w = 0;
float x = 0;
float y = 0;
float z = 0;
for (int i = 0; i < r.AttributeCount; i++)
{
r.MoveToAttribute(i);
// set the field in this object based on the element we just read
switch (r.Name)
{
case "w":
w = float.Parse(r.Value);
break;
case "x":
x = float.Parse(r.Value);
break;
case "y":
y = float.Parse(r.Value);
break;
case "z":
z = float.Parse(r.Value);
break;
}
}
r.MoveToElement(); //Moves the reader back to the element node.
return new Quaternion(w, x, y, z);
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToElement();
reader.ReadStartElement();
Type instanceType = base.GetType().BaseType;
while (reader.IsStartElement())
{
if (reader.HasAttributes)
{
XmlNodeType nodeType = reader.NodeType;
Type t = typeof(FileProcessingJournalEntryData <>);
t = t.MakeGenericType(Type.GetType(reader.GetAttribute("type")));
string name = reader.GetAttribute("name");
var ser = XmlSerializerCache.GetOrAdd(t, name);
object obj = ser.Deserialize(reader.ReadSubtree());
reader.ReadEndElement();
this.EntryData.Add((FileProcessingJournalEntryDataBase)obj);
}
else
{
PropertyInfo Prop = instanceType.GetProperty(reader.Name);
if (Prop != null)
{
var h = reader.ReadElementContentAsObject(Prop.Name, "");
Prop.SetValue(this, Convert.ChangeType(h, Prop.PropertyType), null);
}
}
}
}
public override object ReadObject(XmlReader reader)
{
OneWayAttachmentRequest OneWayAttachmentRequestField = null;
if (IsParentStartElement(reader, false, true))
{
OneWayAttachmentRequestField = new OneWayAttachmentRequest();
OneWayAttachmentRequestField.AnyAttr = ReadAnyAttribute(reader);
reader.Read();
if (IsChildStartElement(reader, "Param", true, true))
{
reader.Read();
if (IsAttribute(reader, "href"))
{
string contentID;
contentID = reader.Value;
reader.MoveToElement();
reader.ReadStartElement("Include", "http://www.w3.org/2004/08/xop/include");
reader.ReadEndElement();
OneWayAttachmentRequestField.Param = GetBodyPartContent(contentID, BodyParts);
}
else
{
OneWayAttachmentRequestField.Param = Convert.FromBase64String(reader.ReadString());
reader.ReadEndElement();
}
}
OneWayAttachmentRequestField.Any = ReadAnyElement(reader, false);
reader.ReadEndElement();
}
return OneWayAttachmentRequestField;
}
public static IFeed GetFeed(Uri url, XmlReader reader) {
reader.MoveToContent();
string language = string.Empty;
FeedType feedType;
string namespaceUri = reader.NamespaceURI;
if(reader.LocalName.Equals("RDF") &&
reader.NamespaceURI.Equals("http://www.w3.org/1999/02/22-rdf-syntax-ns#")) {
feedType = FeedType.Rdf;
reader.Read();
reader.MoveToContent();
} else if(reader.LocalName.Equals("rss")) {
feedType = FeedType.Rss;
do {
reader.Read();
reader.MoveToContent();
} while(!reader.LocalName.Equals("channel") && !reader.LocalName.Equals("rss"));
} else if(reader.NamespaceURI.Equals("http://purl.org/atom/ns#") && reader.LocalName.Equals("feed")) {
if(reader.MoveToAttribute("version") && reader.Value.Equals("0.3")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
reader.MoveToElement();
} else {
throw new ApplicationException(string.Format("Unsupported Atom Version {0}", reader.Value));
}
} else if(reader.NamespaceURI.Equals("http://www.w3.org/2005/Atom") && reader.LocalName.Equals("feed")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
} else {
throw new ApplicationException("Unknown Xml Dialect");
}
return PopulateFeed(url, reader, namespaceUri, feedType, language);
}
public void ReadXml(XmlReader reader)
{
base.ReadXmlAttributes(reader);
reader.MoveToElement();
bool empty = reader.IsEmptyElement;
reader.ReadStartElement(Xml.TestSuite);
if (!empty)
{
reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter);
while (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == Xml.TestSuite)
{
new TestSuite(null, this).ReadXml(reader);
}
else if (reader.Name == TestCase.Xml.TestCase)
{
new TestCase(null, this).ReadXml(reader);
}
reader.ConsumeUntilFirst(XmlReaderHelper.ElementFilter);
}
reader.ReadEndElement();
}
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("WriteBinHex") == false)
{
throw new MyException("Could not find the end of WriteBinHex");
}
reader.Read();
string binHexString = reader.ReadContentAsString(); // good enuff.
if (binHexString == null || binHexString.Length == 0)
{
msg = String.Format("WriteBinHex: reader.Name = {0}, reader.NamespaceURI = {1} reader.Value = {2} binHexString = {3}", reader.Name, reader.NamespaceURI, reader.Value, binHexString);
throw new MyException(msg);
}
reader.MoveToElement(); // move back to WriteBinHex end
int counter = 0;
const int NODES_AT_END = 1;
while (reader.Read())
{
counter++;
}
if (counter != NODES_AT_END)
{
throw new MyException(String.Format("expected {0} nodes, but found {1}", NODES_AT_END, counter));
}
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("WriteAttributes") == false)
{
throw new MyException("Could not find the end of WriteAttributes");
}
//Console.WriteLine("After one ReadToDescendant Name = {0}", reader.Name);
if (reader.HasAttributes)
{
int attribCount = 0;
while (reader.MoveToNextAttribute())
{
attribCount++;
}
//Console.WriteLine("attribCount = {0}", attribCount);
if (attribCount != 3)
{
throw new MyException(String.Format("XmlReader says this node has no elements {0} {1} and I expect 3", reader.Name, reader.NodeType));
}
}
else
{
throw new MyException(String.Format("XmlReader says this node has no elements {0} {1} and I expect 3", reader.Name, reader.NodeType));
}
reader.MoveToElement(); // back at WriteAttributes
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToAttribute("Width");
Width = reader.ReadContentAsInt();
reader.MoveToAttribute("Height");
Height = reader.ReadContentAsInt();
reader.MoveToElement();
SetupWorld(Width, Height);
while (reader.Read())
{
switch (reader.Name)
{
case "Tiles":
ReadXML_Tiles(reader);
break;
case "StaticObjects":
ReadXml_StaticObjects(reader);
break;
case "Characters":
ReadXml_Characters(reader);
break;
}
}
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("WriteBase64") == false)
{
throw new MyException("Could not find the end of WriteBase64");
}
reader.Read();
string base64 = reader.ReadContentAsString();
byte[] bytes = Convert.FromBase64String(base64);
string text = System.Text.Encoding.UTF8.GetString(bytes);
if (text == null || text.Equals("hello world") == false)
{
msg = String.Format("WriteBase64: reader.Name = {0}, reader.NamespaceURI = {1} reader.Value = {2} base64 = {3}", reader.Name, reader.NamespaceURI, reader.Value, base64);
throw new MyException(msg);
}
reader.MoveToElement(); // move back to WriteBase64 end
int counter = 0;
const int NODES_AT_END = 1;
while (reader.Read())
{
counter++;
}
if (counter != NODES_AT_END)
{
throw new MyException(String.Format("expected {0} nodes, but found {1}", NODES_AT_END, counter));
}
}
public static Exception CreateResponseException(XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
reader.MoveToElement();
if (!reader.ReadToDescendant("err"))
throw new XmlException("No error element found in XML");
int code = 0;
string message = (string) null;
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "code")
{
try
{
code = int.Parse(reader.Value, NumberStyles.Any, (IFormatProvider) NumberFormatInfo.InvariantInfo);
}
catch (FormatException ex)
{
throw new FlickrException("Invalid value found in code attribute. Value '" + (object) code + "' is not an integer");
}
}
else if (reader.LocalName == "msg")
message = reader.Value;
}
return (Exception) ExceptionHandler.CreateException(code, message);
}
private static void ReadAttributes(ZXmlNode Node, XmlReader rd)
{
for (int i = 0; i < rd.AttributeCount; i++)
{
rd.MoveToAttribute(i);
Node.Attributes.Add(rd.Name, rd.Value);
}
rd.MoveToElement();
}
private void ProcessAttributes(XmlReader xmlReader, IReqIfParserCallbackReceiver callbackReceiver)
{
while (xmlReader.MoveToNextAttribute())
{
callbackReceiver.ProcessAttribute(xmlReader.Name, xmlReader.Value);
}
xmlReader.MoveToElement();
}
internal virtual void Load (XmlReader reader)
{
reader.ReadToFollowing (XmlName);
FillLocation (reader);
while (reader.MoveToNextAttribute ()) {
LoadAttribute (reader.Name, reader.Value);
}
reader.MoveToElement ();
LoadValue (reader);
}
public static XmlQualifiedName GetXsiType(XmlReader reader)
{
string attribute = reader.GetAttribute("type", "http://www.w3.org/2001/XMLSchema-instance");
reader.MoveToElement();
if (string.IsNullOrEmpty(attribute))
{
return null;
}
return ResolveQName(reader, attribute);
}
public override void ReadXml(XmlReader reader)
{
if (null == reader)
{
throw new ArgumentNullException("reader");
}
if (reader.EOF)
{
throw new ArgumentException("reader is at EOF");
}
reader.MoveToElement();
base.ReadXml(reader);
reader.MoveToElement();
reader.MoveToAttribute("value");
string temp = reader.Value;
reader.MoveToElement();
reader.MoveToAttribute("type");
this._value = ReflectionServices.StrongTypeValue(temp, reader.Value);
}
public object DeserializeObject(XmlReader reader)
{
if (reader.MoveToAttribute(_attributeName))
{
var value = _parseValue(reader.Value);
reader.MoveToElement();
return value;
}
return null;
}
public void ReadXml(XmlReader reader)
{
reader.MoveToAttribute("span");
if (reader.NodeType == XmlNodeType.Attribute)
Span = (int)reader.ReadContentAsDouble();
reader.MoveToElement();
Text = reader.ReadElementContentAsString();
double length;
if (double.TryParse(Text, out length))
Length = length;
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.Read();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string key = reader.Name;
this.Add(key, reader.ReadElementContentAsString());
reader.MoveToElement();
}
reader.ReadEndElement();
}
public static string ReadAttribute(XmlReader xr, string key)
{
string rlt;
if (xr.NodeType == XmlNodeType.Element)
{
xr.MoveToAttribute(key);
rlt = xr.Value;
xr.MoveToElement();
return rlt;
}
return null;
}
public override void ReadXml(XmlReader reader)
{
var solidFill = new SolidFill();
while (reader.MoveToNextAttribute())
if (!Style.TryReadXmlAttribute(reader))
MapXmlReader.HandleUnexpectedAttribute(reader.LocalName);
reader.MoveToElement();
if (!reader.IsEmptyElement && reader.Read() && reader.MoveToContent() != XmlNodeType.EndElement)
throw new Exception("SolidFill element should be empty");
reader.Read();
}
/// <summary>Initializes a new instance of RssGuid</summary>
public RssGuid(XmlReader xmlTextReader) : this()
{
bool emptyElement = xmlTextReader.IsEmptyElement;
while (xmlTextReader.MoveToNextAttribute())
{
XmlSerializationUtil.DecodeXmlTextReaderValue(this, xmlTextReader);
}
if (emptyElement)
return;
xmlTextReader.MoveToElement();
XmlSerializationUtil.DecodeXmlTextReaderValue(this, GetType().GetProperty("Value"), xmlTextReader);
}
public static string GetXmlLangAttribute(XmlReader reader)
{
string xmlLang = null;
if (reader.MoveToAttribute("lang", XmlNs))
{
xmlLang = reader.Value;
reader.MoveToElement();
}
if (xmlLang == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.XmlLangAttributeMissing));
return xmlLang;
}
/// <summary>
/// When a MOS server is communicating with our application we will need
/// to know the version that mosID is configured for inorder to load the correct version
/// </summary>
public static string GetMosIDFromMOSMsg(string xml)
{
XmlReader reader = new XmlReader(xml);
while (reader.Read())
{
// Move to fist element
reader.MoveToElement();
// Read this element's properties and display them on console
Console.WriteLine("Name:" + reader.Name);
if (reader.Name == "mosID")
{
return reader.Value;
}
}
}
/// <summary>Initializes a new instance of RssGuid</summary>
public RssGuid(System.Xml.XmlReader xmlTextReader) : this()
{
bool emptyElement = xmlTextReader.IsEmptyElement;
while (xmlTextReader.MoveToNextAttribute())
{
XmlSerializationUtil.DecodeXmlTextReaderValue(this, xmlTextReader);
}
if (emptyElement)
{
return;
}
//
xmlTextReader.MoveToElement();
XmlSerializationUtil.DecodeXmlTextReaderValue(this, this.GetType().GetProperty("Value"), xmlTextReader);
}
protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue)
{
if (SoapHelper.ReadEmptyStartElement(reader)) // Read start of enclosing element
return null;
if (!reader.MoveToAttribute("type"))
throw new ArgumentException("Cannot deserialize value, 'type' attribute missing");
String typeStr = reader.ReadContentAsString();
Type type = Type.GetType(typeStr);
reader.MoveToElement();
HomogenousMap result = new HomogenousMap(type, typeof(int));
if (SoapHelper.ReadEmptyStartElement(reader, "Values"))
return result;
while (reader.NodeType != XmlNodeType.EndElement)
result.Add(MediaItemAspect.DeserializeValue(reader, type), MediaItemAspect.DeserializeValue(reader, typeof(int)));
reader.ReadEndElement(); // End of enclosing element
return result;
}
/// <summary>
/// Creates a new CombinerParameterElement using the XmlReader instance provided.
/// </summary>
/// <param name="reader">The XmlReader instance positioned at the CombinerParameterElement node.</param>
/// <param name="nodeName">The name of the node for this combiner parameter item.</param>
/// <param name="schemaVersion">The version of the schema that was used to validate.</param>
protected CombinerParameterElement(XmlReader reader, string nodeName, XacmlVersion schemaVersion)
: base(XacmlSchema.Policy, schemaVersion)
{
if (reader == null) throw new ArgumentNullException("reader");
if (reader.LocalName == nodeName &&
ValidateSchema(reader, schemaVersion))
{
// Read the attributes
if (reader.HasAttributes)
{
// Load all the attributes
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == Consts.Schema2.CombinerParameterElement.ParameterName)
{
_parameterName = reader.GetAttribute(Consts.Schema2.CombinerParameterElement.ParameterName);
}
else
{
AttributeFound(reader);
}
}
reader.MoveToElement();
}
// Read the rule contents.
while (reader.Read())
{
switch (reader.LocalName)
{
case Consts.Schema2.CombinerParameterElement.AttributeValue:
_attributeValue = new AttributeValueElement(reader, schemaVersion);
break;
}
if (reader.LocalName == Consts.Schema2.CombinerParameterElement.CombinerParameter &&
reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
}
else
{
throw new Exception(string.Format(Properties.Resource.exc_invalid_node_name, reader.LocalName));
}
}
public void ReadXml(XmlReader reader)
{
reader.Read();
if(reader.Name != "Font")
throw new Exception("Unable to deserialize font. Unknown format. Error: No font tag.");
if(!reader.HasAttributes)
throw new Exception("Unable to deserialize font. Unknown format. Error: Font tag has no attributes.");
bool faceFound = false;
while (reader.MoveToNextAttribute())
{
faceFound = reader.Name == "Face";
if (faceFound)
break;
}
if(!faceFound)
throw new Exception("Unable to deserialize font. Unknown format. Error: Font tag has no Face attribute.");
Face = reader.Value;
reader.MoveToElement();
while (reader.Read())
{
if (reader.IsStartElement())
{
switch(reader.Name)
{
case "Glyph":
ReadGlyph(reader);
break;
}
}
else
{
if(reader.Name == "Font")
break;
}
}
}
public override bool Matches(XmlReader reader, IXmlNamespaceResolver resolver)
{
bool preCondition = false;
switch (mode)
{
case MatchMode.StartElement:
preCondition = reader.NodeType == XmlNodeType.Element;
break;
case MatchMode.StartElementClosed:
if (reader.NodeType == XmlNodeType.Attribute)
{
string name = reader.LocalName;
string ns = reader.NamespaceURI;
if (reader.MoveToNextAttribute())
{
// If we moved, we didn't match and
// we restore the cursor.
reader.MoveToAttribute(name, ns);
preCondition = false;
}
else
{
// We need to evaluate the element name/ns match from
// the base here, moving to the element first
reader.MoveToElement();
preCondition = base.Matches(reader, resolver);
// Restore cursor always.
reader.MoveToAttribute(name, ns);
return preCondition;
}
}
else if (reader.NodeType == XmlNodeType.Element)
{
// Matches the same as StartElement if there are no attributes
preCondition = !reader.HasAttributes;
}
break;
case MatchMode.EndElement:
preCondition = reader.NodeType == XmlNodeType.EndElement;
break;
}
return preCondition && base.Matches(reader, resolver);
}
public void FromXml(XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
if (reader.Name == "Width")
Width = reader.ReadContentAsInt();
else if (reader.Name == "Height")
Height = reader.ReadContentAsInt();
else if (reader.Name == "Name")
Name = reader.ReadContentAsString();
else if (reader.Name == "PositionNaming")
{
var index = reader.ReadContentAsInt();
if (index < PositionNamings.Defined.Length) PositionNaming = PositionNamings.Defined[index];
}
}
reader.MoveToElement();
}
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
var records = new List <Record>();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (!reader.IsEmptyElement && reader.LocalName == "Descriptor")
{
reader.MoveToElement();
_descriptor = new Record.RecordDescriptor();
((System.Xml.Serialization.IXmlSerializable)_descriptor).ReadXml(reader);
}
else if (!reader.IsEmptyElement && reader.LocalName == "Records")
{
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.LocalName == "Record")
{
var record = new Record(_descriptor);
((IXmlSerializable)record).ReadXml(reader);
records.Add(record);
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
_records = records;
}
/// <summary>
/// Recupera os dados contidos no xml informado.
/// </summary>
/// <param name="reader"></param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("name"))
{
Name = reader.ReadContentAsString();
}
reader.MoveToElement();
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "Parameters")
{
if (!reader.IsEmptyElement)
{
((System.Xml.Serialization.IXmlSerializable)Parameters).ReadXml(reader);
}
else
{
reader.Skip();
}
}
else if (reader.Name == "Children")
{
if (!reader.IsEmptyElement)
{
ReadChildrenXml(reader);
}
else
{
reader.Skip();
}
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
private bool IsCollection()
{
var isCollection = false;
if (reader.HasAttributes)
{
var ok = reader.MoveToFirstAttribute();
while (ok)
{
var name = reader.Name;
var attName = name.ChangeCase(TextCase.PascalCase);
if (attName.Equals("IsArray"))
{
isCollection = (reader.Value == "true") || (reader.Value == "1");
break;
}
ok = reader.MoveToNextAttribute();
}
}
reader.MoveToElement();
return(isCollection);
}
public override bool MoveToElement()
{
CheckAsync();
return(_coreReader.MoveToElement());
}
public override bool MoveToElement()
{
return(reader.MoveToElement());
}
public virtual void WriteNode(XmlReader reader, bool defattr)
{
if (reader == null)
{
throw new ArgumentException();
}
if (reader.ReadState == ReadState.Initial)
{
reader.Read();
do
{
WriteNode(reader, defattr);
}while (!reader.EOF);
return;
}
switch (reader.NodeType)
{
case XmlNodeType.Element:
WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
#if false
WriteAttributes(reader, defattr);
reader.MoveToElement();
#else
// Well, I found that MS.NET took this way, since
// there was a error-prone SgmlReader that fails
// MoveToNextAttribute().
if (reader.HasAttributes)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
WriteAttribute(reader, defattr);
}
reader.MoveToElement();
}
#endif
if (reader.IsEmptyElement)
{
WriteEndElement();
}
else
{
int depth = reader.Depth;
reader.Read();
if (reader.NodeType != XmlNodeType.EndElement)
{
do
{
WriteNode(reader, defattr);
}while (depth < reader.Depth);
}
WriteFullEndElement();
}
break;
// In case of XmlAttribute, don't proceed reader, and it will never be written.
case XmlNodeType.Attribute:
return;
case XmlNodeType.Text:
WriteString(reader.Value);
break;
case XmlNodeType.CDATA:
WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
// LAMESPEC: It means that XmlWriter implementation _must not_ check
// whether PI name is "xml" (it is XML error) or not.
case XmlNodeType.ProcessingInstruction:
WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Comment:
WriteComment(reader.Value);
break;
case XmlNodeType.DocumentType:
WriteDocType(reader.Name,
reader ["PUBLIC"], reader ["SYSTEM"], reader.Value);
break;
case XmlNodeType.SignificantWhitespace:
goto case XmlNodeType.Whitespace;
case XmlNodeType.Whitespace:
WriteWhitespace(reader.Value);
break;
case XmlNodeType.EndElement:
WriteFullEndElement();
break;
case XmlNodeType.EndEntity:
break;
case XmlNodeType.None:
break; // Do nothing, nor reporting errors.
default:
throw new XmlException("Unexpected node " + reader.Name + " of type " + reader.NodeType);
}
reader.Read();
}
private XmlNode?LoadNode(bool skipOverWhitespace)
{
XmlReader r = _reader !;
XmlNode? parent = null;
XmlElement? element;
IXmlSchemaInfo?schemaInfo;
do
{
XmlNode?node;
switch (r.NodeType)
{
case XmlNodeType.Element:
bool fEmptyElement = r.IsEmptyElement;
element = _doc !.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);
element.IsEmpty = fEmptyElement;
if (r.MoveToFirstAttribute())
{
XmlAttributeCollection attributes = element.Attributes;
do
{
XmlAttribute attr = LoadAttributeNode();
attributes.Append(attr); // special case for load
}while (r.MoveToNextAttribute());
r.MoveToElement();
}
// recursively load all children.
if (!fEmptyElement)
{
parent?.AppendChildForLoad(element, _doc);
parent = element;
continue;
}
else
{
schemaInfo = r.SchemaInfo;
if (schemaInfo != null)
{
element.XmlName = _doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
node = element;
break;
}
case XmlNodeType.EndElement:
if (parent == null)
{
return(null);
}
Debug.Assert(parent.NodeType == XmlNodeType.Element);
schemaInfo = r.SchemaInfo;
if (schemaInfo != null)
{
element = parent as XmlElement;
if (element != null)
{
element.XmlName = _doc !.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
}
if (parent.ParentNode == null)
{
return(parent);
}
parent = parent.ParentNode;
continue;
case XmlNodeType.EntityReference:
node = LoadEntityReferenceNode(false);
break;
case XmlNodeType.EndEntity:
Debug.Assert(parent == null);
return(null);
case XmlNodeType.Attribute:
node = LoadAttributeNode();
break;
case XmlNodeType.Text:
node = _doc !.CreateTextNode(r.Value);
break;
case XmlNodeType.SignificantWhitespace:
node = _doc !.CreateSignificantWhitespace(r.Value);
break;
case XmlNodeType.Whitespace:
if (_preserveWhitespace)
{
node = _doc !.CreateWhitespace(r.Value);
break;
}
else if (parent == null && !skipOverWhitespace)
{
// if called from LoadEntityReferenceNode, just return null
return(null);
}
else
{
continue;
}
case XmlNodeType.CDATA:
node = _doc !.CreateCDataSection(r.Value);
break;
case XmlNodeType.XmlDeclaration:
node = LoadDeclarationNode();
break;
case XmlNodeType.ProcessingInstruction:
node = _doc !.CreateProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.Comment:
node = _doc !.CreateComment(r.Value);
break;
case XmlNodeType.DocumentType:
node = LoadDocumentTypeNode();
break;
default:
throw UnexpectedNodeType(r.NodeType);
}
Debug.Assert(node != null);
if (parent != null)
{
parent.AppendChildForLoad(node, _doc !);
}
else
{
return(node);
}
}while (r.Read());
// when the reader ended before full subtree is read, return whatever we have created so far
if (parent != null)
{
while (parent.ParentNode != null)
{
parent = parent.ParentNode;
}
}
return(parent);
}
public void DoSearch(string[] parts, ArrayList result, System.Xml.XmlReader reader, bool securityTrimmingEnabled)
{
if (reader.ReadToFollowing("category", ns) && reader.MoveToAttribute("name") && reader.Value == "Root" && reader.MoveToElement())
{
int i = 1;
if (i < parts.Length)
{
ReadSubElements(reader, parts, i, result, securityTrimmingEnabled);
}
else
{
ReadSubItems(reader, result, securityTrimmingEnabled);
}
}
}
public static List <XmlReadInstructions> AnalyseXmlReader(System.Xml.XmlReader reader, bool globalUniqueColumnNames)
{
var root = new Node();
var current = root;
var resultSets = new Dictionary <string, Node>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
current = current.SubElement(reader.Name);
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
current.Attribute(reader.Name);
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
if (current.CurrentCount > 1)
{
string xpath = current.AbsXPath;
if (!resultSets.ContainsKey(xpath))
{
resultSets[xpath] = current;
current.IsRepetetive = true;
}
}
if (reader.IsEmptyElement)
{
current = current.Parent;
}
break;
case XmlNodeType.Text:
if (!String.IsNullOrWhiteSpace(reader.Value))
{
current.HasText = true;
}
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
continue;
case XmlNodeType.EndElement:
current = current.Parent;
break;
}
}
// remove repetetive parents. Remains only innermost repetetives
foreach (var resultSet in resultSets.Values.ToList())
{
var node = resultSet;
node = node.Parent;
while (node != null && !node.IsRepetetive)
{
node = node.Parent;
}
if (node != null)
{
resultSets.Remove(node.AbsXPath);
node.IsRepetetive = false;
}
}
if (!resultSets.Any())
{
resultSets["/"] = root;
}
var res = new List <XmlReadInstructions>();
var addedColumns = new HashSet <string>();
var collectionNames = new HashSet <string>();
foreach (var resultSet in resultSets.Values)
{
var instruction = new XmlReadInstructions();
instruction.XPath = resultSet.AbsXPath ?? "/";
string collectionName = resultSet.Name;
if (collectionNames.Contains(collectionName))
{
int index = 2;
while (collectionNames.Contains(collectionName + index))
{
index++;
}
collectionName = collectionName + index;
}
instruction.CollectionName = collectionName;
if (!globalUniqueColumnNames)
{
addedColumns.Clear();
}
CollectColumns(instruction, root, addedColumns, resultSet);
if (resultSet != root)
{
CollectColumns(instruction, resultSet, addedColumns, resultSet);
}
res.Add(instruction);
}
return(res);
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("WriteAttributeString") == false)
{
throw new MyException("Could not find the end of WriteAttributeString");
}
//Console.WriteLine("AFter 1 reader.NodeType, {0} name {1} depth {2}", reader.NodeType, reader.Name, reader.Depth);
if (reader.HasAttributes)
{
int attribCount = 0;
string msg = null;
while (reader.MoveToNextAttribute())
{
Trace.WriteLine(String.Format("attribute[{0}], localname=\"{1}\" value=\"{2}\" namespaceURI=\"{3}\"", attribCount, reader.LocalName, reader.Value, reader.NamespaceURI));
if (String.IsNullOrEmpty(reader.LocalName))
{
continue;
}
switch (reader.LocalName)
{
case "attributeName":
if (reader.Prefix == null || !reader.Prefix.Equals("abc"))
{
msg = String.Format("attributeName: reader.Name = {0}, reader.NamespaceURI = {1} reader.Value = {2} reader.Prefix = {3}", reader.Name, reader.NamespaceURI, reader.Value, reader.Prefix);
throw new MyException(msg);
}
break;
case "attributeName2":
break;
case "attributeName3":
if (reader.NamespaceURI == null || !reader.NamespaceURI.Equals("myNameSpace3"))
{
msg = String.Format("attributeName: reader.Name = {0}, reader.NamespaceURI = {1} reader.ReadAttributeValue() = {2} reader.Prefix = {3}", reader.Name, reader.NamespaceURI, reader.Value, reader.Prefix);
throw new MyException(msg);
}
break;
default:
if (reader.Value != null && reader.Value.Equals("myNameSpace3"))
{
// this is my namespace declaration, it is OK
break;
}
if (reader.LocalName != null && reader.LocalName.Equals("abc"))
{
// this is my namespace declaration, it is OK
break;
}
msg = String.Format("DEFAULT LocalName <{0}> \r\n reader.Name = <{1}>, \r\n reader.NamespaceURI = <{2}> \r\n reader.ReadAttributeValue() = {3}", reader.LocalName, reader.Name, reader.NamespaceURI, reader.Value);
throw new MyException(msg);
}
attribCount++;
}
//Console.WriteLine("attribCount = {0}", attribCount);
if (attribCount != 5)
{
throw new MyException(String.Format("XmlReader says this node {0} {1} has no elements and I expect 4", reader.Name, reader.NodeType));
}
}
else
{
throw new MyException(String.Format("XmlReader says this node has no elements {0} {1} and I expect 3", reader.Name, reader.NodeType));
}
reader.MoveToElement(); // back at WriteAttributes
}
public override object Parse(System.Xml.XmlReader s, DatatypeFormatterParseResult result)
{
// Create the types
Type ivlType = typeof(IVL <>);
Type ivlGenericType = ivlType.MakeGenericType(GenericArguments);
// Sometimes there can be just a messy, unstructured value inline with this IVL (like in CCDA) so we still need to support that
MemoryStream leftOvers = new MemoryStream();
XmlWriter leftoverWriter = XmlWriter.Create(leftOvers);
leftoverWriter.WriteStartElement(s.LocalName, s.NamespaceURI);
// Create an instance of rto from the rtoType
object instance = ivlGenericType.GetConstructor(Type.EmptyTypes).Invoke(null);
if (s.MoveToFirstAttribute())
{
do
{
switch (s.LocalName)
{
case "nullFlavor":
((ANY)instance).NullFlavor = (NullFlavor)Util.FromWireFormat(s.GetAttribute("nullFlavor"), typeof(NullFlavor));
break;
case "operator":
ivlGenericType.GetProperty("Operator").SetValue(instance, Util.FromWireFormat(s.GetAttribute("operator"), typeof(SetOperator?)), null);
break;
case "specializationType":
if (result.CompatibilityMode == DatatypeFormatterCompatibilityMode.Canadian)
{
((ANY)instance).Flavor = s.GetAttribute("specializationType");
}
break;
default:
leftoverWriter.WriteAttributeString(s.Prefix, s.LocalName, s.NamespaceURI, s.Value);
break;
}
} while (s.MoveToNextAttribute());
s.MoveToElement();
}
// Get property information
PropertyInfo lowProperty = ivlGenericType.GetProperty("Low"),
highProperty = ivlGenericType.GetProperty("High"),
widthProperty = ivlGenericType.GetProperty("Width"),
centerProperty = ivlGenericType.GetProperty("Center"),
lowClosedProperty = ivlGenericType.GetProperty("LowClosed"),
highClosedProperty = ivlGenericType.GetProperty("HighClosed"),
valueProperty = ivlGenericType.GetProperty("Value");
// Now process the elements
#region Elements
if (!s.IsEmptyElement)
{
int sDepth = s.Depth;
string sName = s.Name;
s.Read();
// string Name
while (!(s.NodeType == System.Xml.XmlNodeType.EndElement && s.Depth == sDepth && s.Name == sName))
{
string oldName = s.Name; // Name
try
{
if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "low") // low value
{
if (!String.IsNullOrEmpty(s.GetAttribute("inclusive")))
{
lowClosedProperty.SetValue(instance, Util.FromWireFormat(s.GetAttribute("inclusive"), typeof(bool?)), null);
}
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
lowProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "high") // high value
{
if (!String.IsNullOrEmpty(s.GetAttribute("inclusive")))
{
highClosedProperty.SetValue(instance, Util.FromWireFormat(s.GetAttribute("inclusive"), typeof(bool?)), null);
}
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
highProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "center") // center
{
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
centerProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "width") // width
{
var parseResult = Host.Parse(s, typeof(PQ));
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
widthProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element)
{
leftoverWriter.WriteNode(s, true);
//result.AddResultDetail(new NotImplementedElementResultDetail(ResultDetailType.Warning, s.LocalName, s.NamespaceURI, s.ToString(), null));
}
}
catch (MessageValidationException e) // Message validation error
{
result.AddResultDetail(new MARC.Everest.Connectors.ResultDetail(MARC.Everest.Connectors.ResultDetailType.Error, e.Message, e));
}
finally
{
if (s.Name == oldName)
{
s.Read();
}
}
}
}
#endregion
// Process any leftovers as Value !!!
try
{
leftoverWriter.WriteEndElement();
leftoverWriter.Flush();
leftOvers.Seek(0, SeekOrigin.Begin);
using (XmlReader xr = XmlReader.Create(leftOvers))
{
xr.MoveToContent();
if (xr.AttributeCount > 1 || !xr.IsEmptyElement)
{
bool isNotEmpty = !xr.IsEmptyElement;
if (xr.MoveToFirstAttribute())
{
do
{
isNotEmpty |= xr.Prefix != "xmlns" && xr.LocalName != "xmlns" && xr.NamespaceURI != DatatypeFormatter.NS_XSI;
} while (!isNotEmpty && xr.MoveToNextAttribute());
}
xr.MoveToElement();
if (isNotEmpty)
{
var baseResult = base.Parse(xr, result);
valueProperty.SetValue(instance, Util.FromWireFormat(baseResult, valueProperty.PropertyType), null);
}
}
}
}
catch { }
// Validate
base.Validate(instance as ANY, s.LocalName, result);
return(instance);
}
private void ReadSubElements(System.Xml.XmlReader reader, string[] parts, int i, ArrayList result, bool securityTrimmingEnabled)
{
string nextName = parts[i];
int depth = reader.Depth + 1;
while (reader.Read())
{
if (reader.Depth == depth)
{
switch (reader.NodeType)
{
case System.Xml.XmlNodeType.Attribute:
case System.Xml.XmlNodeType.CDATA:
case System.Xml.XmlNodeType.Comment:
case System.Xml.XmlNodeType.Whitespace:
continue;
case System.Xml.XmlNodeType.EndElement:
break;
case System.Xml.XmlNodeType.Element:
break;
default:
throw new System.Xml.XmlException("读取到错误的节点");
}
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
bool hit = false;
if (reader.MoveToAttribute("name"))
{
hit = reader.Value == nextName;
if (hit)
{
hit = DeterminVisible(reader);
}
reader.MoveToElement();
}
if (hit)
{
i++;
if (i < parts.Length)
{
ReadSubElements(reader, parts, i, result, securityTrimmingEnabled);
}
else
{
ReadSubItems(reader, result, securityTrimmingEnabled);
}
break;
}
else
{
//reader.Skip();
}
}
}
else if (reader.Depth > depth)
{
reader.Skip();
}
else
{
break;
}
}
}
private static Int32 GetRanksTelecomResponseStatus(string responseString)
{
int statusCode = -1;// Invalid value
// Confirm status in response
System.IO.MemoryStream ms = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(responseString));
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(ms);
while (reader.Read())
{
string elementName = "status";
if (reader.NodeType == XmlNodeType.Element)
{
elementName = reader.LocalName;
if (elementName.ToLower() == "status")
{
statusCode = Convert.ToInt32(reader["status"]);
if (statusCode == 0)
{
break;
}
}
}
reader.MoveToElement();
}
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("Response status: ", logModule);
switch (statusCode)
{
case 0:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("0 Request was successful (all recipients)", logModule);
break;
}
case -1:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-1 Error in processing the request", logModule);
break;
}
case -2:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-2 Not enough credits on a specific account", logModule);
break;
}
case -3:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-3 Targeted network is not covered on specific account", logModule);
break;
}
case -5:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-5 Username or password is invalid", logModule);
break;
}
case -6:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-6 Destination address is missing in the request", logModule);
break;
}
case -10:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("10 Username is missing in the request", logModule);
break;
}
case -11:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("11 Password is missing in the request", logModule);
break;
}
case -13:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("13 Number is not recognized by the platform", logModule);
break;
}
case -22:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-22 Incorrect format, caused by syntax error", logModule);
break;
}
case -23:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-23 General error, reasons may vary", logModule);
break;
}
case -26:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-26 General API error, reasons may vary", logModule);
break;
}
case -28:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-28 Invalid PushURL in the request", logModule);
break;
}
case -33:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-33 Duplicated MessageID in the request", logModule);
break;
}
case -34:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-34 Sender name is not allowed", logModule);
break;
}
case -99:
{
VaaaN.TollMax.Library.SharedLibrary.FileIO.Log.Write("-99 Error in processing request, reasons may vary", logModule);
break;
}
}
return(statusCode);
}
private CategoryDirectory ReadResult(System.Xml.XmlReader reader, bool securityTrimmingEnabled)
{
CategoryDirectory result = null;
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (reader.LocalName == "category" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryDirectory();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
reader.MoveToElement();
}
}
else if (reader.LocalName == "item" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryLink();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
if (reader.MoveToAttribute("group"))
{
((CategoryLink)result).Group = reader.ReadContentAsInt();
}
if (reader.MoveToAttribute("href"))
{
((CategoryLink)result).Url = reader.Value;
}
if (reader.MoveToAttribute("role"))
{
((CategoryLink)result).Role = reader.Value;
}
if (reader.MoveToAttribute("feature"))
{
((CategoryLink)result).Feature = reader.Value;
}
}
}
else if (reader.LocalName == "group" && reader.NamespaceURI == ns)
{
if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader))
{
result = new CategoryGroup();
if (reader.MoveToAttribute("name"))
{
result.Name = reader.Value;
}
if (reader.MoveToAttribute("title"))
{
result.Title = reader.Value;
}
reader.MoveToElement();
ArrayList list = new ArrayList();
ReadSubItems(reader, list, securityTrimmingEnabled);
((CategoryGroup)result).Categories = (CategoryDirectory[])list.ToArray(typeof(CategoryDirectory));
}
else
{
var level = reader.Depth;
while (reader.Read() && reader.Depth > level)
{
reader.Skip(); //跳过其任何子节点
}
}
}
}
reader.MoveToElement();
return(result);
}
XmlNode ReadNodeCore(XmlReader reader)
{
switch (reader.ReadState)
{
case ReadState.Interactive:
break;
case ReadState.Initial:
#if NET_2_0
if (reader.SchemaInfo != null)
{
SchemaInfo = reader.SchemaInfo;
}
#endif
reader.Read();
break;
default:
return(null);
}
XmlNode n;
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
string localName = reader.LocalName;
string ns = reader.NamespaceURI;
n = ReadAttributeNode(reader);
// Keep the current reader position on attribute.
reader.MoveToAttribute(localName, ns);
return(n);
case XmlNodeType.CDATA:
n = CreateCDataSection(reader.Value);
break;
case XmlNodeType.Comment:
n = CreateComment(reader.Value);
break;
case XmlNodeType.Element:
XmlElement element = CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.NameTable == this.NameTable);
#if NET_2_0
if (reader.SchemaInfo != null)
{
SchemaInfo = reader.SchemaInfo;
}
#endif
element.IsEmpty = reader.IsEmptyElement;
// set the element's attributes.
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
element.SetAttributeNode(
ReadAttributeNode(reader));
reader.MoveToElement();
}
// FIXME: the code below should be fine and
// in some XmlReaders it is much faster, but
// caused some breakage in sys.data test.
/*
* if (reader.MoveToFirstAttribute ()) {
* do {
* element.SetAttributeNode (ReadAttributeNode (reader));
* } while (reader.MoveToNextAttribute ());
* reader.MoveToElement ();
* }
*/
reader.MoveToElement();
int depth = reader.Depth;
if (reader.IsEmptyElement)
{
n = element;
break;
}
reader.Read();
while (reader.Depth > depth)
{
n = ReadNodeCore(reader);
if (preserveWhitespace || n.NodeType != XmlNodeType.Whitespace)
{
element.AppendChild(n, false);
}
}
n = element;
break;
case XmlNodeType.ProcessingInstruction:
n = CreateProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Text:
n = CreateTextNode(reader.Value);
break;
case XmlNodeType.XmlDeclaration:
n = CreateXmlDeclaration("1.0", String.Empty, String.Empty);
n.Value = reader.Value;
break;
case XmlNodeType.DocumentType:
DTDObjectModel dtd = null;
IHasXmlParserContext ctxReader = reader as IHasXmlParserContext;
if (ctxReader != null)
{
dtd = ctxReader.ParserContext.Dtd;
}
if (dtd != null)
{
n = CreateDocumentType(dtd);
}
else
{
n = CreateDocumentType(reader.Name, reader ["PUBLIC"], reader ["SYSTEM"], reader.Value);
}
break;
case XmlNodeType.EntityReference:
if (this.loadMode && this.DocumentType != null &&
DocumentType.Entities.GetNamedItem(reader.Name) == null)
{
throw new XmlException("Reference to undeclared entity was found.");
}
n = CreateEntityReference(reader.Name);
// IF argument XmlReader can resolve entity,
// ReadNode() also fills children _from it_.
// In this case, it is not from doctype node.
// (it is kind of sucky design, but it happens
// anyways when we modify doctype node).
//
// It does not happen when !CanResolveEntity.
// (In such case AppendChild() will resolve
// entity content, as XmlEntityReference does.)
if (reader.CanResolveEntity)
{
reader.ResolveEntity();
reader.Read();
for (XmlNode child; reader.NodeType != XmlNodeType.EndEntity && (child = ReadNode(reader)) != null;)
{
n.InsertBefore(child, null, false, false);
}
}
break;
case XmlNodeType.SignificantWhitespace:
n = CreateSignificantWhitespace(reader.Value);
break;
case XmlNodeType.Whitespace:
n = CreateWhitespace(reader.Value);
break;
case XmlNodeType.None:
return(null);
default:
// No idea why MS does throw NullReferenceException ;-P
throw new NullReferenceException("Unexpected node type " + reader.NodeType + ".");
}
reader.Read();
return(n);
}
