/// <summary>
/// 分析集合大小
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
protected ChannelSearchOutlineInfo AnalysisCount(System.Xml.XmlReader reader)
{
ChannelSearchOutlineInfo channelSearchOutLineInfo = new ChannelSearchOutlineInfo();
if (reader.ReadToFollowing("count"))
{
channelSearchOutLineInfo.Count = reader.ReadElementContentAsInt();
if (reader.IsStartElement("page_count"))
{
channelSearchOutLineInfo.PageCount = reader.ReadElementContentAsInt();
if (reader.IsStartElement("countInPage"))
{
channelSearchOutLineInfo.CountInPage = reader.ReadElementContentAsInt();
if (reader.IsStartElement("page"))
{
channelSearchOutLineInfo.CurrentPage = reader.ReadElementContentAsInt();
///*
// * 总个数是否小于每页的个数,小于的话第一页返回总个数，其余页返回0
// * 不小于判断是哪页，其余页返回每页个数，最后一页算一下还剩下多少页
// */
//return count > countInPage ?
// (pageIndex > pageCount ? 0 : (pageIndex == pageCount) ? count - (pageIndex - 1) * countInPage : countInPage) :
// (pageIndex > 1 ? 0 : count);
}
}
}
}
return(channelSearchOutLineInfo);
}
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(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
Durability = reader.ReadElementContentAsInt("Durability", "");
Damage = reader.ReadElementContentAsInt("Damage", "");
string s = reader.ReadElementString("Type", "");
switch (s)
{
case "FISTS":
Type = WeaponType.FISTS;
break;
case "LIGHT":
Type = WeaponType.LIGHT;
break;
case "MEDIUM":
Type = WeaponType.MEDIUM;
break;
case "HEAVY":
Type = WeaponType.HEAVY;
break;
}
reader.ReadEndElement();
}
/// <summary>
/// 分析集合大小
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
protected virtual int AnalysisCount(System.Xml.XmlReader reader)
{
if (reader.ReadToFollowing("count"))
{
var count = reader.ReadElementContentAsInt();
if (reader.IsStartElement("page_count"))
{
var pageCount = reader.ReadElementContentAsInt();
if (reader.IsStartElement("countInPage"))
{
var countInPage = reader.ReadElementContentAsInt();
if (reader.IsStartElement("page"))
{
var pageIndex = reader.ReadElementContentAsInt();
/*
* 总个数是否小于每页的个数,小于的话第一页返回总个数，其余页返回0
* 不小于判断是哪页，其余页返回每页个数，最后一页算一下还剩下多少页
*/
return(count > countInPage ?
(pageIndex > pageCount ? 0 : (pageIndex == pageCount) ? count - (pageIndex - 1) * countInPage : countInPage) :
(pageIndex > 1 ? 0 : count));
}
}
}
}
return(20);
}
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 void ReadXml(XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (reader.NodeType == XmlNodeType.Whitespace)
{
continue;
}
switch (reader.Name)
{
case "portalID":
PortalID = reader.ReadElementContentAsInt();
break;
case "portalAliasID":
PortalAliasID = reader.ReadElementContentAsInt();
break;
case "HTTPAlias":
HTTPAlias = reader.ReadElementContentAsString();
break;
}
}
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
InitHours = reader.ReadElementContentAsInt("initHours", "");
InitMinutes = reader.ReadElementContentAsInt("initMinutes", "");
Multiplier = reader.ReadElementContentAsInt("Multiplier", "");
reader.ReadEndElement();
}
internal static void Read(XmlReader reader, TransactionSearchResult result)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (result == null)
throw new ArgumentNullException("result");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(TransactionSearchResultSerializer.TransactionSearchResult);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, TransactionSearchResultSerializer.TransactionSearchResult))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case TransactionSearchResultSerializer.Date:
result.Date = reader.ReadElementContentAsDateTime();
break;
case TransactionSearchResultSerializer.CurrentPage:
result.CurrentPage = reader.ReadElementContentAsInt();
break;
case TransactionSearchResultSerializer.TotalPages:
result.TotalPages = reader.ReadElementContentAsInt();
break;
case TransactionSummaryListSerializer.Transactions:
TransactionSummaryListSerializer.Read(reader, result.Items);
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
public void ReadXml(XmlReader reader)
{
if (reader.LocalName != "icon" && !reader.ReadToDescendant("icon"))
throw new InvalidDataException();
XmlHelper.ParseXml(reader, new XmlParseSet
{
{"url", () => this.RelativeUrl = reader.ReadString()},
{"mimetype", () => this.MimeType = reader.ReadString()},
{"width", () => this.Width = reader.ReadElementContentAsInt()},
{"height", () => this.Height = reader.ReadElementContentAsInt()},
{"depth", () => this.Depth = reader.ReadElementContentAsInt()}
});
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result"></param>
internal static void Read(XmlReader reader, PreApprovalSearchResult result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(PreApprovalSearchResultSerializer.PreApprovalSearchResult);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, PreApprovalSearchResultSerializer.PreApprovalSearchResult))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PreApprovalSearchResultSerializer.Date:
result.Date = reader.ReadElementContentAsDateTime();
break;
case PreApprovalSearchResultSerializer.CurrentPage:
result.CurrentPage = reader.ReadElementContentAsInt();
break;
case PreApprovalSearchResultSerializer.TotalPages:
result.TotalPages = reader.ReadElementContentAsInt();
break;
case PreApprovalSummaryListSerializer.PreApprovals:
PreApprovalSummaryListSerializer.Read(reader, result.PreApprovals);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
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;
}
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;
}
public static AreaType ReadAreaType(XmlReader reader, Counter<string> badTags)
{
string type = null;
int level = 0;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "type")
{
type = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "level")
{
level = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "area")
{
break;
}
}
if (level == 0 || type == null)
throw new Exception("Area type or level not specified.");
return new AreaType(level, type);
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
this.UniqueID = (uint)reader.ReadElementContentAsInt("UniqueID", "");
this.Name = reader.ReadElementString("Name", "");
this.MaxSize = reader.ReadElementContentAsFloat("MaxSize", "");
this.Lod1Distance = reader.ReadElementContentAsFloat("Lod1Distance", "");
this.Lod2Distance = reader.ReadElementContentAsFloat("Lod2Distance", "");
this.Shadows = reader.ReadElementContentAsBoolean("Shadows", "");
this.SoftShadows = reader.ReadElementContentAsBoolean("SoftShadows", "");
this.Bloom = reader.ReadElementContentAsBoolean("Bloom", "");
this.UseGraph = reader.ReadElementContentAsBoolean("UseGraph", "");
this.UseLods = reader.ReadElementContentAsBoolean("UseLods", "");
if (reader.Name == "Wind")
{
reader.ReadStartElement();
Wind = new Vector2(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""));
reader.ReadEndElement();
}
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;
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "count":
this.Count = reader.ReadElementContentAsInt();
continue;
case "prevphoto":
this.PreviousPhoto = new ContextPhoto();
this.PreviousPhoto.Load(reader);
if (this.PreviousPhoto.PhotoId == "0")
{
this.PreviousPhoto = (ContextPhoto) null;
continue;
}
else
continue;
case "nextphoto":
this.NextPhoto = new ContextPhoto();
this.NextPhoto.Load(reader);
if (this.NextPhoto.PhotoId == "0")
{
this.NextPhoto = (ContextPhoto) null;
continue;
}
else
continue;
default:
continue;
}
}
}
public bool FromXml(XmlReader reader)
{
if (reader == null || reader.Name != "Lib")
{
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 == "Text" || reader.ReadToNextSibling("Text"))
{
Text = reader.ReadElementContentAsString();
}
if (reader.Name == "Memo" || reader.ReadToNextSibling("Memo"))
{
Memo = reader.ReadElementContentAsString();
}
return true;
}
internal static WindowsStoreServiceAppCategoryNode ParseXml(XmlReader reader)
{
var node = new WindowsStoreServiceAppCategoryNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "I":
node.Id = reader.ReadElementContentAsInt();
break;
case "N":
node.Name = reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
internal static void Read(XmlReader reader, PaymentMethod paymentMethod)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (paymentMethod == null)
throw new ArgumentNullException("paymentMethod");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(PaymentMethodSerializer.PaymentMethod);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, PaymentMethodSerializer.PaymentMethod))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PaymentMethodSerializer.PaymentMethodType:
paymentMethod.PaymentMethodType = reader.ReadElementContentAsInt();
break;
case PaymentMethodSerializer.PaymentMethodCode:
paymentMethod.PaymentMethodCode = reader.ReadElementContentAsInt();
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
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);
}
}
}
private static Color ReadColorXml(XmlReader reader)
{
int a, r, g, b;
reader.ReadStartElement("Color");
reader.MoveToContent();
a = reader.ReadElementContentAsInt("A", "");
reader.MoveToContent();
r = reader.ReadElementContentAsInt("R", "");
reader.MoveToContent();
g = reader.ReadElementContentAsInt("G", "");
reader.MoveToContent();
b = reader.ReadElementContentAsInt("B", "");
reader.MoveToContent();
reader.ReadEndElement();
reader.MoveToContent();
return Color.FromArgb(a, r, g, b);
}
public void ReadXml(XmlReader reader)
{
short parentNodeId = 0;
string port = null;
bool encrypt = false;
byte[] key = new byte[16];
bool readElement = false;
while (!readElement)
{
switch (reader.Name)
{
case "ID":
id = (short)reader.ReadElementContentAsInt();
break;
case "nodeType":
_cachedType = new sensorType((sensorTypeEnum)reader.ReadElementContentAsInt());
break;
case "parentNodeID":
parentNodeId = (short)reader.ReadElementContentAsInt();
break;
case "driverPort":
port = reader.ReadElementContentAsString();
break;
case "driverEncrypt":
encrypt = reader.ReadElementContentAsBoolean();
break;
case "key":
reader.ReadElementContentAsBinHex(key, 0, 16);
break;
case "selectedSensor":
if (reader.NodeType == XmlNodeType.EndElement)
readElement = true;
else
reader.Read();
break;
default:
reader.Read();
break;
}
}
_parentNode = new Node(parentNodeId);
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
JunkCount = reader.ReadElementContentAsInt("JunkCount", "");
FoodCount = reader.ReadElementContentAsInt("FoodCount", "");
if (reader.Name == "Weapon")
{
//reader.ReadStartElement();
(CurrentWeapon as IXmlSerializable).ReadXml(reader);
//reader.ReadEndElement();
}
reader.ReadEndElement();
}
internal MegaComment(XmlReader rdr)
{
rdr.ReadStartElement("mega_comment");
this.Id = rdr.ReadElementContentAsInt("id", "");
this.Comment = rdr.ReadElementString("comment");
this.User = rdr.ReadElementString("user");
this.CreatedAt = rdr.ReadElementString("created_at").FromBatchBookFormat2();
this.RecordId = int.Parse(rdr.ReadElementString("record_id"));
rdr.ReadEndElement();
}
/// <summary>
/// Read a direct payment session request result
/// </summary>
/// <param name="streamReader"></param>
/// <param name="installments"></param>
internal static void Read(XmlReader reader, Installment installment)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Installment);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Installment))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.CreditCardBrand:
installment.cardBrand = reader.ReadElementContentAsString();
break;
case SerializerHelper.Quantity:
installment.quantity = reader.ReadElementContentAsInt();
break;
case SerializerHelper.Amount:
installment.amount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.TotalAmount:
installment.totalAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.InterestFree:
installment.interestFree = reader.ReadElementContentAsBoolean();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="paymentMethod"></param>
internal static void Read(XmlReader reader, PaymentMethod paymentMethod)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(PaymentMethodSerializer.PaymentMethod);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, PaymentMethodSerializer.PaymentMethod))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PaymentMethodSerializer.PaymentMethodType:
paymentMethod.PaymentMethodType = reader.ReadElementContentAsInt();
break;
case PaymentMethodSerializer.PaymentMethodCode:
paymentMethod.PaymentMethodCode = reader.ReadElementContentAsInt();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
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();
}
private TimeFrame[] DeserializeIntervals(XmlReader reader)
{
var timesCount = reader.ReadElementContentAsInt(nameof(AttendedTimesCount), string.Empty);
var timesArray = new TimeFrame[timesCount];
var timeFrameSerializer = new XmlSerializer(typeof(TimeFrame));
for (int i = 0; i < timesArray.Length; i++)
{
var interval = (TimeFrame)timeFrameSerializer.Deserialize(reader);
timesArray[i] = interval;
}
return timesArray;
}
/// <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);
}
}
}
private IAttendance[] DeserializeAttendances(XmlReader reader)
{
var attendanceCount = reader.ReadElementContentAsInt(nameof(AttendancesCount), string.Empty);
var attendanceArray = new IAttendance[attendanceCount];
for (int i = 0; i < attendanceCount; i++)
{
var serializer = SerializationHelper.ReadTypeInformationAndGetSerializer(reader);
var currentAttendance = (IAttendance)serializer.Deserialize(reader);
attendanceArray[i] = currentAttendance;
}
return attendanceArray;
}
public override bool FromXml(XmlReader reader)
{
if (reader == null || reader.Name != "Item")
{
return false;
}
reader.ReadStartElement();
if (reader.Name == "Order" || reader.ReadToNextSibling("Order"))
{
Order = reader.ReadElementContentAsInt();
}
if (reader.Name == "Id" || reader.ReadToNextSibling("Id"))
{
Id = reader.ReadElementContentAsString();
}
if (reader.Name == "Type" || reader.ReadToNextSibling("Type"))
{
Type = reader.ReadElementContentAsInt();
}
if (reader.Name == "Name" || reader.ReadToNextSibling("Name"))
{
Name = reader.ReadElementContentAsString();
}
if (reader.Name == "Text" || reader.ReadToNextSibling("Text"))
{
Text = reader.ReadElementContentAsString();
}
if (reader.Name == "Data" || reader.ReadToNextSibling("Data"))
{
Data = reader.ReadElementContentAsString();
}
if (reader.Name == "Memo" || reader.ReadToNextSibling("Memo"))
{
Memo = reader.ReadElementContentAsString();
}
reader.ReadEndElement();
return true;
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
SunID = (uint)reader.ReadElementContentAsInt("SunID", "");
LightDayID = (uint)reader.ReadElementContentAsInt("LightDayID", "");
LightNightID = (uint)reader.ReadElementContentAsInt("LightNightID", "");
if (reader.Name == "TextureNames")
{
TextureNames = new string[TEXTURE_COUNT];
reader.ReadStartElement();
for (int i = 0; i < TEXTURE_COUNT; ++i)
{
TextureNames[i] = reader.ReadElementString("TextureName");
}
reader.ReadEndElement();
}
SunriseMinutes = reader.ReadElementContentAsInt("SunriseMinutes", "");
SunsetMinutes = reader.ReadElementContentAsInt("SunsetMinutes", "");
StateChangeMinutes = reader.ReadElementContentAsInt("StateChangeMinutes", "");
HorizonOffset = reader.ReadElementContentAsFloat("HorizonOffset", "");
reader.ReadEndElement();
}
/// <summary>
/// Loads the configuration from Xml.
/// </summary>
/// <param name="reader">An XmlReader containing your configuration data.</param>
/// <returns>A new instance of a LoggingConfig object.</returns>
public static LoggingConfig Load(XmlReader reader)
{
var result = new LoggingConfig();
reader.GoToElement();
if (!reader.IsEmptyElement)
{
result.MaxExceptionLength = null; // assume no limit is intended if param is omitted
reader.ReadStartElement();
while (reader.GoToSibling())
{
switch (reader.LocalName)
{
case "LogUnhandledExceptions":
result.LogUnhandledExceptions = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "PreventUnhandledExceptions":
result.PreventUnhandledExceptions = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "MaxExceptionLength":
result.MaxExceptionLength = reader.ReadElementContentAsInt();
break;
case "QueryStringParam":
result.QueryStringParam = reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
else
reader.Skip();
return result;
}
public ShowRule(XmlReader reader)
{
this.SetToDefaults();
reader.Read();
while (reader.Name != "Rule")
return;
reader.Read();
while (reader.Name != "Rule")
{
if (reader.Name == "DoWhatNow")
this.DoWhatNow = (RuleAction) reader.ReadElementContentAsInt();
else if (reader.Name == "First")
this.First = reader.ReadElementContentAsInt();
else if (reader.Name == "Second")
this.Second = reader.ReadElementContentAsInt();
else if (reader.Name == "Text")
this.UserSuppliedText = reader.ReadElementContentAsString();
else
reader.ReadOuterXml();
}
}
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;
}
internal static WindowsPhoneStoreServiceAppRatingsDistributionsNode ParseXml(XmlReader reader)
{
var node = new WindowsPhoneStoreServiceAppRatingsDistributionsNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "oneStarRatings":
node.OneStarRatings = reader.ReadElementContentAsInt();
break;
case "twoStarRatings":
node.TwoStarRatings = reader.ReadElementContentAsInt();
break;
case "threeStarRatings":
node.ThreeStarRatings = reader.ReadElementContentAsInt();
break;
case "fourStarRatings":
node.FourStarRatings = reader.ReadElementContentAsInt();
break;
case "fiveStarRatings":
node.FiveStarRatings = reader.ReadElementContentAsInt();
break;
default:
reader.Skip();
break;
}
}
return node;
}
internal Communication(XmlReader rdr)
{
rdr.ReadStartElement("communication");
this.Id = rdr.ReadElementContentAsInt("id", "");
this.Subject = rdr.ReadElementString("subject");
this.Body = rdr.ReadElementString("body");
this.Date = rdr.ReadElementContentAsDateTime("date", "ctype");
this.Ctype = rdr.ReadElementString("");
this.Tags = Tag.BuildList(rdr);
this.Comments = MegaComment.BuildList(rdr);
this.CreateAt = rdr.ReadElementContentAsDateTime("created_at", "");
this.UpdatedAt = rdr.ReadElementContentAsDateTime("updated_at", "");
rdr.ReadEndElement();
}
internal static void Read(XmlReader reader, Shipping shipping)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (shipping == null)
throw new ArgumentNullException("shipping");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(ShippingSerializer.Shipping);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, ShippingSerializer.Shipping))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case ShippingSerializer.ShippingType:
shipping.ShippingType = reader.ReadElementContentAsInt();
break;
case ShippingSerializer.Cost:
shipping.Cost = reader.ReadElementContentAsDecimal();
break;
case AddressSerializer.Address:
Address address = new Address();
AddressSerializer.Read(reader, address);
shipping.Address = address;
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
target = ResourceManager.Instance.CurrentScene.GetObject((uint)reader.ReadElementContentAsInt("TargetID", ""));
//target = ResourceManager.Instance.CurrentScene.GetObject(tmp);
if (reader.Name == "TargetPosition")
{
reader.ReadStartElement();
this.target.MyTransform.Position = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
ResourceManager.Instance.CurrentScene.ObjectsDictionary = new Dictionary <uint, GameObject>();
ResourceManager.Instance.CurrentScene.PointLights = new List <LightPoint>();
DirectionalLights = new LightDirectional[ResourceManager.DIRECTIONAL_MAX_LIGHTS];
if (reader.Name == "SceneParams")
{
Params = new SceneParams(0, "null");
(Params as IXmlSerializable).ReadXml(reader);
}
if (reader.Name == "AmbientLight")
{
AmbientLight = new LightAmbient(0, "null");
(AmbientLight as IXmlSerializable).ReadXml(reader);
}
int ctr = 0;
reader.ReadStartElement("DirectionalLights");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "DirectionalLight")
{
reader.ReadStartElement();
if (reader.Name != "null")
{
LightDirectional obj = new LightDirectional(0, "");
(obj as IXmlSerializable).ReadXml(reader);
DirectionalLights[ctr] = obj;
++ctr;
}
else
{
reader.ReadElementString("null", "");
reader.ReadEndElement();
++ctr;
}
}
}
reader.ReadEndElement();
reader.ReadStartElement("PointLights");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "PointLight")
{
reader.ReadStartElement();
LightPoint pl = new LightPoint(0, "");
ResourceManager.Instance.CurrentScene.PointLights.Add(pl);
(pl as IXmlSerializable).ReadXml(reader);
if (pl.CastShadows)
{
pl.SetupShadowRender();
}
reader.ReadEndElement();
}
else
{
reader.ReadElementString("null", "");
}
}
reader.ReadEndElement();
reader.ReadStartElement("ObjectsDictionary");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "GameObject")
{
reader.ReadStartElement();
GameObject obj = null;
uint key = (uint)reader.ReadElementContentAsInt("GameObjectKey", "");
if (ResourceManager.Instance.CurrentScene.ObjectsDictionary.TryGetValue(key, out obj))
{
Debug.Log("GameObject successfully loaded - " + obj.Name);
GameObject tmp = null;
(tmp as IXmlSerializable).ReadXml(reader);
}
else
{
obj = new GameObject(0, "");
ResourceManager.Instance.CurrentScene.ObjectsDictionary.Add(key, obj);
(obj as IXmlSerializable).ReadXml(reader);
Debug.Log("New Gameobject successfully loaded - " + obj.Name);
}
}
reader.ReadEndElement();
}
reader.ReadEndElement();
if (reader.Name == "Camera")
{
Cam = new Camera(0, "null", Vector3.Zero, Vector3.Zero, Vector3.Zero, Vector3.Zero, MathHelper.Pi / 3.0f, 1.0f, 0.1f, 2000.0f);
reader.ReadStartElement();
(Cam as IXmlSerializable).ReadXml(reader);
}
ObjectsDictionary = ResourceManager.Instance.CurrentScene.ObjectsDictionary;
PointLights = ResourceManager.Instance.CurrentScene.PointLights;
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
//reader.ReadStartElement();
UniqueID = (uint)reader.ReadElementContentAsInt("UniqueID", "");
Name = reader.ReadElementString("Name", "");
DrawLast = reader.ReadElementContentAsBoolean("DrawLast", "");
if (reader.Name == "Tags")
{
reader.ReadStartElement();
Tags = new List <string>();
while (reader.NodeType != XmlNodeType.EndElement)
{
string s = reader.ReadElementString("Tag", "");
if (s != "null")
{
Tags.Add(s);
}
}
reader.ReadEndElement();
}
Dynamic = reader.ReadElementContentAsBoolean("Dynamic", "");
if (reader.Name == "MyTransform")
{
MyTransform = new Transform(this);
(MyTransform as IXmlSerializable).ReadXml(reader);
}
if (reader.Name == "MyPhysicalObject")
{
MyPhysicalObject = new PhysicalObject(this);
(MyPhysicalObject as IXmlSerializable).ReadXml(reader);
}
//if (reader.Name == "MyCollider")
//{
// reader.ReadStartElement();
// String s = reader.ReadElementString("Type", "");
// switch(s)
// {
// case "TrashSoup.Engine.BoxCollider":
// MyCollider = new BoxCollider(this);
// break;
// case "TrashSoup.Engine.SphereCollider":
// MyCollider = new SphereCollider(this);
// break;
// default:
// MyCollider = new Collider(this);
// break;
// }
// (MyCollider as IXmlSerializable).ReadXml(reader);
// reader.ReadEndElement();
//}
if (reader.Name == "MyAnimator")
{
reader.ReadStartElement();
Model baseAnim = null;
string baseAnimPath = reader.ReadElementString("BaseAnim", "");
if (!ResourceManager.Instance.Models.TryGetValue(baseAnimPath, out baseAnim))
{
baseAnim = ResourceManager.Instance.LoadModel(baseAnimPath);
}
MyAnimator = new Animator(this, ResourceManager.Instance.Models[baseAnimPath]);
(MyAnimator as IXmlSerializable).ReadXml(reader);
//MyAnimator.MyObject = ResourceManager.Instance.CurrentScene.GetObject(MyAnimator.tmp);
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
String s = reader.ReadElementString("AnimatorClip", "");
MyAnimator.AddAnimationClip(ResourceManager.Instance.LoadAnimationFromModel(
ResourceManager.Instance.Models[baseAnimPath],
ResourceManager.Instance.LoadAnimation(s),
s
));
//MyAnimator.animationPlayers.Add(s, new SkinningModelLibrary.AnimationPlayer(MyAnimator.SkinningData, s));
}
reader.ReadEndElement();
}
if (reader.Name == "Components")
{
List <object> parameters = new List <object>();
parameters.Add(this);
reader.MoveToContent();
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
Object obj = Activator.CreateInstance(Type.GetType(reader.Name), parameters.ToArray());
(obj as IXmlSerializable).ReadXml(reader);
Components.Add((ObjectComponent)obj);
}
}
if (reader.NodeType == System.Xml.XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
if (reader.Name == "MyCollider")
{
reader.ReadStartElement();
String s = reader.ReadElementString("Type", "");
switch (s)
{
//commented because Collider system will be changed
case "TrashSoup.Engine.BoxCollider":
MyCollider = new BoxCollider(this);
break;
case "TrashSoup.Engine.SphereCollider":
MyCollider = new SphereCollider(this);
break;
default:
//MyCollider = new Collider(this);
break;
}
(MyCollider as IXmlSerializable).ReadXml(reader);
reader.ReadEndElement();
}
//this.Initialize();
//reader.ReadEndElement();
}
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;
}
}
}
}
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 override int ReadElementContentAsInt()
{
CheckAsync();
return(_coreReader.ReadElementContentAsInt());
}
