| public ReadElementContentAsString ( ) : string | ||
| return | string | |
public ExamQuestion(XmlReader reader)
: this()
{
QuestionIdentifier = reader.GetAttribute("identifier");
Question = reader.GetAttribute("question");
Image = reader.GetAttribute("image");
while (!reader.EOF)
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name == "Answer")
Answer = reader.ReadElementContentAsString();
else if (reader.Name == "Distractor")
Distractors.Add(reader.ReadElementContentAsString());
else
reader.Read();
break;
case XmlNodeType.EndElement:
return;
default:
reader.Read();
break;
}
}
}
public bool FromXml(XmlReader reader)
{
if (reader == null || reader.Name != "Udc")
{
return false;
}
if (reader.Name == "Order" || reader.ReadToDescendant("Order"))
{
Order = reader.ReadElementContentAsInt();
}
if (reader.Name == "Id" || reader.ReadToNextSibling("Id"))
{
Id = reader.ReadElementContentAsString();
}
if (reader.Name == "Name" || reader.ReadToNextSibling("Name"))
{
Name = reader.ReadElementContentAsString();
}
if (reader.Name == "Tips" || reader.ReadToNextSibling("Tips"))
{
Tips = reader.ReadElementContentAsString();
}
if (reader.Name == "Data" || reader.ReadToNextSibling("Data"))
{
Data = reader.ReadElementContentAsString();
}
if (reader.Name == "Memo" || reader.ReadToNextSibling("Memo"))
{
Data = reader.ReadElementContentAsString();
}
return true;
}
public void ReadXml(System.Xml.XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
else if (reader.NodeType == XmlNodeType.Whitespace)
{
continue;
}
else if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name.ToLowerInvariant())
{
case "roles":
if (!reader.IsEmptyElement)
{
ReadRoles(reader);
}
break;
case "rolegroupname":
RoleGroupName = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
}
}
}
}
public void ReadXml(XmlReader reader)
{
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case ModeElementName:
TranslitModeEnum mode;
string elementContent = reader.ReadElementContentAsString();
if (!Enum.TryParse(elementContent, true, out mode))
{
throw new InvalidDataException(string.Format("Invalit ignore Title value read: {0}",elementContent));
}
Mode = mode;
continue;
case FileNameElementName:
FileName = reader.ReadElementContentAsString();
continue;
}
}
reader.Read();
}
}
internal static MarketplaceAppCapabilityNode ParseXml(XmlReader reader)
{
var node = new MarketplaceAppCapabilityNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "id":
node.Id = reader.ReadElementContentAsString();
break;
case "string":
node.Title = reader.ReadElementContentAsString();
break;
case "disclosure":
node.Disclosure = reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
/// <summary>
/// Reads an Xml Subtree and looks for a Node with the name "Location" and "Mood"
/// If both nodes are found then a Beat object is created and added to the m_BeatsList
/// </summary>
/// <param name="Subtree">The XML subtree to Read</param>
private void CreateBeatFromXmlSubtree(XmlReader Subtree)
{
string Location = "";
string MoodString = "";
while (Subtree.Read())
{
if (Subtree.NodeType == XmlNodeType.Element)
{
switch(Subtree.Name)
{
case "Location":
Location = Subtree.ReadElementContentAsString();
break;
case "Mood":
MoodString = Subtree.ReadElementContentAsString();
break;
}
}
}
//Ensure both values have been set
if (Location != "" && MoodString != "")
{
m_BeatsList.Add(new Beat(Location, ParseMood(MoodString)));
}
}
internal static WindowsStoreServiceAppScreenshotNode ParseXml(XmlReader reader)
{
var node = new WindowsStoreServiceAppScreenshotNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "U":
node.Url = reader.ReadElementContentAsString();
break;
case "Cap":
node.Caption = reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
private static string _getHeadersFromEntry(XmlReader oEntry)
{
StringBuilder builder = new StringBuilder();
while (oEntry.Read())
{
string str;
if ((oEntry.NodeType == XmlNodeType.Element) && ((str = oEntry.Name) != null))
{
if (!(str == "name"))
{
if (str == "value")
{
goto Label_0052;
}
}
else
{
builder.Append(oEntry.ReadElementContentAsString());
builder.Append(": ");
}
}
continue;
Label_0052:
builder.Append(oEntry.ReadElementContentAsString());
builder.Append("\r\n");
}
return builder.ToString();
}
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();
}
}
}
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();
}
/// <summary>
/// Parse the results of the Bing search
/// </summary>
/// <param name="reader">The xml reader containing the search results</param>
public Collection<Article> ParseItems(XmlReader reader, Feed ownerFeed)
{
Collection<Article> results = new Collection<Article>();
reader.ReadToFollowing("item");
do
{
if (reader.ReadToFollowing("title"))
{
string name = reader.ReadElementContentAsString();
if (reader.ReadToFollowing("link"))
{
string uri = reader.ReadElementContentAsString();
// Assign feed information to Article object.
Article newResult = new Article
{
ArticleTitle = name,
ArticleBaseURI = uri
};
// Safely add the search result to the collection.
lock (_lockObject)
{
results.Add(newResult);
}
}
}
} while (reader.ReadToFollowing("item"));
return results;
}
public new void ReadXml(System.Xml.XmlReader reader)
{
if (null == reader)
{
throw new ArgumentNullException("reader");
}
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "Finger":
_finger = reader.ReadElementContentAsString();
break;
case "Name":
_name = reader.ReadElementContentAsString();
break;
case "ServiceObject":
_ServiceObject = reader.ReadElementContentAsString();
break;
case "BaseClassData":
base.ReadXml(reader);
break;
default:
throw new Exception("Unexpected element in xml");
}
}
reader.ReadEndElement();
}
public bool FromXml(XmlReader reader)
{
if (reader == null || reader.Name != "Ren" || !reader.IsStartElement())
{
return false;
}
if (reader.Name == "Order" || reader.ReadToDescendant("Order"))
{
Order = reader.ReadElementContentAsInt();
}
if (reader.Name == "Id" || reader.ReadToNextSibling("Id"))
{
Id = reader.ReadElementContentAsString();
}
if (reader.Name == "Name" || reader.ReadToNextSibling("Name"))
{
Name = reader.ReadElementContentAsString();
}
if (reader.Name == "Command" || reader.ReadToNextSibling("Command"))
{
Command = reader.ReadElementContentAsString();
}
if (reader.Name == "Remark" || reader.ReadToNextSibling("Remark"))
{
Remark = reader.ReadElementContentAsString();
}
if (reader.Name == "Ren" && reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
return true;
}
protected virtual void ReadXml(XmlReader reader, SyndicationFeed result)
{
if (result == null)
throw new ArgumentNullException("result");
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.ReadElementContentAsString());
else if (reader.IsStartElement("link"))
result.Links.Add(new SyndicationLink(new Uri(reader.ReadElementContentAsString())));
else if (reader.IsStartElement("description"))
result.Description = new TextSyndicationContent(reader.ReadElementContentAsString());
else
reader.Skip();
}
reader.ReadEndElement(); // Read in </channel>
while (reader.IsStartElement())
{
if (reader.IsStartElement("item"))
{
result.Items = ReadItems(reader, result);
break;
}
reader.Skip();
}
}
private void readItems(XmlReader reader) {
reader.ReadToFollowing ("ItemDatabase");
bool continueReading = reader.ReadToDescendant ("Item");
while (continueReading) {
//Read all information from the .xml-file
reader.ReadToDescendant ("Id");
int id = reader.ReadElementContentAsInt ();
reader.ReadToNextSibling ("Name");
string name = reader.ReadElementContentAsString ();
reader.ReadToNextSibling ("Description");
string desc = reader.ReadElementContentAsString ();
reader.ReadToNextSibling ("Value");
int value = reader.ReadElementContentAsInt ();
reader.ReadToNextSibling ("Type");
string type = reader.ReadElementContentAsString ();
ItemType t = type.StringToType ();
//And add the item to the database
Item i = new Item (name, desc, value, t, id);
//check for attributes and add them to the item
checkForAttributes(reader, i);
//Add the item to the databse and read end element
items.Add(i);
reader.ReadEndElement ();
//Check if there is another item to read
continueReading = reader.ReadToNextSibling ("Item");
}
}
public Searchers(XmlReader reader)
{
this.Choices = new List<Choice>();
this.CurrentSearch = "";
reader.Read();
if (reader.Name != "TheSearchers")
return; // bail out
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "TheSearchers") && !reader.IsStartElement())
break; // all done
if (reader.Name == "Current")
this.CurrentSearch = reader.ReadElementContentAsString();
else if (reader.Name == "Choice")
{
string url = reader.GetAttribute("URL");
if (url == null)
url = reader.GetAttribute("URL2");
else
{
// old-style URL, replace "!" with "{ShowName}+{Season}+{Episode}"
url = url.Replace("!", "{ShowName}+{Season}+{Episode}");
}
this.Add(reader.GetAttribute("Name"), url);
reader.ReadElementContentAsString();
}
else
reader.ReadOuterXml();
}
}
internal static void Read(XmlReader reader, Item item)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (item == null)
throw new ArgumentNullException("item");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(ItemSerializer.Item);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, ItemSerializer.Item))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case ItemSerializer.Id:
item.Id = reader.ReadElementContentAsString();
break;
case ItemSerializer.Description:
item.Description = reader.ReadElementContentAsString();
break;
case ItemSerializer.Quantity:
item.Quantity = reader.ReadElementContentAsInt();
break;
case ItemSerializer.Amount:
item.Amount = reader.ReadElementContentAsDecimal();
break;
case ItemSerializer.Weight:
item.Weight = reader.ReadElementContentAsLong();
break;
case ItemSerializer.ShippingCost:
item.ShippingCost = reader.ReadElementContentAsDecimal();
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
//Attempt to read batch.xml to load previous settings
//If anything goes wrong, just start without any preloaded settings
public void ReadXml(XmlReader reader)
{
try
{
FileDescs = new Dictionary<string, FbxFileDesc>();
reader.ReadToFollowing("BatchConversion");
reader.ReadToDescendant("Output");
OutputDir = reader.ReadElementContentAsString();
while (reader.LocalName == "FbxFile")
{
var newFile = new FbxFileDesc();
reader.ReadToDescendant("Filename");
var newFilename = reader.ReadElementContentAsString();
if (reader.LocalName != "CollisionGeneration")
reader.ReadToNextSibling("CollisionGeneration");
newFile.CollisionType = reader.ReadElementContentAsString();
while (reader.LocalName == "AnimClip")
{
var newClip = new AnimationClipDesc();
reader.ReadToDescendant("Name");
var newClipName = reader.ReadElementContentAsString();
if (reader.LocalName != "Keyframes")
reader.ReadToNextSibling("Keyframes");
newClip.BeginFrame = double.Parse(reader.GetAttribute("Begin"));
newClip.EndFrame = double.Parse(reader.GetAttribute("End"));
newClip.Fps = double.Parse(reader.GetAttribute("FPS"));
reader.Read();
reader.ReadEndElement();
newFile.AnimationClips.Add(newClipName, newClip);
}
reader.ReadEndElement();
FileDescs.Add(newFilename, newFile);
}
}
catch (Exception)
{
MessageBox.Show(ParentWindow, "Unable to read batch.xml, starting with a clean slate...",
"Error", MessageBoxButton.OK,
MessageBoxImage.Error);
FileDescs = new Dictionary<string, FbxFileDesc>();
OutputDir = "";
}
}
/// <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>
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
CommonUtils.AssertNotNull("reader", reader);
reader.MoveToContent();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
bool more = true;
while (more)
{
if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
{
switch (reader.Name)
{
case VersionElement:
string version = reader.ReadElementContentAsString();
Console.WriteLine(version);
// For future versioning
break;
case NextMarkerElement:
this.NextMarker = reader.ReadElementContentAsString();
break;
case NextPartitionKeyElement:
this.NextPartitionKey = reader.ReadElementContentAsString();
break;
case NextRowKeyElement:
this.NextRowKey = reader.ReadElementContentAsString();
break;
case NextTableNameElement:
this.NextTableName = reader.ReadElementContentAsString();
break;
case TypeElement:
this.Type = (ContinuationType)Enum.Parse(typeof(ContinuationType), reader.ReadElementContentAsString());
break;
}
}
else
{
more = reader.Read();
}
}
}
}
void IFlickrParsable.Load(XmlReader reader)
{
this.Load(reader, false);
if (reader.LocalName == "comment")
this.Comment = reader.ReadElementContentAsString();
if (reader.LocalName == "description")
this.Description = reader.ReadElementContentAsString();
if (reader.NodeType != XmlNodeType.EndElement || !(reader.LocalName == "photo"))
return;
reader.Skip();
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "nsid":
this.InstitutionId = reader.Value;
continue;
case "date_launch":
this.DateLaunched = UtilityMethods.UnixTimestampToDate(reader.Value);
continue;
default:
continue;
}
}
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "name":
this.InstitutionName = reader.ReadElementContentAsString();
continue;
case "urls":
reader.Read();
while (reader.LocalName == "url")
{
string attribute = reader.GetAttribute("type");
string str = reader.ReadElementContentAsString();
switch (attribute)
{
case "site":
this.SiteUrl = str;
continue;
case "flickr":
this.FlickrUrl = str;
continue;
case "license":
this.LicenseUrl = str;
continue;
default:
continue;
}
}
reader.Read();
continue;
default:
continue;
}
}
reader.Read();
}
private string ReadXmlDimension(XmlReader r)
{
r.ReadStartElement("tr");
string returnValue="";
string dimension = r.ReadElementContentAsString();
if (dimension!="Coordinates")
{
returnValue= r.ReadElementContentAsString();
}
r.ReadEndElement();
return returnValue;
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="item"></param>
internal static void Read(XmlReader reader, Item item)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(ItemSerializer.Item);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, ItemSerializer.Item))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case ItemSerializer.Id:
item.Id = reader.ReadElementContentAsString();
break;
case ItemSerializer.Description:
item.Description = reader.ReadElementContentAsString();
break;
case ItemSerializer.Quantity:
item.Quantity = reader.ReadElementContentAsInt();
break;
case ItemSerializer.Amount:
item.Amount = reader.ReadElementContentAsDecimal();
break;
case ItemSerializer.Weight:
item.Weight = reader.ReadElementContentAsLong();
break;
case ItemSerializer.ShippingCost:
item.ShippingCost = reader.ReadElementContentAsDecimal();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public bool FromXml(XmlReader reader)
{
Algorithm = reader.ReadElementContentAsString();
BlockSize = reader.ReadElementContentAsInt();
string salt = reader.ReadElementContentAsString();
//_Salt = null;
string mask = reader.ReadElementContentAsString();
//_Mask = null;
return true;
}
private static RetailCustomer ReadRetail(XmlReader xmlIn)
{
RetailCustomer customer = new RetailCustomer();
customer.FirstName =
xmlIn.ReadElementContentAsString();
customer.LastName =
xmlIn.ReadElementContentAsString();
customer.Email =
xmlIn.ReadElementContentAsString();
customer.HomePhone =
xmlIn.ReadElementContentAsString();
return customer;
}
void IFlickrParsable.Load(XmlReader reader)
{
Load(reader, false);
if (reader.LocalName == "comment")
Comment = reader.ReadElementContentAsString();
if (reader.LocalName == "description")
Description = reader.ReadElementContentAsString();
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "photo")
reader.Skip();
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result">PagSeguro AuthorizationSummary</param>
internal static void Read(XmlReader reader, AuthorizationSummary result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Authorization);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Authorization))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
result.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.CreationDate:
result.CreationDate = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Reference:
result.Reference = reader.ReadElementContentAsString();
break;
case SerializerHelper.Account:
AuthorizationAccountSerializer.Read(reader, result);
break;
case SerializerHelper.Permissions:
AuthorizationPermissionListSerializer.Read(reader, result.Permissions);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public static Dictionary<string, string> Databases(XmlReader rdr)
{
var dbs = new Dictionary<string, string>();
if (rdr.NameTable == null) return dbs;
var eDatabases = rdr.NameTable.Add("Databases");
var eDatabase = rdr.NameTable.Add("Database");
var eName = rdr.NameTable.Add("Name");
var eID = rdr.NameTable.Add("ID");
string name;
string id;
while (rdr.Read())
{
if (rdr.NodeType == XmlNodeType.Element
&& rdr.LocalName == eDatabases)
{
while (rdr.Read())
{
if (rdr.NodeType == XmlNodeType.Element
&& rdr.LocalName == eDatabase)
{
name = "";
id = "";
while (rdr.Read())
{
if (rdr.NodeType == XmlNodeType.Element
&& rdr.LocalName == eName)
{
name = rdr.ReadElementContentAsString();
}
if (rdr.NodeType == XmlNodeType.Element
&& rdr.LocalName == eID)
{
id = rdr.ReadElementContentAsString();
}
if (rdr.NodeType == XmlNodeType.EndElement
&& rdr.LocalName == eDatabase) break;
}
dbs.Add(name, id);
}
if (rdr.NodeType == XmlNodeType.EndElement
&& rdr.LocalName == eDatabases) break;
}
if (rdr.NodeType == XmlNodeType.EndElement
&& rdr.LocalName == eDatabases) break;
}
}
return dbs;
}
/// <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(System.Xml.XmlReader reader)
{
CommonUtils.AssertNotNull("reader", reader);
reader.MoveToContent();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
while (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
{
if (!reader.IsEmptyElement)
{
switch (reader.Name)
{
case Constants.ContinuationConstants.VersionElement:
string version = reader.ReadElementContentAsString();
// For future versioning
break;
case Constants.ContinuationConstants.NextMarkerElement:
this.NextMarker = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.TypeElement:
string continuationType = reader.ReadElementContentAsString();
if ("Queue" != continuationType)
{
throw new System.Xml.XmlException(SR.UnexpectedContinuationType);
}
break;
default:
throw new XmlException(string.Format(SR.UnexpectedElement, reader.Name));
}
}
else
{
throw new XmlException(string.Format(SR.UnexpectedEmptyElement, reader.Name));
}
}
reader.ReadEndElement();
}
}
internal static void Read(XmlReader reader, Sender sender)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (sender == null)
throw new ArgumentNullException("sender");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(SenderSerializer.Sender);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, SenderSerializer.Sender))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SenderSerializer.Name:
sender.Name = reader.ReadElementContentAsString();
break;
case SenderSerializer.Email:
sender.Email = reader.ReadElementContentAsString();
break;
case PhoneSerializer.Phone:
Phone phone = new Phone();
PhoneSerializer.Read(reader, phone);
sender.Phone = phone;
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
/// <summary>
/// Parses a single error element from the reader
/// </summary>
/// <param name="reader">The reader to read from.</param>
/// <returns>The exception parsed.</returns>
private static Exception ParseInStreamSingleError(XmlReader reader)
{
string type = null;
string stackTrace = null;
string message = null;
Exception innerException = null;
reader.Read();
reader.Read();
while (!reader.EOF)
{
if (reader.NodeType != XmlNodeType.Element ||
reader.NamespaceURI != UnitTestsUtil.MetadataNamespace.NamespaceName)
{
reader.Read();
continue;
}
switch (reader.LocalName)
{
case "message":
message = reader.ReadElementContentAsString(); break;
case "type":
type = reader.ReadElementContentAsString(); break;
case "stacktrace":
stackTrace = reader.ReadElementContentAsString(); break;
case "innererror":
innerException = ParseInStreamSingleError(reader.ReadSubtree());
break;
default:
reader.Skip();
break;
}
}
Exception exception;
switch (type)
{
case "System.InvalidOperationException":
exception = new InvalidOperationException(message, innerException);
break;
default:
exception = new DataServiceException(message, innerException);
break;
}
exception.Data["StackTrace"] = stackTrace;
return exception;
}
internal static PagSeguroServiceError Read(XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
string code = String.Empty;
String message = String.Empty;
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return new PagSeguroServiceError(code, message);
}
reader.ReadStartElement(PagSeguroErrorSerializer.Error);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, PagSeguroErrorSerializer.Error))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PagSeguroErrorSerializer.Code:
code = reader.ReadElementContentAsString();
break;
case PagSeguroErrorSerializer.Message:
message = reader.ReadElementContentAsString();
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
PagSeguroServiceError error = new PagSeguroServiceError(code, message);
return error;
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if( reader.IsEmptyElement ) { reader.Read(); return; }
reader.Read();
while( ! reader.EOF )
{
if( reader.IsStartElement() )
{
switch( reader.Name )
{
case "path":
path = reader.ReadElementContentAsString();
break;
case "name":
name = reader.ReadElementContentAsString();
break;
case "value":
valueRaw = reader.ReadElementContentAsString();
break;
case "type":
string valueTxt = reader.ReadElementContentAsString();
type = RegistryValueKind.Unknown;
switch (valueTxt)
{
case "REG_DWORD":
type = RegistryValueKind.DWord;
break;
case "REG_BINARY":
type = RegistryValueKind.Binary;
break;
case "REG_SZ":
type = RegistryValueKind.String;
break;
}
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
break;
}
}
}
internal Identity(XmlReader reader)
{
if (reader.IsEmptyElement)
throw new Exception("Expected a non-empty <Owner> element.");
// Example:
// <Owner>
// <ID>bcaf1ffd86f41caff1a493dc2ad8c2c281e37522a640e161ca5fb16fd081034f</ID>
// <DisplayName>webfile</DisplayName>
// </Owner>
reader.ReadStartElement("Owner");
this.ID = reader.ReadElementContentAsString("ID", "");
this.DisplayName = reader.ReadElementContentAsString("DisplayName", "");
reader.ReadEndElement();
}
/// <summary>
/// Custom helper to deserialize a SqlException object from Xml.
/// </summary>
private static SqlException DeserializeSqlException(System.Xml.XmlReader reader)
{
// SqlException constructor takes in two parameters, an errorCollection and a serverVersion.
SqlErrorCollection errorCollection = (SqlErrorCollection)typeof(SqlErrorCollection).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, System.Type.EmptyTypes, null).Invoke(null);;
string serverVersion = null;
// Read the subtree and fill in the parameters.
int startDepth = reader.Depth;
reader.ReadStartElement();
while (reader.Depth > startDepth)
{
switch (reader.Name)
{
case "serverVersion":
serverVersion = reader.ReadElementContentAsString();
break;
case "SqlError":
SqlError newSqlError = DeserializeSqlError(reader);
errorCollection.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(errorCollection, new object[] { newSqlError });
break;
}
}
reader.ReadEndElement();
// Use reflection to create the SqlException.
Type sqlExceptionType = typeof(SqlException);
Type[] types = { typeof(SqlErrorCollection), typeof(String) };
MethodInfo info = sqlExceptionType.GetMethod("CreateException", BindingFlags.Static | BindingFlags.NonPublic, null, types, null);
return((SqlException)info.Invoke(null, new object[] { errorCollection, serverVersion }));
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public void ReadXml(System.Xml.XmlReader reader)
{
reader.Read();
_name = reader.ReadElementContentAsString();
Assembly assembly = Assembly.GetAssembly(typeof(IOperation));
try
{
string operation = reader.Name;
Type type = assembly.GetType(assembly.GetName().Name + "." + operation);
// Operationen holen
XmlSerializer xmlSerializer = new XmlSerializer(type);
_operation = xmlSerializer.Deserialize(reader) as IOperation;
reader.Read();
// Informationen
FillVariableInformation();
// Beispiel für Erzeugung einer Instanz über Reflektion
//object ob = Activator.CreateInstance(assemblyName, typeof(Or).FullName);
//object ob = Activator.CreateInstance(type);
}
catch (Exception ex)
{
Logger.LogCritical("ReadXML throws an exception: ", ex);
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public virtual void ReadXml(System.Xml.XmlReader reader)
{
reader.Read();
Assembly assembly = Assembly.GetExecutingAssembly();
while (reader.NodeType != XmlNodeType.EndElement)
{
string operation = reader.Name;
Type type = assembly.GetType(assembly.GetName().Name + "." + operation);
// Ausnahme beim VariablenOperator
if (type == typeof(VariablesOperator))
{
VariablesOperator op;
reader.Read();
string varName = reader.ReadElementContentAsString();
reader.Read();
if (!VariablesOperator.VarOperatorList.TryGetValue(varName, out op))
{
op = new VariablesOperator(varName);
VariablesOperator.VarOperatorList.Add(varName, op);
}
AddOperator(op);
}
else
{
XmlSerializer xmlSerializer = new XmlSerializer(type);
IOperation op = xmlSerializer.Deserialize(reader) as IOperation;
AddOperator(op);
}
}
reader.Read();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
base.ReadXml(reader);
reader.ReadStartElement();
Date = XmlConvert.ToDateTime(reader.ReadElementContentAsString(XmlTags.Date, ""), XmlDateTimeSerializationMode.Utc);
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
while (reader.Read())
{
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (reader.Name == "Key")
{
this.Key = reader.ReadElementContentAsString();
}
if (reader.Name == "Expire")
{
var expire = reader.ReadElementContentAsString();
DateTime realExpire = DateTime.Now;
if (DateTime.TryParse(expire, out realExpire))
{
this.Expire = realExpire;
}
}
if (reader.Name == "Value")
{
var valueType = reader.GetAttribute("Type");
var type = Type.GetType(valueType);
var valueStr = string.Empty;
while (reader.Read())
{
if (reader.NodeType == System.Xml.XmlNodeType.CDATA)
{
valueStr = reader.Value;
break;
}
}
this.Value = XmlSerialize.DeserializeFromString(type, valueStr);
}
}
}
}
private void RestoreFiles(Excel.Worksheet thisSheet, string propname)
{
string vals = Utilities.ExcelHelpers.getWorksheetCustomProperty(thisSheet, propname);
if (vals != null)
{
System.Xml.XmlReader xvals = System.Xml.XmlReader.Create(new System.IO.StringReader(vals));
string x = "";
string y = "";
string z = "";
while (xvals.Read())
{
if (xvals.NodeType == System.Xml.XmlNodeType.Element && xvals.Name == "SourceFile")
{
x = "";
y = "";
z = "";
}
if (xvals.NodeType == System.Xml.XmlNodeType.Element && xvals.Name == "FileName")
{
z = xvals.ReadElementContentAsString();
}
if (xvals.NodeType == System.Xml.XmlNodeType.Element && xvals.Name == "SQLStatement")
{
y = xvals.ReadElementContentAsString();
}
if (xvals.NodeType == System.Xml.XmlNodeType.Element && xvals.Name == "DisplayName")
{
x = xvals.ReadElementContentAsString();
}
if (xvals.NodeType == System.Xml.XmlNodeType.EndElement && xvals.Name == "SourceFile")
{
if (!files.Contains(new SourceFile(y, x, z, true)))
{
files.Add(new SourceFile(y, x, z, true));
}
}
}
}
AddFilesToList();
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
if (reader.Name == "intObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
int i = reader.ReadElementContentAsInt(s, "");
SetInt(s, i);
}
reader.ReadEndElement();
}
if (reader.Name == "floatObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
float f = reader.ReadElementContentAsFloat(s, "");
SetFloat(s, f);
}
reader.ReadEndElement();
}
if (reader.Name == "boolObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
bool b = reader.ReadElementContentAsBoolean(s, "");
SetBool(s, b);
}
reader.ReadEndElement();
}
if (reader.Name == "vectorObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
string content = reader.ReadElementContentAsString(s, "");
}
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public void ReadXmlContent(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.Read();
bool done = false;
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case "aliaces":
if (reader.ReadToDescendant("aliace"))
{
List <string> aList = new List <string>();
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (!reader.IsEmptyElement)
{
string aliace = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(aliace))
{
if (!aList.Contains(aliace))
{
aList.Add(aliace);
}
}
}
if (!reader.Read())
{
break;
}
}
//MergeAliaces(aList);
ALIACES = aList;
}
break;
default:
{
done = true;
break;
}
}
reader.MoveToContent();
if (done || !reader.Read())
{
break;
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
src = reader.GetAttribute("src") ?? System.String.Empty;
bool isEmptyElement = reader.IsEmptyElement;
if (!isEmptyElement) // (1)
{
Value = reader.ReadElementContentAsString();
}
else
{
Value = System.String.Empty;
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
if (wasEmpty)
{
return;
}
reader.Read();
while (reader.NodeType == XmlNodeType.Element)
{
string key = reader.GetAttribute("key");
string value = reader.ReadElementContentAsString();
this[key] = value;
}
reader.ReadEndElement();
}
/// <summary>
/// Custom helper to deserialize a SqlError object from Xml.
/// </summary>
private static SqlError DeserializeSqlError(System.Xml.XmlReader reader)
{
Dictionary <string, string> sqlErrorParameters = new Dictionary <string, string>();
// Read the subtree and fill in the parameters.
int startDepth = reader.Depth;
reader.ReadStartElement();
while (reader.Depth > startDepth)
{
string name = reader.Name;
string value = reader.ReadElementContentAsString();
sqlErrorParameters.Add(name, value);
}
reader.ReadEndElement();
// Make sure all parameters were defined.
if ((!sqlErrorParameters.ContainsKey("infoNumber")) ||
(!sqlErrorParameters.ContainsKey("errorState")) ||
(!sqlErrorParameters.ContainsKey("errorClass")) ||
(!sqlErrorParameters.ContainsKey("server")) ||
(!sqlErrorParameters.ContainsKey("errorMessage")) ||
(!sqlErrorParameters.ContainsKey("procedure")) ||
(!sqlErrorParameters.ContainsKey("lineNumber")))
{
// Incomplete definition
throw new XmlException("Incomplete definition of 'SqlError' in mock query result.");
}
// Using reflection to create a new SqlError object.
SqlError newSqlError = (SqlError)typeof(SqlError).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] {
typeof(int), typeof(byte), typeof(byte), typeof(string), typeof(string), typeof(string), typeof(int)
}, null).Invoke(new object[] {
int.Parse(sqlErrorParameters["infoNumber"]),
byte.Parse(sqlErrorParameters["errorState"]),
byte.Parse(sqlErrorParameters["errorClass"]),
sqlErrorParameters["server"],
sqlErrorParameters["errorMessage"],
sqlErrorParameters["procedure"],
int.Parse(sqlErrorParameters["lineNumber"])
});
return(newSqlError);
}
protected override List <HotSearchInfo> AnalysisData(System.Xml.XmlReader reader)
{
var list = new List <HotSearchInfo>(20);
while (reader.Read())
{
while (reader.NodeType == XmlNodeType.Element &&
reader.Name == "keyword")
{
int nodeValue = 0;
list.Add(new HotSearchInfo()
{
Type = int.TryParse(reader.GetAttribute("type"), out nodeValue) ? nodeValue : 0,
Count = int.TryParse(reader.GetAttribute("count"), out nodeValue) ? nodeValue : 0,
Name = reader.ReadElementContentAsString()
});
}
}
return(list);
}
public void ReadXml(System.Xml.XmlReader reader)
{
Initialize();
if (reader.MoveToContent() == XmlNodeType.Element)
{
Default = reader["Default"];
if (reader.ReadToDescendant("Translations"))
{
if (reader.ReadToDescendant("Translation"))
{
while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "Translation")
{
_Translations.Add(reader["LanguageCode"], reader.ReadElementContentAsString());
}
}
reader.Read();
}
reader.Read();
}
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToDescendant("LotsOfData") == false)
{
throw new Exception("could not find the start of element LotsOfData");
}
if (reader.ReadToDescendant("Boolean") == false)
{
throw new Exception("could not find the start of element Boolean");
}
reader.Read();
if (reader.ReadContentAsBoolean() == false)
{
throw new Exception("did not find the correct value in Boolean");
}
//DateTime
if (reader.ReadToNextSibling("DateTime") == false)
{
throw new Exception("could not find the start of element DateTime");
}
reader.Read();
DateTime now = reader.ReadContentAsDateTime();
if (now != Now)
{
TimeSpan diff = new TimeSpan((now.Ticks - Now.Ticks));
if (diff.TotalMilliseconds > 1000)
{
// seconds are lost in Xml
throw new Exception(String.Format("Dates differ {0} {1} Ticks {2}", now, Now, (now.Ticks - Now.Ticks)));
}
}
//DecimalValue
if (reader.ReadToNextSibling("DecimalValue") == false)
{
throw new Exception("could not find the start of element DecimalValue");
}
// reader.Read();
decimal decimalValue = (decimal)reader.ReadElementContentAs(typeof(decimal), null);
if (decimalValue != CommonUtilities.DecimalValue)
{
string msg = String.Format("different decimal Values {0} {1}", decimalValue, CommonUtilities.DecimalValue);
throw new Exception(msg);
}
//DoubleValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "DoubleValue")
{
if (reader.ReadToNextSibling("DoubleValue") == false)
{
throw new Exception("could not find the start of element DoubleValue");
}
}
//reader.Read();
double doubleValue = (double)reader.ReadElementContentAsDouble();
if (doubleValue != CommonUtilities.DoubleValue)
{
string msg = String.Format("different double Values {0} {1}", doubleValue, CommonUtilities.DoubleValue);
throw new Exception(msg);
}
//FloatValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "FloatValue")
{
if (reader.ReadToNextSibling("FloatValue") == false)
{
throw new Exception("could not find the start of element FloatValue");
}
}
//reader.Read();
float floatValue = (float)reader.ReadElementContentAs(typeof(float), null);
if (floatValue != CommonUtilities.FloatValue)
{
string msg = String.Format("different floatValue Values {0} {1}", floatValue, CommonUtilities.FloatValue);
throw new MyException(msg);
}
//IntValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "IntValue")
{
if (reader.ReadToNextSibling("IntValue") == false)
{
throw new Exception("could not find the start of element IntValue");
}
}
// reader.Read();
int intValue = reader.ReadElementContentAsInt();
if (intValue != CommonUtilities.IntValue)
{
string msg = String.Format("different intValue Values {0} {1}", intValue, CommonUtilities.IntValue);
throw new MyException(msg);
}
//LongValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "LongValue")
{
if (reader.ReadToNextSibling("LongValue") == false)
{
throw new Exception("could not find the start of element LongValue");
}
}
//reader.Read();
long longValue = (long)reader.ReadElementContentAs(typeof(long), null);
if (longValue != CommonUtilities.LongValue)
{
string msg = String.Format("different longValue Values {0} {1}", longValue, CommonUtilities.LongValue);
throw new MyException(msg);
}
//Object
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "Object")
{
if (reader.ReadToNextSibling("Object") == false)
{
throw new MyException("could not find the start of element Object");
}
}
//reader.Read();
TimeSpan objectValue = (TimeSpan)reader.ReadElementContentAs(typeof(TimeSpan), null);
if (objectValue != CommonUtilities.TimeSpanValue)
{
string msg = String.Format("different objectValue Values {0} {1}", objectValue, CommonUtilities.TimeSpanValue);
throw new MyException(msg);
}
//StringValue
if (reader.NodeType != System.Xml.XmlNodeType.Element && reader.Name != "StringValue")
{
if (reader.ReadToNextSibling("StringValue") == false)
{
throw new MyException("could not find the start of element StringValue");
}
}
//reader.Read();
string stringValue = reader.ReadElementContentAsString();
if (stringValue == null || stringValue.Equals(CommonUtilities.XmlStringForAttributes) == false)
{
string msg = String.Format("different stringValue Values {0} {1}", stringValue, CommonUtilities.XmlStringForAttributes);
throw new MyException(msg);
}
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(System.Xml.XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
else if (reader.NodeType == XmlNodeType.Whitespace)
{
continue;
}
else if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name.ToLowerInvariant())
{
case "rolename":
RoleName = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "billingfrequency":
BillingFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(BillingFrequency))
{
BillingFrequency = "N";
}
break;
case "billingperiod":
BillingPeriod = reader.ReadElementContentAsInt();
break;
case "servicefee":
ServiceFee = reader.ReadElementContentAsFloat();
if (ServiceFee < 0)
{
ServiceFee = 0;
}
break;
case "trialfrequency":
TrialFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(TrialFrequency))
{
TrialFrequency = "N";
}
break;
case "trialperiod":
TrialPeriod = reader.ReadElementContentAsInt();
break;
case "trialfee":
TrialFee = reader.ReadElementContentAsFloat();
if (TrialFee < 0)
{
TrialFee = 0;
}
break;
case "ispublic":
IsPublic = reader.ReadElementContentAsBoolean();
break;
case "autoassignment":
AutoAssignment = reader.ReadElementContentAsBoolean();
break;
case "rsvpcode":
RSVPCode = reader.ReadElementContentAsString();
break;
case "iconfile":
IconFile = reader.ReadElementContentAsString();
break;
case "roletype":
switch (reader.ReadElementContentAsString())
{
case "adminrole":
_RoleType = Roles.RoleType.Administrator;
break;
case "registeredrole":
_RoleType = Roles.RoleType.RegisteredUser;
break;
case "subscriberrole":
_RoleType = Roles.RoleType.Subscriber;
break;
default:
_RoleType = Roles.RoleType.None;
break;
}
_RoleTypeSet = true;
break;
}
}
}
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IRssFeed ret = (IRssFeed) new RssFeed();
reader.Read();
// RDF versions of RSS don't have version tags.
//double version = double.Parse(reader.GetAttribute("version"));
reader.ReadToDescendant("channel");
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "link":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "description":
ret.Description = reader.ReadElementContentAsString();
break;
case "language":
ret.Culture = CachedPropertiesProvider.ConvertToCultureInfo(reader.ReadElementContentAsString());
break;
case "copyright":
ret.Copyright = reader.ReadElementContentAsString();
break;
case "managingEditor":
ret.ManagingEditor = reader.ReadElementContentAsString();
break;
case "webMaster":
ret.WebMaster = reader.ReadElementContentAsString();
break;
case "pubDate":
ret.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "lastBuildDate":
ret.LastChanged = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Category = ConvertToIRssCategory(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "generator":
ret.Generator = reader.ReadElementContentAsString();
break;
case "docs":
ret.Doc = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "cloud":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Cloud = ConvertToIRssCloud(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "ttl":
ret.TimeToLive = CachedPropertiesProvider.ConvertToInt(reader.ReadElementContentAsString());
break;
case "image":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Image = ConvertToIRssImage(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
/*case "rating":
* break;*/
case "textInput":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.TextInput = ConvertToIRssTextInput(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipHours":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipHours = ConvertToSkipHourList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipDays":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipDays = ConvertToDayOfWeekList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "item":
using (XmlReader itemReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(itemReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
/// <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(System.Xml.XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
reader.MoveToContent();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement(Constants.ContinuationConstants.ContinuationTopElement);
if (!isEmptyElement)
{
while (true)
{
if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
{
switch (reader.Name)
{
case Constants.ContinuationConstants.VersionElement:
string version = reader.ReadElementContentAsString();
if (version != Constants.ContinuationConstants.CurrentVersion)
{
throw new System.Xml.XmlException(string.Format(SR.UnexpectedElement, version));
}
break;
case Constants.ContinuationConstants.NextPartitionKeyElement:
this.NextPartitionKey = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.NextRowKeyElement:
this.NextRowKey = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.NextTableNameElement:
this.NextTableName = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.TypeElement:
string continuationType = reader.ReadElementContentAsString();
if ("Table" != continuationType)
{
throw new System.Xml.XmlException(SR.UnexpectedContinuationType);
}
break;
default:
throw new System.Xml.XmlException(string.Format(SR.UnexpectedElement, reader.Name));
}
}
else
{
reader.ReadEndElement();
return;
}
}
}
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IAtomFeed ret = (IAtomFeed) new AtomFeed();
reader.Read();
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "id":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI);
break;
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "updated":
ret.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "generator":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Generator = ConvertToIAtomGenerator(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "author":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Authors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "link":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Links.Add(ConvertToIAtomLink(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Categories.Add(ConvertToIAtomCategory(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "entry":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "contributor":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Contributors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "logo":
ret.Logo = reader.ReadElementContentAsString();
break;
case "icon":
ret.Icon = reader.ReadElementContentAsString();
break;
case "rights":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Rights = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "subtitle":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Subtitle = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
public override string ReadElementContentAsString()
{
CheckAsync();
return(_coreReader.ReadElementContentAsString());
}
