internal static WindowsPhoneStoreServiceAppImageNode ParseXml(XmlReader reader)
{
var node = new WindowsPhoneStoreServiceAppImageNode();
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "id":
node.Id = reader.ReadElementContentAsUrn();
break;
case "orientation":
node.Orientation = reader.ReadElementContentAsInt();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
return node;
}
internal static LoggingConfig Load(XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
LoggingConfig result = new LoggingConfig();
reader.GoToElement();
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
while (reader.GoToSibling())
{
switch (reader.LocalName)
{
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
else
reader.Skip();
return result;
}
internal static ApplicationManifestTaskNodeBase ParseXml(XmlReader reader)
{
switch (reader.Name)
{
case "DefaultTask":
var node = new ApplicationManifestDefaultTaskNode()
{
Name = reader.GetAttribute("Name"),
NavigationPage = reader.GetAttribute("NavigationPage")
};
reader.Skip();
return node;
case "ExtendedTask":
var node2 = new ApplicationManifestExtendedTaskNode
{
Name = reader.GetAttribute("Name"),
BackgroundServiceAgents = reader.ReadElementContentAsArray(ApplicationManifestBackgroundServiceAgentNode.ParseXml)
};
return node2;
default:
reader.Skip();
return null;
}
}
/// <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 void AddXmlDocumentation(XmlReader xml)
{
while (xml.Read()) {
if (xml.NodeType == XmlNodeType.Element) {
string elname = xml.Name.ToLowerInvariant();
switch (elname) {
case "filterpriority":
case "remarks":
xml.Skip();
break;
case "example":
ret.Append(Environment.NewLine);
ret.Append("Example:");
ret.Append(Environment.NewLine);
break;
case "exception":
ret.Append(Environment.NewLine);
ret.Append(GetCref(xml["cref"]));
ret.Append(": ");
break;
case "returns":
xml.Skip();
break;
case "see":
ret.Append(GetCref(xml["cref"]));
ret.Append(xml["langword"]);
break;
case "seealso":
ret.Append(Environment.NewLine);
ret.Append("See also: ");
ret.Append(GetCref(xml["cref"]));
break;
case "paramref":
ret.Append(xml["name"]);
break;
case "param":
ret.Append(Environment.NewLine);
ret.Append(whitespace.Replace(xml["name"].Trim()," "));
ret.Append(": ");
break;
case "typeparam":
ret.Append(Environment.NewLine);
ret.Append(whitespace.Replace(xml["name"].Trim()," "));
ret.Append(": ");
break;
case "value":
ret.Append(Environment.NewLine);
ret.Append("Value: ");
ret.Append(Environment.NewLine);
break;
case "br":
case "para":
ret.Append(Environment.NewLine);
break;
}
} else if (xml.NodeType == XmlNodeType.Text) {
ret.Append(whitespace.Replace(xml.Value, " "));
}
}
}
/// <summary>
/// Parses the WDDX element and returns the deserialized
/// content as a <see cref="System.String"/> object, advancing the reader to the next
/// element.
/// </summary>
/// <param name="input">The pre-initialized <see cref="System.Xml.XmlTextReader"/> pointing to the WDDX to be parsed.</param>
public object ParseElement(XmlReader input)
{
if (input.IsEmptyElement)
{
input.Skip();
return String.Empty;
}
StringBuilder output = new StringBuilder();
input.Read();
while (!(input.Name == "string" && input.NodeType == XmlNodeType.EndElement))
{
if (input.NodeType == XmlNodeType.Text || input.NodeType == XmlNodeType.Whitespace)
{
output.Append(input.ReadString());
}
else if (input.Name == "char")
{
// parse out the <char code="xx"/> tag
output.Append((char)Int32.Parse(input.GetAttribute("code"), NumberStyles.AllowHexSpecifier));
input.Skip();
}
}
input.ReadEndElement();
return output.ToString();
}
//public static Oids.Oid Deserialize(XmlReader reader, Oids.Oid oid)
/// <summary>
/// Deserializes Oid from an XML stream.
/// </summary>
/// <param name="reader">XML stream.</param>
/// <returns>Oid.</returns>
public static Oids.Oid Deserialize(XmlReader reader)
{
Oids.Oid lResult = null;
if (reader.IsStartElement(DTD.TagOID))
{
string lClassName = reader.GetAttribute(DTD.OID.TagClass);
List<KeyValuePair<ModelType,object>> lFields = new List<KeyValuePair<ModelType,object>>();
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
do
{
#region Process tag <OID.Field>.
if (reader.IsStartElement(DTD.OID.TagOIDField))
{
if (!reader.IsEmptyElement)
{
ModelType lType = Convert.StringTypeToMODELType(reader.GetAttribute(DTD.OID.TagType));
lFields.Add(new KeyValuePair<ModelType, object>(lType, Convert.XmlToType(lType, reader.ReadString())));
}
else
{
throw new ArgumentException("Xml Reader have one OID.Field with empty Element.", "XmlReader reader");
}
}
#endregion Process tag <OID.Field>.
else
{
#region Process tag <?>
reader.Skip();
if (reader.NodeType == XmlNodeType.None)
{
break;
}
else
{
continue;
}
#endregion Process tag <?>
}
} while (reader.Read());
}
else
{
reader.Skip();
}
if(lClassName.Length > 0)
{
lResult = ServerConnection.CreateOid(lClassName,lFields);
}
}
else
{
throw new ArgumentException("Xml Reader don't have the OID in Start Element.", "XmlReader reader");
}
return lResult;
}
public static ServiceResponse Deserialize(XmlReader reader, ServiceResponse serviceResponse)
{
if (reader.IsStartElement(DTD.Response.TagServiceResponse))
{
if (serviceResponse == null)
{
serviceResponse = new ServiceResponse();
}
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
do
{
#region <ERROR>
if (reader.IsStartElement(DTD.Response.ServiceResponse.TagError))
{
if(int.Parse(reader.GetAttribute(DTD.Error.TagNumber))!=0)
{
throw XMLErrorSerializer.Deserialize(reader.ReadSubtree());
}
else
{
reader.Skip();
}
}
#endregion <ERROR>
#region <OID>
if (reader.IsStartElement(DTD.TagOID))
{
serviceResponse.Oid = XMLAdaptorOIDSerializer.Deserialize(reader.ReadSubtree());
}
#endregion <OID>
#region <Arguments>
if (reader.IsStartElement(DTD.Response.ServiceResponse.TagArguments))
{
serviceResponse.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree());
}
#endregion <Arguments>
} while (reader.Read());
}
else
{
reader.Skip();
}
}
else
{
throw new ArgumentException("Xml Reader don't have the Service.Response in Start Element.", "XmlReader reader");
}
return serviceResponse;
}
/// <summary>
/// Generates a serializable continuation token from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the continuation token is deserialized.</param>
public void ReadXml(XmlReader reader)
{
CommonUtility.AssertNotNull("reader", reader);
reader.MoveToContent();
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
while (reader.IsStartElement())
{
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
switch (reader.Name)
{
case Constants.ContinuationConstants.VersionElement:
string version = reader.ReadElementContentAsString();
if (version != Constants.ContinuationConstants.CurrentVersion)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, version));
}
break;
case Constants.ContinuationConstants.NextMarkerElement:
this.NextMarker = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.TypeElement:
string continuationType = reader.ReadElementContentAsString();
if (Constants.ContinuationConstants.QueueType != continuationType)
{
throw new XmlException(SR.UnexpectedContinuationType);
}
break;
default:
throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, reader.Name));
}
}
}
reader.ReadEndElement();
}
}
/// <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 void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
semesterStart = DateTime.Parse(reader.GetAttribute("semesterStart"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "weekday")
{
var weekday = new ScheduleWeekday();
weekday.ReadFromXml(reader);
weekdays.Add(weekday);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
num = int.Parse(reader.GetAttribute("number"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "class")
{
var sClass = new ScheduleClass();
sClass.ReadFromXml(reader);
classes.Add(sClass);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
void IFlickrParsable.Load(XmlReader reader)
{
if (reader.LocalName != "user")
UtilityMethods.CheckParsingException(reader);
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "nsid":
case "id":
UserId = reader.Value;
break;
case "username":
UserName = reader.Value;
break;
case "fullname":
FullName = reader.Value;
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
if (reader.NodeType != XmlNodeType.EndElement)
{
UserName = reader.ReadElementContentAsString();
reader.Skip();
}
}
public override void ReadXml(XmlReader reader)
{
if (CheckEmptyNode(reader, "ContactPersonPrimary", Namespace))
return;
while (!reader.EOF)
{
if (reader.IsStartElement())
{
var isEmpty = reader.IsEmptyElement;
switch (reader.LocalName)
{
case "ContactPerson":
ContactPerson = isEmpty ? string.Empty : reader.ReadElementContentAsString();
break;
case "ContactOrganization":
ContactOrganization = isEmpty ? string.Empty : reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
return;
}
else
{
reader.Read();
}
}
}
private void ReadSubItems(System.Xml.XmlReader reader, ArrayList result, bool securityTrimmingEnabled)
{
int depth = reader.Depth + 1;
while (reader.Read())
{
if (reader.Depth == depth)
{
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
var aResult = ReadResult(reader, securityTrimmingEnabled);
if (aResult != null)
{
result.Add(aResult);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
}
}
else if (reader.Depth > depth)
{
reader.Skip();
}
else if (reader.Depth < depth)
{
break;
}
}
}
void IFlickrParsable.Load(XmlReader reader)
{
if (!(reader.LocalName != "photos"))
;
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "total":
this.Total = string.IsNullOrEmpty(reader.Value) ? 0 : int.Parse(reader.Value, (IFormatProvider) CultureInfo.InvariantCulture);
continue;
case "perpage":
case "per_page":
this.PerPage = string.IsNullOrEmpty(reader.Value) ? 0 : int.Parse(reader.Value, (IFormatProvider) CultureInfo.InvariantCulture);
continue;
case "page":
this.Page = string.IsNullOrEmpty(reader.Value) ? 0 : int.Parse(reader.Value, (IFormatProvider) CultureInfo.InvariantCulture);
continue;
case "pages":
this.Pages = string.IsNullOrEmpty(reader.Value) ? 0 : int.Parse(reader.Value, (IFormatProvider) CultureInfo.InvariantCulture);
continue;
default:
continue;
}
}
reader.Read();
while (reader.LocalName == "photo")
{
Photo photo = new Photo();
photo.Load(reader);
if (!string.IsNullOrEmpty(photo.PhotoId))
this.Add(photo);
}
reader.Skip();
}
/// <summary>
/// Parses the WDDX element and returns the deserialized
/// content as a <see cref="Hashtable"/> object, advancing the reader to the next
/// element.
/// </summary>
/// <param name="input">The pre-initialized <see cref="System.Xml.XmlTextReader"/> pointing to the WDDX to be parsed.</param>
public object ParseElement(XmlReader input)
{
Hashtable thisTable = new Hashtable();
if (input.IsEmptyElement)
{
input.Skip();
return thisTable;
}
string elementName;
object elementValue;
IWddxElementDeserializer deserializer;
while (input.Read() && (!(input.Name == "struct" && input.NodeType == XmlNodeType.EndElement)))
{
if (input.Name == "var" && input.NodeType != XmlNodeType.EndElement)
{
elementName = input.GetAttribute("name");
input.Read(); // move to contents of <var>
deserializer = WddxElementDeserializerFactory.GetDeserializer(input.Name);
elementValue = deserializer.ParseElement(input);
thisTable.Add(elementName, elementValue);
}
}
input.ReadEndElement();
return thisTable;
}
/// <summary>
/// Obtains the type and value of a parameter from an XML Error file.
/// </summary>
/// <param name="reader">XML Error file.</param>
/// <param name="parameter">Parameter to obtain.</param>
/// <returns>Parameter.</returns>
public static Parameter Deserialize(XmlReader reader, Parameter parameter)
{
if (reader.IsStartElement(DTD.Error.ErrorParams.TagErrorParam))
{
if (parameter == null)
{
parameter = new Parameter();
}
// Read Attributes of Node.
parameter.Key = reader.GetAttribute(DTD.Error.ErrorParams.TagKey);
switch (reader.GetAttribute(DTD.Error.ErrorParams.TagType))
{
case ResponseException.ErrorKey:
parameter.Type = ErrorParamType.Key;
break;
case ResponseException.ErrorLiteral:
parameter.Type = ErrorParamType.Literal;
break;
}
if (!reader.IsEmptyElement)
{
parameter.Text = reader.ReadString();
}
else
{
reader.Skip();
}
}
return parameter;
}
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();
}
void IFlickrParsable.Load(XmlReader reader)
{
reader.Read();
while (reader.LocalName != "photos")
{
switch (reader.LocalName)
{
case "firstdatetaken":
this.FirstTakenDate = UtilityMethods.ParseDateWithGranularity(reader.ReadElementContentAsString());
continue;
case "firstdate":
this.FirstDate = UtilityMethods.UnixTimestampToDate(reader.ReadElementContentAsString());
continue;
case "count":
this.PhotoCount = reader.ReadElementContentAsInt();
continue;
case "views":
this.Views = reader.ReadElementContentAsInt();
continue;
default:
reader.Skip();
continue;
}
}
reader.Read();
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Format":
Format = reader.ReadElementContentAsString();
break;
case "OnlineResource":
OnlineResource = new OnlineResource();
OnlineResource.ReadXml(reader);
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
}
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Repeat = Convert.ToInt32(reader["Repeat"], CultureInfo.InvariantCulture);
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Frames":
ReadFramesXml(reader);
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
/// <summary>
/// Reads XML from the configuration file.
/// </summary>
/// <param name="xmlReader">The XmlReader object, which reads from the configuration file.</param>
protected internal override void DeserializeSection(XmlReader xmlReader)
{
if (RawXml == null)
RawXml = xmlReader.ReadOuterXml();
else
xmlReader.Skip();
}
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();
}
/// <summary>
/// Decodes an <see cref="Error"/> object from its XML representation.
/// </summary>
public static Error Decode(XmlReader reader)
{
if (reader == null) throw new ArgumentNullException("reader");
if (!reader.IsStartElement()) throw new ArgumentException("Reader is not positioned at the start of an element.", "reader");
//
// Read out the attributes that contain the simple
// typed state.
//
var error = new Error();
ReadXmlAttributes(reader, error);
//
// Move past the element. If it's not empty, then
// read also the inner XML that contains complex
// types like collections.
//
var isEmpty = reader.IsEmptyElement;
reader.Read();
if (!isEmpty)
{
ReadInnerXml(reader, error);
while (reader.NodeType != XmlNodeType.EndElement)
reader.Skip();
reader.ReadEndElement();
}
return error;
}
public override void ReadXml(XmlReader reader)
{
if (CheckEmptyNode(reader, "HTTP", Namespace))
return;
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Get":
Get = new Get();
Get.ReadXml(reader);
break;
case "Post":
_postField = new Post();
Post.ReadXml(reader);
break;
default:
reader.Skip();
break;
}
}
else
reader.Read();
}
}
protected override SecurityKeyIdentifier ReadKeyIdentifierCore(XmlReader reader)
{
var result = new SecurityKeyIdentifier();
reader.ReadStartElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
while (reader.IsStartElement())
{
if (reader.IsStartElement("X509Data", SignedXml.XmlDsigNamespaceUrl))
{
foreach (var clause in ReadX509Data(reader))
{
result.Add(clause);
}
}
else
{
if (reader.IsStartElement("KeyName", SignedXml.XmlDsigNamespaceUrl))
{
result.Add(ReadKeyNameClause(reader));
}
else
{
reader.Skip();
}
}
}
reader.ReadEndElement();
return result;
}
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();
}
internal static MarketplaceAppImageNode ParseXml(XmlReader reader)
{
var node = new MarketplaceAppImageNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "id":
node.Id = reader.ReadElementContentAsUrn();
break;
case "orientation":
node.Orientation = reader.ReadElementContentAsInt();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
void IFlickrParsable.Load(XmlReader reader)
{
if (reader.LocalName != "referrer")
UtilityMethods.CheckParsingException(reader);
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "url":
Url = reader.Value;
break;
case "searchterm":
SearchTerm = reader.Value;
break;
case "views":
Views = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo);
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Skip();
}
ICustomXmlSerializer ICustomXmlSerializer.ReadFrom(System.Xml.XmlReader reader)
{
storedVars = new List <string> ();
reader.MoveToContent();
if (reader.IsEmptyElement)
{
reader.Read();
return(null);
}
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Element)
{
storedVars.Add(reader.ReadElementString());
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
return(null);
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Transform":
XmlTransformElement transform = new XmlTransformElement();
transform.ReadXml(reader);
Transform = transform;
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
DefaultAnimation = reader["DefaultAnimation"];
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Activity":
XmlActivityElement activity = new XmlActivityElement();
activity.ReadXml(reader);
Activities.Add(activity);
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
protected virtual void ReadXml(XmlReader reader, SyndicationFeed result)
{
if (result == null)
throw new ArgumentNullException("result");
else if (reader == null)
throw new ArgumentNullException("reader");
reader.ReadStartElement(); // Read in <RDF>
reader.ReadStartElement("channel"); // Read in <channel>
while (reader.IsStartElement()) // Process <channel> children
{
if (reader.IsStartElement("title"))
result.Title = new TextSyndicationContent(reader.ReadElementString());
else if (reader.IsStartElement("link"))
result.Links.Add(new SyndicationLink(new Uri(reader.ReadElementString())));
else if (reader.IsStartElement("description"))
result.Description = new TextSyndicationContent(reader.ReadElementString());
else
reader.Skip();
}
reader.ReadEndElement(); // Read in </channel>
while (reader.IsStartElement())
{
if (reader.IsStartElement("item"))
{
result.Items = this.ReadItems(reader, result);
break;
}
else
reader.Skip();
}
}
void IFlickrParsable.Load(XmlReader reader)
{
if (reader.LocalName != "set")
UtilityMethods.CheckParsingException(reader);
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "id":
SetId = reader.Value;
break;
case "title":
Title = reader.Value;
break;
case "description":
Description = reader.Value;
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Skip();
}
public void ReadXmlContent(System.Xml.XmlReader reader, Func <Type, WSTableSource> getTSource)
{
base.ReadXmlContent(reader);
bool done = false;
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case "params":
{
if (reader.ReadToDescendant("param"))
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
string pName = reader.GetAttribute("name");
WSParam param = GetXParam(pName, null, getTSource);
if (param == null)
{
reader.Skip();
continue;
}
else
{
if (param is WSTableParam)
{
((WSTableParam)param).ReadXml(reader);
}
else
{
param.ReadXml(reader);
}
}
reader.MoveToContent();
if (!reader.Read())
{
break;
}
}
}
break;
}
default:
{
done = true;
break;
}
}
reader.MoveToContent();
if (done || !reader.Read())
{
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();
}
void ITwentyThreeParsable.Load(System.Xml.XmlReader reader)
{
reader.ReadToDescendant("tag");
while (reader.LocalName == "tag")
{
var member = new RawTag();
((ITwentyThreeParsable)member).Load(reader);
Add(member);
}
reader.Skip();
}
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;
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
reader.ReadToDescendant("tag");
while (reader.LocalName == "tag")
{
RawTag member = new RawTag();
((IFlickrParsable)member).Load(reader);
Add(member);
}
reader.Skip();
}
private void LoadElements(System.Xml.XmlReader reader)
{
if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "photo")
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "neighbourhood":
Neighbourhood = new Place();
((IFlickrParsable)Neighbourhood).Load(reader);
break;
case "locality":
Locality = new Place();
((IFlickrParsable)Locality).Load(reader);
break;
case "county":
County = new Place();
((IFlickrParsable)County).Load(reader);
break;
case "region":
Region = new Place();
((IFlickrParsable)Region).Load(reader);
break;
case "country":
Country = new Place();
((IFlickrParsable)Country).Load(reader);
break;
case "shapedata":
ShapeData = new ShapeData();
((IFlickrParsable)ShapeData).Load(reader);
break;
default:
UtilityMethods.CheckParsingException(reader);
reader.Skip();
break;
}
}
reader.Read();
}
/// <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>
/// Reads the error data in child nodes.
/// </summary>
private static void ReadInnerXml(XmlReader reader, Error error)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
//
// Loop through the elements, reading those that we
// recognize. If an unknown element is found then
// this method bails out immediately without
// consuming it, assuming that it belongs to a subclass.
//
while (reader.IsStartElement())
{
//
// Optimization Note: This block could be re-wired slightly
// to be more efficient by not causing a collection to be
// created if the element is going to be empty.
//
NameValueCollection collection;
switch (reader.Name)
{
case "serverVariables": collection = error.ServerVariables; break;
case "queryString": collection = error.QueryString; break;
case "form": collection = error.Form; break;
case "cookies": collection = error.Cookies; break;
default: reader.Skip(); continue;
}
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
UpcodeTo(reader, collection);
}
}
}
/// <summary>
/// Decodes an <see cref="Error"/> object from its XML representation.
/// </summary>
public static Error Decode(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
//
// Reader must be positioned on an element!
//
if (!reader.IsStartElement())
{
throw new ArgumentException("Reader is not positioned at the start of an element.", "reader");
}
//
// Read out the attributes that contain the simple
// typed state.
//
Error error = new Error();
ReadXmlAttributes(reader, error);
//
// Move past the element. If it's not empty, then
// read also the inner XML that contains complex
// types like collections.
//
bool isEmpty = reader.IsEmptyElement;
reader.Read();
if (!isEmpty)
{
ReadInnerXml(reader, error);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
return(error);
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
if (reader.LocalName != "contacts")
{
UtilityMethods.CheckParsingException(reader);
}
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "page":
Page = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "total":
Total = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "pages":
Pages = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "per_page":
case "perpage":
PerPage = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.LocalName == "contact")
{
Contact contact = new Contact();
((IFlickrParsable)contact).Load(reader);
Add(contact);
}
reader.Skip();
}
/// <summary>
/// Lê os filhos do nó.
/// </summary>
/// <param name="reader"></param>
private void ReadChildrenXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "Node")
{
var node = new ServiceAddressNode();
((System.Xml.Serialization.IXmlSerializable)node).ReadXml(reader);
this.Add(node);
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
if (reader.LocalName != "services")
{
UtilityMethods.CheckParsingException(reader);
}
reader.Read();
while (reader.LocalName == "service")
{
var service = new BlogService();
((IFlickrParsable)service).Load(reader);
Add(service);
}
reader.Skip();
}
void ITwentyThreeParsable.Load(System.Xml.XmlReader reader)
{
if (reader.LocalName != "domains")
{
UtilityMethods.CheckParsingException(reader);
}
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "page":
Page = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "total":
Total = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "pages":
Pages = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
case "perpage":
PerPage = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.LocalName == "domain")
{
var domain = new StatDomain();
((ITwentyThreeParsable)domain).Load(reader);
Add(domain);
}
reader.Skip();
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
if (reader.LocalName != "people")
{
UtilityMethods.CheckParsingException(reader);
}
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "total":
Total = reader.ReadContentAsInt();
break;
case "photo_width":
PhotoWidth = reader.ReadContentAsInt();
break;
case "photo_height":
PhotoHeight = reader.ReadContentAsInt();
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.LocalName == "person")
{
var item = new PhotoPerson();
((IFlickrParsable)item).Load(reader);
Add(item);
}
reader.Skip();
}
public override void Skip()
{
CheckAsync();
_coreReader.Skip();
}
/// <summary>
/// Reads Node from the currnt element in the _xmlReader.
/// </summary>
/// <returns>Information about parsed node.</returns>
private NodeInfo ReadNode()
{
// id
string attId = _xmlReader.GetAttribute("id");
if (attId == null)
{
throw new Sys.XmlException("Attribute 'id' is missing.");
}
var nodeId = long.Parse(attId, System.Globalization.CultureInfo.InvariantCulture);
// latitude
string attLat = _xmlReader.GetAttribute("lat");
if (attLat == null)
{
throw new Sys.XmlException("Attribute 'lat' is missing.");
}
double nodeLat = double.Parse(attLat, System.Globalization.CultureInfo.InvariantCulture);
// longitude
string attLon = _xmlReader.GetAttribute("lon");
if (attLon == null)
{
throw new Sys.XmlException("Attribute 'lon'is missing.");
}
double nodeLon = double.Parse(attLon, System.Globalization.CultureInfo.InvariantCulture);
EntityMetadata additionalInfo = null;
if (this.Settings.ReadMetadata)
{
additionalInfo = this.ReadMetadata();
}
NodeInfo result = new NodeInfo(nodeId, nodeLat, nodeLon, new TagsCollection(), additionalInfo);
if (_xmlReader.IsEmptyElement == false)
{
_xmlReader.Read();
while (_xmlReader.NodeType != Sys.XmlNodeType.EndElement)
{
if (_xmlReader.NodeType == Sys.XmlNodeType.Element && _xmlReader.Name == "tag")
{
result.Tags.Add(this.ReadTag());
}
else
{
_xmlReader.Skip();
}
}
}
_xmlReader.Skip();
return(result);
}
public override void Skip()
{
reader.Skip();
}
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);
}
public new void ReadXmlContent(System.Xml.XmlReader reader)
{
base.ReadXmlContent(reader);
bool done = false;
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case "readAccessMode":
READ_ACCESS_MODE.ReadXml(reader);
break;
case "writeAccessMode":
WRITE_ACCESS_MODE.ReadXml(reader);
break;
case "allowedValues":
if (reader.ReadToDescendant("allowedValue"))
{
List <WSValue> values = new List <WSValue>();
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (!reader.IsEmptyElement)
{
string aName = reader.GetAttribute("name");
if (string.IsNullOrEmpty(aName))
{
reader.Skip();
}
else
{
WSValue value = new WSValue(aName);
value.ReadXml(reader);
values.Add(value);
}
}
reader.MoveToContent();
if (!reader.Read())
{
break;
}
}
ALLOWED_VALUES = values;
}
break;
default:
{
reader.Skip();
done = true;
break;
}
}
reader.MoveToContent();
if (done || !reader.Read())
{
break;
}
}
}
/// <summary>
/// Updates an existing <see cref="NameValueCollection" /> object from
/// its XML representation.
/// </summary>
private static void UpcodeTo(XmlReader reader, NameValueCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Debug.Assert(!reader.IsEmptyElement);
reader.Read();
//
// Add entries into the collection as <item> elements
// with child <value> elements are found.
//
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("item"))
{
string name = reader.GetAttribute("name");
bool isNull = reader.IsEmptyElement;
reader.Read(); // <item>
if (!isNull)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("value")) // <value ...>
{
string value = reader.GetAttribute("string");
collection.Add(name, value);
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement(); // </item>
}
else
{
collection.Add(name, null);
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
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;
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
try
{
string objectType = reader.GetAttribute("type");
if (objectType != null && objectType.Trim().Length > 0)
{
if (objectType == "MixedCollection")
{
int index = 0;
reader.Read();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.IsStartElement("Item"))
{
objectType = reader.GetAttribute("type");
Type type = ChoType.GetType(objectType);
if (type == null)
{
throw new ApplicationException(String.Format("Can't find {0} class.", objectType));
}
reader.ReadStartElement("Item");
try
{
index++;
XmlSerializer xmlSerializer = new XmlSerializer(type);
Add(xmlSerializer.Deserialize(reader));
}
catch (Exception ex)
{
throw new XmlException(String.Format("Failed to deserialize {0} array item.", index), ex);
}
reader.ReadEndElement();
}
}
reader.ReadEndElement();
}
else
{
Type type = ChoType.GetType(objectType);
if (type == null)
{
throw new ApplicationException(String.Format("Can't find {0} class.", objectType));
}
reader.Read();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
//if (reader.IsStartElement(type.Name))
//{
XmlSerializer xmlSerializer = new XmlSerializer(ChoType.GetType(objectType));
Add(xmlSerializer.Deserialize(reader));
//}
}
reader.ReadEndElement();
}
}
else
{
reader.Skip();
}
}
catch (Exception)
{
//ChoStreamProfile.WriteLine(ChoReservedFileName.SerializationIssues.ToString(), ChoApplicationException.ToString(ex));
throw;
}
}
