/// <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 Mass(Model model, XmlReader xml) : base(model,xml) {//throws Exception {
//super(model, xml);
//foreach(XmlAttribute attribute in xml.Attributes)
//{
//string key = attribute.Name;
if (xml.MoveToAttribute("VX".ToLower()))
{
velocityX = double.Parse(xml.ReadContentAsString());
}
if (xml.MoveToAttribute("VY".ToLower()))
{
velocityY = double.Parse(xml.ReadContentAsString());
}
//}
//Enumeration enum = xml.enumerateAttributeNames();
//while (enum.hasMoreElements()) {
// String key = enum.nextElement().toString();
// if (key.equals("VX")) {
// velocityX = xml.getDoubleAttribute(key);
// }
// if (key.equals("VY")) {
// velocityY = xml.getDoubleAttribute(key);
// }
//}
}
public void Load (XmlReader x)
{
if(x.MoveToAttribute("ShowParameters"))
ShowFuncParams = Boolean.Parse(x.ReadContentAsString());
if(x.MoveToAttribute("ShowVariables"))
ShowFuncVariables = Boolean.Parse(x.ReadContentAsString());
if(x.MoveToAttribute("ShowTypes"))
ShowBaseTypes = Boolean.Parse(x.ReadContentAsString());
if(x.MoveToAttribute("GrayOutNonPublic"))
GrayOutNonPublic = Boolean.Parse(x.ReadContentAsString());
if(x.MoveToAttribute("ExpansionBehaviour"))
Enum.TryParse(x.ReadContentAsString(),out ExpansionBehaviour);
}
/// <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();
}
public static UserDetail loadUserDetail(XmlReader reader)
{
reader.MoveToAttribute("name");
var user = reader.ReadContentAsString();
reader.MoveToAttribute("pass");
var password = reader.ReadContentAsString();
reader.MoveToAttribute("type");
var accountType = (byte) reader.ReadContentAsInt();
reader.MoveToAttribute("known");
var flag = reader.ReadContentAsString().ToLower().Equals("true");
return new UserDetail(user, password, accountType)
{
known = flag
};
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer serializer = new XmlSerializer(typeof(string));
if (reader.IsEmptyElement || !reader.Read())
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Comment)
{
reader.ReadEndElement();
reader.MoveToContent();
continue;
}
string key = reader.GetAttribute("key");
reader.ReadStartElement("item");
string value = reader.ReadContentAsString();
reader.ReadEndElement();
reader.MoveToContent();
properties.Add(key, value);
}
reader.ReadEndElement();
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
if (reader.LocalName != "service")
{
UtilityMethods.CheckParsingException(reader);
}
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "id":
Id = reader.Value;
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
Name = reader.ReadContentAsString();
reader.Skip();
}
public void ReadXml(XmlReader reader)
{
m_name = reader.Name;
while (reader.Read())
{
reader.SkipEmptyNodes();
if (reader.NodeType == XmlNodeType.EndElement)
{
// the end
break;
}
else if (reader.NodeType == XmlNodeType.Element)
{
reader.Read(); // go into ValueNode
reader.SkipEmptyNodes();
}
if (reader.NodeType != XmlNodeType.Text)
{
throw new Exception("Required NodeType: Text - Found: " + reader.NodeType);
}
var value = reader.ReadContentAsString();
Pairs.Add(new KeyValuePair<string, string>(reader.Name, value));
if (reader.NodeType == XmlNodeType.EndElement)
{
// the end
reader.ReadInnerXml();
}
}
}
void IFlickrParsable.Load(XmlReader reader)
{
if (!(reader.LocalName != "tag"))
;
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "id":
this.TagId = reader.Value;
continue;
case "author":
this.AuthorId = reader.Value;
continue;
case "authorname":
this.AuthorName = reader.Value;
continue;
case "raw":
this.Raw = reader.Value;
continue;
case "machine_tag":
this.IsMachineTag = reader.Value == "1";
continue;
default:
continue;
}
}
reader.Read();
this.TagText = reader.ReadContentAsString();
reader.Skip();
}
void IFlickrParsable.Load(XmlReader reader)
{
if (reader.LocalName != "place_type")
UtilityMethods.CheckParsingException(reader);
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "place_type_id":
case "id":
Id = reader.ReadContentAsInt();
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
Name = reader.ReadContentAsString();
reader.Skip();
}
public override void ReadXml(XmlReader reader)
{
Keyword.Clear();
var subReader = reader.ReadSubtree();
if (CheckEmptyNode(subReader, "KeywordList", string.Empty, true))
return;
while (!subReader.EOF)
{
subReader.MoveToContent();
if (subReader.LocalName == "Keyword")
{
var att = subReader.GetAttribute("vocabulary");
reader.ReadStartElement("Keyword");
var val = reader.ReadContentAsString();
reader.ReadEndElement();
Keyword.Add(new Keyword { Vocabulary = att, Value = val });
}
else
{
subReader.ReadEndElement();
}
}
reader.Skip();
}
public static string readString(XmlReader reader, string nodeName)
{
reader.ReadStartElement(nodeName);
string s = reader.ReadContentAsString();
reader.ReadEndElement();
return s;
}
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 void ReadXml(XmlReader reader)
{
Boolean isEmpty = reader.IsEmptyElement;
AddAttributeExtensions(reader);
reader.ReadStartElement();
if (!isEmpty)
{
//Read the text content of the element
String rawValue = reader.ReadContentAsString();
if (!String.IsNullOrEmpty(rawValue))
{
//Split the raw string on commas to get the individual items
String[] unSplitItems = rawValue.Split(',');
foreach (var unSplitItem in unSplitItems)
{
//Split the items on the colon to seperate the tag from the weight
String[] splitItem = unSplitItem.Split(':');
TagCollection.Add(splitItem[0].Trim(), Int32.Parse(splitItem[1].Trim()));
}
}
}
reader.ReadEndElement();
}
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 virtual void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.HasAttributes)
while (reader.MoveToNextAttribute())
AttributeWasRead(reader.Name, reader.Value);
AllAttributesRead();
var isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
while (reader.Read())
{
var nodeType = reader.NodeType;
switch (nodeType)
{
case XmlNodeType.Text:
var content = reader.ReadContentAsString();
ContentWasRead(string.Empty, content);
break;
case XmlNodeType.Element:
var name = reader.Name;
ProcessElement(name, reader);
break;
}
}
}
}
public void ReadXml(XmlReader reader)
{
var isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
for (var i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.NamespaceURI == "")
{
if (reader.LocalName == "type")
{
Type = reader.Value;
}
else
{
AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
reader.ReadStartElement();
if (!isEmpty)
{
DescriptionText = reader.ReadContentAsString();
}
reader.ReadEndElement();
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "usage":
Usage = reader.ReadContentAsInt();
break;
case "predicate":
PredicateName = reader.Value;
break;
case "namespace":
NamespaceName = reader.Value;
break;
}
}
reader.Read();
if (reader.NodeType == XmlNodeType.Text)
PairName = reader.ReadContentAsString();
reader.Read();
}
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
// string Name = reader.GetAttribute("Name");
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
//string es = reader.ReadElementString("pubDate");
//this.m_value = System.DateTime.ParseExact(
// reader.ReadElementString("pubDate")
// , "ddd, dd MMM yyyy HH:mm z"
// , System.Globalization.CultureInfo.InvariantCulture
//);
string dateString = reader.ReadContentAsString();
int timeZonePos = dateString.LastIndexOf(' ') + 1;
string tz = dateString.Substring(timeZonePos);
dateString = dateString.Substring(0, dateString.Length - tz.Length);
dateString += s_timeZoneOffsets[tz];
// https://msdn.microsoft.com/en-us/library/w2sa9yss(v=vs.110).aspx
this.m_value = System.DateTime.ParseExact(
dateString
, "ddd, dd MMM yyyy HH:mm zzz"
, System.Globalization.CultureInfo.InvariantCulture
);
reader.ReadEndElement();
} // End if (!isEmptyElement)
} // End Sub ReadXml
private ClientData(XmlReader reader)
{
reader.ReadStartElement("ClientData");
for (int iter = 0; iter < _NumStoredValues; iter++) {
reader.ReadStartElement(_StoredValueNames[iter]);
if (_StoredValues[iter] is string)
_StoredValues[iter] = reader.ReadContentAsString();
else if (_StoredValues[iter] is DateTime) {
string s = reader.ReadContentAsString();
long l = long.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
_StoredValues[iter] = DateTime.FromFileTimeUtc(l);
} else if (_StoredValues[iter] is bool) {
string s = reader.ReadContentAsString();
_StoredValues[iter] = !(string.IsNullOrEmpty(s) || s != "1");
} else {
_StoredValues[iter] = ReadStringArray(reader);
}
reader.ReadEndElement();
}
reader.ReadEndElement();
}
private static IEnumerable<string> ReadMedia(XmlReader media)
{
while (media.ReadToFollowing("local"))
{
media.MoveToFirstAttribute();
yield return media.ReadContentAsString();
}
}
private static KeyNameIdentifierClause ReadKeyNameClause(XmlReader reader)
{
reader.ReadStartElement("KeyName", SignedXml.XmlDsigNamespaceUrl);
var keyIdentifier = new KeyNameIdentifierClause(reader.ReadContentAsString());
reader.ReadEndElement();
return keyIdentifier;
}
public void ReadXml(XmlReader reader)
{
// Deserialize databases.
while (reader.IsStartElement("IDatabase"))
{
reader.ReadStartElement("IDatabase");
reader.ReadStartElement("AssemblyQualifiedName");
string typeName = reader.ReadContentAsString();
reader.ReadEndElement();
reader.ReadStartElement("CheckedState");
string state = reader.ReadContentAsString();
reader.ReadEndElement();
Type databaseType = Type.GetType(typeName);
//TODO: find new way
// when database type is deleted
if (databaseType == null)
{
reader.Skip();
reader.Skip();
reader.ReadStartElement("Color");
reader.Skip();
reader.ReadEndElement();
}
else
{
bool checkedState = Boolean.Parse(state);
XmlSerializer databaseDeserializer = new XmlSerializer(databaseType);
IDatabase database = (IDatabase)databaseDeserializer.Deserialize(reader);
reader.ReadStartElement("Color");
database.Color = ColorTranslator.FromHtml(reader.ReadContentAsString());
reader.ReadEndElement();
Databases.Add(database, checkedState);
}
reader.ReadEndElement(); // IDatabase.
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement("PathRule");
reader.ReadStartElement();
this.Disabled = reader.ReadContentAsBoolean();
reader.ReadEndElement();
reader.ReadStartElement();
this.Path = reader.ReadContentAsString();
reader.ReadEndElement();
}
/// <summary>
/// Generates a collection from its XML representation.
/// </summary>
/// <param name="reader">System.Xml.XmlReader</param>
public void ReadXml(XmlReader reader)
{
this.Clear();
if (reader.ReadToDescendant("SerializableStringDictionary"))
{
if (reader.ReadToDescendant("DictionaryEntry"))
{
do
{
reader.MoveToAttribute("Key");
string key = reader.ReadContentAsString();
reader.MoveToAttribute("Value");
string value = reader.ReadContentAsString();
this.Add(key, value);
} while (reader.ReadToNextSibling("DictionaryEntry"));
}
}
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Authority = reader.GetAttribute("authority");
var isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmpty)
{
Value = reader.ReadContentAsString();
reader.ReadEndElement();
}
}
public override void ReadXml(XmlReader reader)
{
var isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
reader.ReadStartElement("Format");
Format = reader.ReadContentAsString();
reader.ReadEndElement();
OnlineResource.ReadXml(reader);
}
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Code = reader.GetAttribute("code");
Locator = reader.GetAttribute("locator");
var isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmpty)
{
Value = reader.ReadContentAsString();
reader.ReadEndElement();
}
}
public Spring(Model model, XmlReader xml) :base(model,xml) {//throws Exception {
//super(model, xml);
//foreach(XmlAttribute attribute in xml.Attributes)
//{
// string key = attribute.Name;
if (xml.MoveToAttribute("RESTLENGTH".ToLower()))
{
restLength = double.Parse(xml.ReadContentAsString());// xml.getDoubleAttribute(key);
}
if (xml.MoveToAttribute("AMPLITUDE".ToLower()))
{
amplitude = double.Parse(xml.ReadContentAsString());
Model.checkRange(amplitude, 0.0, 1.0, "Spring amplitude");
}
if (xml.MoveToAttribute("PHASE".ToLower()))
{
phase = double.Parse(xml.ReadContentAsString());
Model.checkRange(phase, 0.0, 1.0, "Spring phase");
}
//}
//Enumeration enum = xml.enumerateAttributeNames();
//while (enum.hasMoreElements()) {
// String key = enum.nextElement().toString();
// if (key.equals("RESTLENGTH")) {
// restLength = xml.getDoubleAttribute(key);
// }
// if (key.equals("AMPLITUDE")) {
// amplitude = xml.getDoubleAttribute(key);
// Model.checkRange(amplitude, 0.0, 1.0, "Spring amplitude");
// }
// if (key.equals("PHASE")) {
// phase = xml.getDoubleAttribute(key);
// Model.checkRange(phase, 0.0, 1.0, "Spring phase");
// }
//}
}
public void ReadXml(XmlReader reader)
{
var isEmptyElement = reader.IsEmptyElement;
FoxHash hash = new FoxHash();
hash.ReadXml(reader);
reader.ReadStartElement("value");
string literal = null;
if (isEmptyElement == false)
{
literal = reader.ReadContentAsString();
reader.ReadEndElement();
}
StringLiteral = new FoxStringLiteral(literal, hash);
}
public Link(Model model, XmlReader xml) {//throws Exception {
this.model = model;
//foreach(XmlAttribute attribute in xml.Attributes)
//{
// //string key = enum.nextElement().toString();
// string key = attribute.Name;
if (xml.MoveToAttribute("A".ToLower()))
{
a = model.getNode(xml.ReadContentAsString());// xml.GetAttribute(key));
}
if (xml.MoveToAttribute("B".ToLower()))
{
b = model.getNode(xml.ReadContentAsString());//xml.GetAttribute(key));
}
//}
//Enumeration enum = xml.enumerateAttributeNames();
//while (enum.hasMoreElements()) {
//}
}
public void ReadXml(XmlReader reader)
{
bool isEmpty = reader.IsEmptyElement;
AddAttributeExtensions(reader);
reader.ReadStartElement();
if (!isEmpty)
{
CommentText = reader.ReadContentAsString();
}
reader.ReadEndElement();
}
public static ContactCardCategory Parse(XmlReader reader)
{
ContactCardCategory card = new ContactCardCategory();
while (reader.Read())
{
if (reader.Name == @"displayName")
{
while (reader.Read() && reader.NodeType != XmlNodeType.Text) ;
card.DisplayName = reader.ReadContentAsString();
}
if (reader.Name == @"email")
{
while (reader.Read() && reader.NodeType != XmlNodeType.Text) ;
card.Email = reader.ReadContentAsString();
}
if (reader.Name == @"contactCard" && reader.NodeType == XmlNodeType.EndElement)
break;
}
return card;
}
public static Firewall load(XmlReader reader)
{
while (reader.Name != "firewall")
reader.Read();
var complexity = 0;
string solution = null;
var additionalTime = 0.0f;
if (reader.MoveToAttribute("complexity"))
complexity = reader.ReadContentAsInt();
if (reader.MoveToAttribute("solution"))
solution = reader.ReadContentAsString();
if (reader.MoveToAttribute("additionalDelay"))
additionalTime = reader.ReadContentAsFloat();
return new Firewall(complexity, solution, additionalTime);
}
public void ReadXml(XmlReader reader)
{
bool isEmpty = reader.IsEmptyElement;
AddAttributeExtensions(reader);
reader.ReadStartElement();
if (!isEmpty)
{
BacklinkUri = new Uri(reader.ReadContentAsString());
}
reader.ReadEndElement();
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
var isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmpty)
{
reader.ReadStartElement("Title");
Title = reader.ReadContentAsString();
reader.ReadEndElement();
OnlineResource.ReadXml(reader);
LogoURL.ReadXml(reader);
reader.ReadEndElement();
}
}
public static AllFactions loadFromSave(XmlReader xmlRdr)
{
var allFactions = new AllFactions();
while (xmlRdr.Name != "AllFactions")
xmlRdr.Read();
if (xmlRdr.MoveToAttribute("current"))
allFactions.currentFaction = xmlRdr.ReadContentAsString();
while (!(xmlRdr.Name == "AllFactions") || xmlRdr.IsStartElement())
{
var faction = Faction.loadFromSave(xmlRdr);
allFactions.factions.Add(faction.idName, faction);
xmlRdr.Read();
}
return allFactions;
}
public bool LoadFrom(DCompilerConfiguration cmpCfg, System.Xml.XmlReader x)
{
if (x.ReadState == ReadState.Initial)
{
x.Read();
}
if (x.MoveToAttribute("Target") &&
!Enum.TryParse(x.ReadContentAsString(), true, out TargetType))
{
return(false);
}
while (x.Read())
{
switch (x.LocalName)
{
// For backward compatibility keep on parsing this
case "CompilerCommand":
cmpCfg.SourceCompilerCommand = x.ReadString();
break;
case "LinkerCommand":
Linker = x.ReadString();
break;
case "Patterns": // ditto
var s = x.ReadSubtree();
cmpCfg.ArgumentPatterns.ReadFrom(s);
s.Close();
break;
case "DebugArgs":
s = x.ReadSubtree();
DebugArguments.ReadFrom(cmpCfg, s);
s.Close();
break;
case "ReleaseArgs":
s = x.ReadSubtree();
ReleaseArguments.ReadFrom(cmpCfg, s);
s.Close();
break;
}
}
return(true);
}
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;
}
public void LoadFrom(System.Xml.XmlReader x)
{
if (x.ReadState == ReadState.Initial)
{
x.Read();
}
if (x.MoveToAttribute("Target"))
{
TargetType = (DCompileTarget)Enum.Parse(typeof(DCompileTarget), x.ReadContentAsString());
}
while (x.Read())
{
switch (x.LocalName)
{
case "CompilerCommand":
Compiler = x.ReadString();
break;
case "LinkerCommand":
Linker = x.ReadString();
break;
case "ObjectLinkPattern":
ObjectFileLinkPattern = x.ReadString();
break;
case "IncludePathPattern":
IncludePathPattern = x.ReadString();
break;
case "DebugArgs":
var s = x.ReadSubtree();
DebugArguments.ReadFrom(s);
s.Close();
break;
case "ReleaseArgs":
var s2 = x.ReadSubtree();
ReleaseArguments.ReadFrom(s2);
s2.Close();
break;
}
}
}
/// <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();
}
public void ReadXml(System.Xml.XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string key = reader.Name;
reader.ReadStartElement();
string value = reader.ReadContentAsString();
reader.ReadEndElement();
this[key] = value;
reader.MoveToContent();
}
reader.ReadEndElement();
}
public override string ReadContentAsString()
{
CheckAsync();
return(_coreReader.ReadContentAsString());
}
/// <summary>
/// Helper function to get data from the XmlReader and transform it into a MockException
/// </summary>
/// <param name="reader">The reader to read from</param>
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
string mockExceptionType = reader.Name;
if (mockExceptionType == BinaryExceptionTypeKey)
{
// Deserialize a binary serialized exception.
reader.ReadStartElement();
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(System.Convert.FromBase64String(reader.ReadContentAsString()));
this.exception = (Exception)formatter.Deserialize(stream);
reader.ReadEndElement();
}
else if (mockExceptionType == SqlExceptionTypeKey)
{
// Deserialize a SqlException.
this.exception = DeserializeSqlException(reader);
}
else
{
// Unknown mock exception type
throw new XmlException(string.Format("Unknown mock exception type '{0}' in mock query result.", mockExceptionType));
}
reader.ReadEndElement();
}
private IEnumerable <GroupByObject> ReadFacet2(System.Xml.XmlReader reader /*, IDictionary<string, string> categories*/)
{
int level = 1;
decimal yVal = 0;
int count = 0;
string category = string.Empty;
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Name == "lst")
{
++level;
}
else if ((reader.Name == "int" || reader.Name == "long" || reader.Name == "double") && level == 3)
{
string name = reader.GetAttribute("name");
reader.Read();
string value = reader.ReadContentAsString();
if (name == "count")
{
count = int.Parse(value);
}
else if (name == "sumYValues")
{
try
{
yVal = Convert.ToDecimal(double.Parse(value));
}
catch (Exception fex)
{
throw new FormatException(string.Format("Unable to parse string \"{0}\" into decimal.", value), fex);
}
}
}
else if (level == 5 && category != null)
{
string name = reader.GetAttribute("name");
reader.Read();
string value = reader.ReadContentAsString();
if (!string.IsNullOrWhiteSpace(value))
{
if (name == "val")
{
category = value;
}
else if (name == "count")
{
count = int.Parse(value);
}
else if (name == "sumYValuesArg")
{
yVal = Convert.ToDecimal(double.Parse(value));
}
}
}
}
else if (reader.NodeType == System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "lst")
{
--level;
if (level < 1)
{
break;
}
else if (level == 4)// && category != null)
{
yield return(new GroupByObject()
{
Total = yVal,
GroupByName = category,//categories.ContainsKey(category) ? categories[category] : category,
Count = count
});
yVal = 0.0m;
category = string.Empty;
count = 0;
}
}
}
}
}
/// <summary>
/// Serializes the XML to an instance.
/// </summary>
/// <param name="reader"></param>
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "name":
Description = reader.Value;
break;
case "place_id":
PlaceId = reader.Value;
break;
case "place_url":
PlaceUrl = reader.Value;
break;
case "place_type_id":
PlaceType = (PlaceType)reader.ReadContentAsInt();
break;
case "place_type":
PlaceType = (PlaceType)Enum.Parse(typeof(PlaceType), reader.Value, true);
break;
case "woeid":
WoeId = reader.Value;
break;
case "woe_name":
WoeName = reader.Value;
break;
case "latitude":
Latitude = reader.ReadContentAsDouble();
break;
case "longitude":
Longitude = reader.ReadContentAsDouble();
break;
case "timezone":
TimeZone = reader.Value;
break;
case "photo_count":
PhotoCount = reader.ReadContentAsInt();
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Text)
{
Description = reader.ReadContentAsString();
}
else
{
switch (reader.LocalName)
{
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
}
reader.Read();
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
string msg = null;
reader.Read();
string value = reader.ReadContentAsString();
if (value == null || value.Length != CommonUtilities.XmlCharacterArray.Length)
{
msg = "bad write data in WriteChars ";
if (value == null)
{
msg += " value == null";
}
else
{
msg += String.Format("original size {0} output size {1}", value.Length, CommonUtilities.XmlCharacterArray.Length);
}
throw new MyException(msg);
}
int errorCount = 0;
string firstMsg = null;
for (int i = 0; i < CommonUtilities.XmlCharacterArray.Length; i++)
{
char originalChar = CommonUtilities.XmlCharacterArray[i];
if (CommonUtilities.XmlCharacterArray[i] != value[i])
{
// special case: XML reader/writer might normalize \r or \r\n to \n (http://www.w3.org/TR/REC-xml#sec-line-ends)
if (value[i] == '\n' && CommonUtilities.XmlCharacterArray[i] == '\r')
{
// do nothing
}
else
{
errorCount++;
if (firstMsg == null)
{
firstMsg = String.Format("Error in string, location = {0}, originalCharacter code = {1}, return character code {2}",
i, (int)CommonUtilities.XmlCharacterArray[i], (int)value[i]);
}
}
}
}
if (errorCount > 0)
{
throw new MyException(firstMsg);
}
int counter = 0;
const int NODES_AT_END = 0;
while (reader.Read())
{
counter++;
}
if (counter != NODES_AT_END)
{
throw new MyException(String.Format("expected {0} nodes, but found {1}", NODES_AT_END, counter));
}
}
