public void Load(System.Xml.XmlTextReader tr, string localName)
{
int count;
tr.ReadStartElement(localName);
_viewDirectionRecentIsFirst = tr.ReadElementContentAsBoolean("DirectionRecentFirst", string.Empty);
count = XmlConvert.ToInt32(tr.GetAttribute("Count"));
tr.ReadStartElement("ColumnWidths");
_columnWidths = new double[count];
for (int i = 0; i < count; i++)
{
_columnWidths[i] = tr.ReadElementContentAsInt("Width", string.Empty);
}
if (count > 0)
{
tr.ReadEndElement(); // ColumnWidths
}
if (null != _view)
{
_view.ColumnWidths = _columnWidths;
_columnWidths = null;
}
tr.ReadEndElement();
}
public static AAInventoryItemBase Deserialize(string serialization)
{
AAInventoryItemBase item = new AAInventoryItemBase();
StringReader sr = new StringReader(serialization);
XmlTextReader xtr = new XmlTextReader(sr);
xtr.ReadStartElement("InventoryItem");
item.Name = xtr.ReadElementString("Name");
item.ID = UUID.Parse(xtr.ReadElementString("ID"));
item.InvType = Convert.ToInt32(xtr.ReadElementString("InvType"));
item.CreatorId = xtr.ReadElementString("CreatorUUID");
item.CreationDate = Convert.ToInt32(xtr.ReadElementString("CreationDate"));
item.Owner = UUID.Parse(xtr.ReadElementString("Owner"));
item.Description = xtr.ReadElementString("Description");
item.AssetType = Convert.ToInt32(xtr.ReadElementString("AssetType"));
item.AssetID = UUID.Parse(xtr.ReadElementString("AssetID"));
item.SaleType = Convert.ToByte(xtr.ReadElementString("SaleType"));
item.SalePrice = Convert.ToInt32(xtr.ReadElementString("SalePrice"));
item.BasePermissions = Convert.ToUInt32(xtr.ReadElementString("BasePermissions"));
item.CurrentPermissions = Convert.ToUInt32(xtr.ReadElementString("CurrentPermissions"));
item.EveryOnePermissions = Convert.ToUInt32(xtr.ReadElementString("EveryOnePermissions"));
item.NextPermissions = Convert.ToUInt32(xtr.ReadElementString("NextPermissions"));
item.Flags = Convert.ToUInt32(xtr.ReadElementString("Flags"));
item.GroupID = UUID.Parse(xtr.ReadElementString("GroupID"));
item.GroupOwned = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));
xtr.ReadEndElement();
xtr.Close();
sr.Close();
return item;
}
public void LoadPIDSetting_FromXmlTextReader(ref XmlTextReader xml_reader)
{
this.cycle_time_in_seconds = Double.Parse(xml_reader.ReadElementString("cycle_time_in_seconds"));
xml_reader.ReadStartElement("outer_zone");
this.proportional_band_EachZone[0] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
this.offset_EachZone[0] = Double.Parse(xml_reader.ReadElementString("offset"));
this.reset_EachZone[0] = Double.Parse(xml_reader.ReadElementString("reset"));
this.rate_EachZone[0] = Double.Parse(xml_reader.ReadElementString("rate"));
xml_reader.ReadEndElement();
xml_reader.ReadStartElement("sample_zone");
this.proportional_band_EachZone[1] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
this.offset_EachZone[1] = Double.Parse(xml_reader.ReadElementString("offset"));
this.reset_EachZone[1] = Double.Parse(xml_reader.ReadElementString("reset"));
this.rate_EachZone[1] = Double.Parse(xml_reader.ReadElementString("rate"));
xml_reader.ReadEndElement();
xml_reader.ReadStartElement("inner_zone");
this.proportional_band_EachZone[2] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
this.offset_EachZone[2] = Double.Parse(xml_reader.ReadElementString("offset"));
this.reset_EachZone[2] = Double.Parse(xml_reader.ReadElementString("reset"));
this.rate_EachZone[2] = Double.Parse(xml_reader.ReadElementString("rate"));
xml_reader.ReadEndElement();
}
public new void Load(XmlTextReader reader)
{
reader.ReadStartElement("Placeable");
_canEnter = (reader.GetAttribute("canEnter", "").Trim() == "1");
_doesWarp = (reader.GetAttribute("doesWarp", "").Trim() == "1");
_name = reader.GetAttribute("name", "").Trim();
base.Load(reader);
reader.ReadEndElement();
}
public static CharacterInformation Read(XmlTextReader reader)
{
reader.ReadStartElement ("Class");
string name = reader.ReadElementString ("Name");
reader.ReadEndElement();
return new CharacterInformation
{
Class = name
};
}
public static DatabaseConfiguration Read(string file)
{
DatabaseConfiguration config = new DatabaseConfiguration ();
StreamReader s = new StreamReader (file);
using (s) {
XmlTextReader tr = new XmlTextReader (s);
tr.MoveToContent ();
if (tr.IsEmptyElement)
return config;
tr.ReadStartElement ("Configuration");
tr.MoveToContent ();
while (tr.NodeType != XmlNodeType.EndElement) {
if (tr.NodeType != XmlNodeType.Element || tr.IsEmptyElement) {
tr.Skip ();
}
else if (tr.LocalName == "DisabledAddins") {
// For back compatibility
tr.ReadStartElement ();
tr.MoveToContent ();
while (tr.NodeType != XmlNodeType.EndElement) {
if (tr.NodeType == XmlNodeType.Element && tr.LocalName == "Addin")
config.addinStatus [tr.ReadElementString ()] = null;
else
tr.Skip ();
tr.MoveToContent ();
}
tr.ReadEndElement ();
}
else if (tr.LocalName == "AddinStatus") {
tr.ReadStartElement ();
tr.MoveToContent ();
while (tr.NodeType != XmlNodeType.EndElement) {
if (tr.NodeType == XmlNodeType.Element && tr.LocalName == "Addin") {
string aid = tr.GetAttribute ("id");
string senabled = tr.GetAttribute ("enabled");
if (senabled.Length == 0 || senabled == "True")
config.addinStatus [aid] = config;
else
config.addinStatus [aid] = null;
}
tr.Skip ();
tr.MoveToContent ();
}
tr.ReadEndElement ();
}
tr.MoveToContent ();
}
}
return config;
}
public static NamingRules LoadRules(string xmlPath)
{
NamingRules namingRules = new NamingRules();
namingRules.rules = new List<NamingRule>();
using (XmlReader reader = new XmlTextReader(xmlPath))
{
reader.ReadStartElement("Rules");
reader.ReadStartElement("GeneralSettings");
reader.ReadStartElement("FilenameRegex");
namingRules.filenameRegex = reader.ReadString();
reader.ReadEndElement();
reader.ReadStartElement("ContextDepth");
namingRules.contextDepth = reader.ReadContentAsInt();
if (namingRules.ContextDepth < 1 || namingRules.ContextDepth > 4)
throw new FormatException("Context Depth must be between 1 and 4");
reader.ReadEndElement();
reader.ReadStartElement("ContextSeparator");
namingRules.contextSeparator = reader.ReadString();
reader.ReadEndElement();
reader.ReadEndElement();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
System.Diagnostics.Debug.Assert(reader.Name == "Rules");
break;
}
//if (reader.IsStartElement())
// System.Diagnostics.Debug.Assert(reader.Name == "Rule");
reader.ReadStartElement("Rule");
//reader.Read();
reader.ReadStartElement("SearchString");
string regex = reader.ReadString();
reader.ReadEndElement();
reader.ReadStartElement("Replacement");
string replacement = reader.ReadString();
reader.ReadEndElement();
reader.ReadEndElement();
namingRules.rules.Add(new NamingRule(regex, replacement));
}
reader.ReadEndElement();
}
return namingRules;
}
public void Deserialize(string str)
{
using (TextReader textReader = new StringReader(str))
using (XmlReader xmlReader = new XmlTextReader(textReader))
{
xmlReader.ReadStartElement();
xmlReader.ReadStartElement();
this.Id = new Guid(xmlReader.ReadContentAsString());
xmlReader.ReadEndElement();
xmlReader.ReadStartElement();
this.Value1 = xmlReader.ReadContentAsInt();
xmlReader.ReadEndElement();
xmlReader.ReadStartElement();
this.Value2 = xmlReader.ReadContentAsDateTime();
xmlReader.ReadEndElement();
xmlReader.ReadStartElement();
this.Value3 = xmlReader.ReadContentAsString();
xmlReader.ReadEndElement();
xmlReader.ReadStartElement();
this.Value4 = xmlReader.ReadContentAsDecimal();
xmlReader.ReadEndElement();
xmlReader.ReadEndElement();
}
}
public static SensorData ReadSensorData(string soap) {
SensorData sd;
XmlTextReader xmread;
sd = null;
try {
sd = new SensorData();
using (System.IO.StringReader read = new System.IO.StringReader(soap)) {
xmread = new XmlTextReader(read);
xmread.ReadStartElement("SensorDataContainer");
xmread.ReadStartElement("Sensor");
xmread.ReadStartElement("HasMotion");
sd.HasMotion = bool.Parse(xmread.ReadString());
xmread.ReadEndElement();
xmread.ReadStartElement("NodeId");
sd.NodeId = int.Parse(xmread.ReadString());
xmread.ReadEndElement();
xmread.ReadStartElement("PowerLevel");
sd.PowerLevel = int.Parse(xmread.ReadString());
xmread.ReadEndElement();
xmread.ReadStartElement("TimeStamp");
sd.TimeStamp = DateTime.Parse(xmread.ReadString());
xmread.ReadEndElement();
xmread.ReadEndElement();
xmread.ReadEndElement();
}
} catch (Exception) {
throw;
}
return (sd);
}
/// <summary>
/// Decodes a function call from Flash.
/// </summary>
/// <param name="xml">The XML string representing the function call.</param>
/// <returns>An ExternalInterfaceCall object representing the function call.</returns>
public static ExternalInterfaceCall DecodeInvoke(string xml)
{
XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Document, null);
reader.Read();
string functionName = reader.GetAttribute("name");
ExternalInterfaceCall result = new ExternalInterfaceCall(functionName);
reader.ReadStartElement("invoke");
reader.ReadStartElement("arguments");
while (reader.NodeType != XmlNodeType.EndElement && reader.Name != "arguments")
{
result.AddArgument(ReadElement(reader));
}
reader.ReadEndElement();
reader.ReadEndElement();
return result;
}
//Copy code from SceneObjectSerializer.ProcessColor
public static System.Drawing.Color DeSerializeColor(string colorString)
{
StringReader sr = new StringReader(colorString);
XmlTextReader reader = new XmlTextReader(sr);
System.Drawing.Color color = new System.Drawing.Color();
reader.ReadStartElement("Color");
if (reader.Name == "R")
{
float r = reader.ReadElementContentAsFloat("R", String.Empty);
float g = reader.ReadElementContentAsFloat("G", String.Empty);
float b = reader.ReadElementContentAsFloat("B", String.Empty);
float a = reader.ReadElementContentAsFloat("A", String.Empty);
color = System.Drawing.Color.FromArgb((int)a, (int)r, (int)g, (int)b);
reader.ReadEndElement();
}
return color;
}
public static ArcanaPlayer ReadCharacter(XmlTextReader reader)
{
reader.ReadStartElement ("Character");
int id = Convert.ToInt32 (reader.ReadElementString ("CharacterID"));
string name = reader.ReadElementString ("Name");
string pclass = reader.ReadElementString ("Class");
int level = Convert.ToInt32 (reader.ReadElementString ("Level"));
reader.ReadEndElement ();
ArcanaPlayer p = classConstructors[pclass] ();
{
p.CharacterID = id;
p.Name = name;
p.Class = pclass;
p.Level = level;
}
return p;
}
public static void Load()
{
using (FileStream strm = new FileStream(FileName, FileMode.Open))
{
Pairs.Clear();
using (XmlReader reader = new XmlTextReader(strm))
{
reader.ReadStartElement("SimpleConfig");
while (reader.Name == "parameter")
{
string key = reader.GetAttribute("name");
string value = reader.GetAttribute("value");
Pairs[key] = value;
reader.Read();
}
reader.ReadEndElement();
reader.Close();
}
strm.Close();
}
}
public void Load()
{
ReadWriteTestStructure ();
// Load class templates
string classTemplateRoot = Path.Combine (Environment.CurrentDirectory, "Content//classes.xml");
using (XmlTextReader treader = new XmlTextReader (classTemplateRoot))
{
treader.ReadStartElement ("Classes");
while (treader.Read () && treader.NodeType != XmlNodeType.EndElement)
{
CharacterInformation template = ClassTemplateSerializer.Read (treader);
template.Texture = Moxy.ContentManager.Load<Texture2D> ("Interface//cf_" + template.Class.ToLower());
Classes.Add (template);
}
treader.ReadEndElement();
}
// Load all characters
foreach (string file in Directory.EnumerateFiles (Path.Combine(Environment.CurrentDirectory, "saves")))
{
using (XmlTextReader reader = new XmlTextReader (file))
{
reader.MoveToElement();
while (reader.Read())
{
ArcanaPlayer player = CharacterSerializer.ReadCharacter (reader);
Characters.Add (new CharacterInformation (player));
characters.Add (player.CharacterID, player);
}
}
}
}
private List<ShippingOption> ParseResponse(string response, bool isDomestic, ref string error)
{
var shippingOptions = new List<ShippingOption>();
string postageStr = isDomestic ? "Postage" : "Service";
string mailServiceStr = isDomestic ? "MailService" : "SvcDescription";
string rateStr = isDomestic ? "Rate" : "Postage";
string classStr = isDomestic ? "CLASSID" : "ID";
string carrierServicesOffered = isDomestic ? _uspsSettings.CarrierServicesOfferedDomestic : _uspsSettings.CarrierServicesOfferedInternational;
using (var sr = new StringReader(response))
using (var tr = new XmlTextReader(sr))
{
do
{
tr.Read();
if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
{
string errorText = "";
while (tr.Read())
{
if ((tr.Name == "Description") && (tr.NodeType == XmlNodeType.Element))
errorText += "Error Desc: " + tr.ReadString();
if ((tr.Name == "HelpContext") && (tr.NodeType == XmlNodeType.Element))
errorText += "USPS Help Context: " + tr.ReadString() + ". ";
}
error = "USPS Error returned: " + errorText;
}
if ((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.Element))
{
string serviceId = string.Empty;
// Find the ID for the service
if (tr.HasAttributes)
{
for (int i = 0; i < tr.AttributeCount; i++)
{
tr.MoveToAttribute(i);
if (tr.Name.Equals(classStr))
{
// Add delimiters [] so that single digit IDs aren't found in mutli-digit IDs
serviceId = String.Format("[{0}]", tr.Value);
break;
}
}
}
// Go to the next rate if the service ID is not in the list of services to offer
if (!String.IsNullOrEmpty(serviceId) &&
!String.IsNullOrEmpty(carrierServicesOffered) &&
!carrierServicesOffered.Contains(serviceId))
{
continue;
}
string serviceCode = string.Empty;
string postalRate = string.Empty;
do
{
tr.Read();
if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.Element))
{
serviceCode = tr.ReadString();
tr.ReadEndElement();
if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.EndElement))
break;
}
if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.Element))
{
postalRate = tr.ReadString();
tr.ReadEndElement();
if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.EndElement))
break;
}
}
while (!((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.EndElement)));
//USPS issue fixed
char tm = (char)174;
serviceCode = serviceCode.Replace("<sup>&reg;</sup>", tm.ToString());
ShippingOption shippingOption = shippingOptions.Find((s) => s.Name == serviceCode);
if (shippingOption == null)
{
shippingOption = new ShippingOption();
shippingOption.Name = serviceCode;
shippingOptions.Add(shippingOption);
}
shippingOption.Rate += Convert.ToDecimal(postalRate, new CultureInfo("en-US"));
}
}
while (!tr.EOF);
}
return shippingOptions;
}
public static void read()
{
try
{
XmlTextReader reader = new XmlTextReader("config.xml");
string temp;
reader.MoveToContent();
reader.ReadStartElement("CONFIG"); // <CONFIG>
reader.ReadStartElement("U2722_ADDRESS");
temp = reader.ReadString();
temp.Trim();
U2722_ADDRESS = temp;
reader.ReadEndElement();
reader.ReadStartElement("COM_ADDRESS");
temp = reader.ReadString();
temp.Trim();
COM_ADDRESS = temp;
reader.ReadEndElement();
reader.ReadStartElement("I2C_ADDRESS");
temp = reader.ReadString();
temp.Trim();
I2C_ADDRESS = Convert.ToByte(temp);
reader.ReadEndElement();
reader.ReadStartElement("SN_LENGTH");
temp = reader.ReadString();
temp.Trim();
SERIAL_NUMBER_LENGTH = Convert.ToInt32(temp);
reader.ReadEndElement();
reader.ReadStartElement("ALS_DARK");
temp = reader.ReadString();
temp.Trim();
ALS_DARK = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("ALS_LIGHT");
temp = reader.ReadString();
temp.Trim();
ALS_LIGHT = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("RESISTOR_MIN");
temp = reader.ReadString();
temp.Trim();
RESISTOR_MIN = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("RESISTOR_MAX");
temp = reader.ReadString();
temp.Trim();
RESISTOR_MAX = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("LED_MIN");
temp = reader.ReadString();
temp.Trim();
LED_MIN = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("LED_MAX");
temp = reader.ReadString();
temp.Trim();
LED_MAX = Convert.ToDouble(temp);
reader.ReadEndElement();
reader.ReadStartElement("MEAS_TIMES");
temp = reader.ReadString();
temp.Trim();
MEAS_TIMES = Convert.ToInt32(temp);
reader.ReadEndElement();
reader.ReadStartElement("ONLINE");
temp = reader.ReadString();
temp.Trim();
if (temp == "true")
{
ONLINE = true;
}
else
{
ONLINE = false;
}
reader.ReadEndElement();
reader.ReadEndElement(); // </CONFIG>
}
catch
{ }
}
private void ReadFeedHeader () {
if (IsUpToDate (feed_file)) {
is_valid_file = false;
return;
}
try {
Log.Debug ("Opening feed file: {0}", feed_file);
reader = new XmlTextReader (feed_file);
reader.WhitespaceHandling = WhitespaceHandling.None;
is_valid_file = true;
// move to beginning of document
reader.MoveToContent();
// move to <rss ...> node
reader.ReadStartElement ("rss");
// move to <channel> node
reader.ReadStartElement ("channel");
// read <title>
do {
string elementName = reader.Name;
if (elementName == "item")
break;
switch (elementName) {
case "title":
reader.ReadStartElement ("title");
channel_title = reader.ReadString ();
reader.ReadEndElement ();
break;
case "link":
reader.ReadStartElement ("link");
channel_link = reader.ReadString ();
reader.ReadEndElement ();
break;
case "description":
reader.ReadStartElement ("description");
channel_description = reader.ReadString ();
reader.ReadEndElement ();
break;
// ignore other elements
default:
reader.ReadOuterXml ();
break;
}
} while (!reader.EOF && reader.NodeType == XmlNodeType.Element);
} catch (XmlException ex) {
Log.Warn (ex, "Caught exception parsing feed file:");
is_valid_file = false;
reader.Close ();
}
}
private void ParseSettingString (string source)
{
XmlTextReader xtr = new XmlTextReader (source,
XmlNodeType.Element, null);
xtr.Read ();
if (xtr.Name != "DataViewSettingCollectionString")
// easy way to throw the expected exception ;-)
xtr.ReadStartElement ("DataViewSettingCollectionString");
if (xtr.IsEmptyElement)
return; // MS does not change the value.
xtr.Read ();
do {
xtr.MoveToContent ();
if (xtr.NodeType == XmlNodeType.EndElement)
break;
if (xtr.NodeType == XmlNodeType.Element)
ReadTableSetting (xtr);
else
xtr.Skip ();
} while (!xtr.EOF);
if (xtr.NodeType == XmlNodeType.EndElement)
xtr.ReadEndElement ();
}
private static void ProcessColor(SceneObjectPart obj, XmlTextReader reader)
{
reader.ReadStartElement("Color");
if (reader.Name == "R")
{
float r = reader.ReadElementContentAsFloat("R", String.Empty);
float g = reader.ReadElementContentAsFloat("G", String.Empty);
float b = reader.ReadElementContentAsFloat("B", String.Empty);
float a = reader.ReadElementContentAsFloat("A", String.Empty);
obj.Color = Color.FromArgb((int)a, (int)r, (int)g, (int)b);
reader.ReadEndElement();
}
}
/// <summary>
/// Read a shape from xml input
/// </summary>
/// <param name="reader"></param>
/// <param name="name">The name of the xml element containing the shape</param>
/// <param name="errors">a list containing the failing node names. If no failures then null.</param>
/// <returns>The shape parsed</returns>
public static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name, out List<string> errorNodeNames)
{
List<string> internalErrorNodeNames = null;
PrimitiveBaseShape shape = new PrimitiveBaseShape();
if (reader.IsEmptyElement)
{
reader.Read();
errorNodeNames = null;
return shape;
}
reader.ReadStartElement(name, String.Empty); // Shape
ExternalRepresentationUtils.ExecuteReadProcessors(
shape,
m_ShapeXmlProcessors,
reader,
(o, nodeName, e)
=>
{
// m_log.DebugFormat(
// "[SceneObjectSerializer]: Exception while parsing Shape property {0}: {1}{2}",
// nodeName, e.Message, e.StackTrace);
if (internalErrorNodeNames == null)
internalErrorNodeNames = new List<string>();
internalErrorNodeNames.Add(nodeName);
}
);
reader.ReadEndElement(); // Shape
errorNodeNames = internalErrorNodeNames;
return shape;
}
public static TaskInventoryDictionary ReadTaskInventory(XmlTextReader reader, string name)
{
TaskInventoryDictionary tinv = new TaskInventoryDictionary();
if (reader.IsEmptyElement)
{
reader.Read();
return tinv;
}
reader.ReadStartElement(name, String.Empty);
while (reader.Name == "TaskInventoryItem")
{
reader.ReadStartElement("TaskInventoryItem", String.Empty); // TaskInventory
TaskInventoryItem item = new TaskInventoryItem();
ExternalRepresentationUtils.ExecuteReadProcessors(
item,
m_TaskInventoryXmlProcessors,
reader);
reader.ReadEndElement(); // TaskInventoryItem
tinv.Add(item.ItemID, item);
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement(); // TaskInventory
return tinv;
}
public static SceneObjectPart Xml2ToSOP(XmlTextReader reader)
{
SceneObjectPart obj = new SceneObjectPart();
reader.ReadStartElement("SceneObjectPart");
ExternalRepresentationUtils.ExecuteReadProcessors(
obj,
m_SOPXmlProcessors,
reader,
(o, nodeName, e)
=> m_log.DebugFormat(
"[SceneObjectSerializer]: Exception while parsing {0} in object {1} {2}: {3}{4}",
((SceneObjectPart)o).Name, ((SceneObjectPart)o).UUID, nodeName, e.Message, e.StackTrace));
reader.ReadEndElement(); // SceneObjectPart
//m_log.DebugFormat("[XXX]: parsed SOP {0} - {1}", obj.Name, obj.UUID);
return obj;
}
public static RegionSettings FromStream(Stream stream)
{
RegionSettings settings = new RegionSettings();
System.Globalization.NumberFormatInfo nfi = Utils.EnUsCulture.NumberFormat;
using (XmlTextReader xtr = new XmlTextReader(stream))
{
xtr.ReadStartElement("RegionSettings");
xtr.ReadStartElement("General");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "AllowDamage":
settings.AllowDamage = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandResell":
settings.AllowLandResell = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandJoinDivide":
settings.AllowLandJoinDivide = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "BlockFly":
settings.BlockFly = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "BlockLandShowInSearch":
settings.BlockLandShowInSearch = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "BlockTerraform":
settings.BlockTerraform = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "DisableCollisions":
settings.DisableCollisions = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "DisablePhysics":
settings.DisablePhysics = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "DisableScripts":
settings.DisableScripts = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "MaturityRating":
settings.MaturityRating = Int32.Parse(xtr.ReadElementContentAsString());
break;
case "RestrictPushing":
settings.RestrictPushing = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "AgentLimit":
settings.AgentLimit = Int32.Parse(xtr.ReadElementContentAsString());
break;
case "ObjectBonus":
settings.ObjectBonus = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("GroundTextures");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "Texture1":
settings.TerrainDetail0 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture2":
settings.TerrainDetail1 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture3":
settings.TerrainDetail2 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture4":
settings.TerrainDetail3 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "ElevationLowSW":
settings.TerrainStartHeight00 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationLowNW":
settings.TerrainStartHeight01 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationLowSE":
settings.TerrainStartHeight10 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationLowNE":
settings.TerrainStartHeight11 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationHighSW":
settings.TerrainHeightRange00 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationHighNW":
settings.TerrainHeightRange01 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationHighSE":
settings.TerrainHeightRange10 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "ElevationHighNE":
settings.TerrainHeightRange11 = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("Terrain");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "WaterHeight":
settings.WaterHeight = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "TerrainRaiseLimit":
settings.TerrainRaiseLimit = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "TerrainLowerLimit":
settings.TerrainLowerLimit = Single.Parse(xtr.ReadElementContentAsString(), nfi);
break;
case "UseEstateSun":
settings.UseEstateSun = Boolean.Parse(xtr.ReadElementContentAsString());
break;
case "FixedSun":
settings.FixedSun = Boolean.Parse(xtr.ReadElementContentAsString());
break;
}
}
}
return settings;
}
public WearableCacheItem[] Get(UUID id)
{
if (m_URL == String.Empty)
return null;
int size = 0;
using (RestClient rc = new RestClient(m_URL))
{
List<WearableCacheItem> ret = new List<WearableCacheItem>();
rc.AddResourcePath("bakes");
rc.AddResourcePath(id.ToString());
rc.RequestMethod = "GET";
try
{
Stream s = rc.Request(m_Auth);
using (XmlTextReader sr = new XmlTextReader(s))
{
sr.ReadStartElement("BakedAppearance");
while (sr.LocalName == "BakedTexture")
{
string sTextureIndex = sr.GetAttribute("TextureIndex");
int lTextureIndex = Convert.ToInt32(sTextureIndex);
string sCacheId = sr.GetAttribute("CacheId");
UUID lCacheId = UUID.Zero;
if (!(UUID.TryParse(sCacheId, out lCacheId)))
{
// ?? Nothing here
}
++size;
sr.ReadStartElement("BakedTexture");
AssetBase a = (AssetBase)m_serializer.Deserialize(sr);
ret.Add(new WearableCacheItem() { CacheId = lCacheId, TextureIndex = (uint)lTextureIndex, TextureAsset = a, TextureID = a.FullID });
sr.ReadEndElement();
}
m_log.DebugFormat("[XBakes]: read {0} textures for user {1}", ret.Count, id);
}
return ret.ToArray();
}
catch (XmlException)
{
return null;
}
}
}
public void TestSerializeXml2()
{
TestHelper.InMethod();
//log4net.Config.XmlConfigurator.Configure();
string rpName = "My Little Pony";
UUID rpUuid = UUID.Parse("00000000-0000-0000-0000-000000000064");
UUID rpCreatorId = UUID.Parse("00000000-0000-0000-0000-000000000015");
PrimitiveBaseShape shape = PrimitiveBaseShape.CreateSphere();
// Vector3 groupPosition = new Vector3(10, 20, 30);
// Quaternion rotationOffset = new Quaternion(20, 30, 40, 50);
// Vector3 offsetPosition = new Vector3(5, 10, 15);
SceneObjectPart rp = new SceneObjectPart();
rp.UUID = rpUuid;
rp.Name = rpName;
rp.CreatorID = rpCreatorId;
rp.Shape = shape;
SceneObjectGroup so = new SceneObjectGroup(rp);
// Need to add the object to the scene so that the request to get script state succeeds
m_scene.AddSceneObject(so);
string xml2 = m_serialiserModule.SerializeGroupToXml2(so);
XmlTextReader xtr = new XmlTextReader(new StringReader(xml2));
xtr.ReadStartElement("SceneObjectGroup");
xtr.ReadStartElement("SceneObjectPart");
UUID uuid = UUID.Zero;
string name = null;
UUID creatorId = UUID.Zero;
while (xtr.Read() && xtr.Name != "SceneObjectPart")
{
if (xtr.NodeType != XmlNodeType.Element)
continue;
switch (xtr.Name)
{
case "UUID":
xtr.ReadStartElement("UUID");
uuid = UUID.Parse(xtr.ReadElementString("Guid"));
xtr.ReadEndElement();
break;
case "Name":
name = xtr.ReadElementContentAsString();
break;
case "CreatorID":
xtr.ReadStartElement("CreatorID");
creatorId = UUID.Parse(xtr.ReadElementString("Guid"));
xtr.ReadEndElement();
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("OtherParts");
xtr.ReadEndElement();
xtr.Close();
// TODO: More checks
Assert.That(uuid, Is.EqualTo(rpUuid));
Assert.That(name, Is.EqualTo(rpName));
Assert.That(creatorId, Is.EqualTo(rpCreatorId));
}
private List<ShippingOption> ParseResponse(string response, bool isDomestic, ref string error)
{
var shippingOptions = new List<ShippingOption>();
string postageStr = isDomestic ? "Postage" : "Service";
string mailServiceStr = isDomestic ? "MailService" : "SvcDescription";
string rateStr = isDomestic ? "Rate" : "Postage";
using (var sr = new StringReader(response))
using (var tr = new XmlTextReader(sr))
{
do
{
tr.Read();
if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
{
string errorText = "";
while (tr.Read())
{
if ((tr.Name == "Description") && (tr.NodeType == XmlNodeType.Element))
errorText += "Error Desc: " + tr.ReadString();
if ((tr.Name == "HelpContext") && (tr.NodeType == XmlNodeType.Element))
errorText += "USPS Help Context: " + tr.ReadString() + ". ";
}
error = "USPS Error returned: " + errorText;
}
if ((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.Element))
{
string serviceCode = string.Empty;
string postalRate = string.Empty;
do
{
tr.Read();
if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.Element))
{
serviceCode = tr.ReadString();
tr.ReadEndElement();
if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.EndElement))
break;
}
if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.Element))
{
postalRate = tr.ReadString();
tr.ReadEndElement();
if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.EndElement))
break;
}
}
while (!((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.EndElement)));
if (shippingOptions.Find((s) => s.Name == serviceCode) == null)
{
var shippingOption = new ShippingOption();
//TODO check whether we need to multiply rate by package quantity
shippingOption.Rate = Convert.ToDecimal(postalRate, new CultureInfo("en-US"));
shippingOption.Name = serviceCode;
shippingOptions.Add(shippingOption);
}
}
}
while (!tr.EOF);
}
return shippingOptions;
}
private void FromXml(String xmlStream)
{
try
{
StringReader stringReader = new StringReader(xmlStream);
XmlTextReader reader = new XmlTextReader(stringReader);
while (reader.EOF == false)
{
reader.ReadStartElement("ValidationContext");
String generateSummaryResults = reader.ReadElementString("GenerateSummaryResults");
if (generateSummaryResults == "true")
{
_generateSummaryResults = true;
}
String generateDetailedResults = reader.ReadElementString("GenerateDetailedResults");
if (generateDetailedResults == "true")
{
_generateDetailedResults = true;
}
// ...
// EVS Specific Context properties
// ...
reader.ReadElementString("EvsSpecificContext");
reader.ReadEndElement();
}
reader.Close();
}
catch (Exception e)
{
String message = String.Format("Failed to FromXml() DVTK DICOM EVS Validation Context XML stream: \"{0}\". Error: \"{1}\"", xmlStream, e.Message);
throw new Exception(message, e);
}
}
/// <summary>
/// Deserialize settings
/// </summary>
/// <param name="serializedSettings"></param>
/// <returns></returns>
/// <exception cref="System.Xml.XmlException"></exception>
public static InventoryItemBase Deserialize(string serialization)
{
InventoryItemBase item = new InventoryItemBase();
using (XmlTextReader reader = new XmlTextReader(new StringReader(serialization)))
{
reader.ReadStartElement("InventoryItem");
ExternalRepresentationUtils.ExecuteReadProcessors<InventoryItemBase>(
item, m_InventoryItemXmlProcessors, reader);
reader.ReadEndElement(); // InventoryItem
}
//m_log.DebugFormat("[XXX]: parsed InventoryItemBase {0} - {1}", obj.Name, obj.UUID);
return item;
}
private void ReadConfigFile (XmlTextReader reader)
{
//int depth = reader.Depth;
for (reader.MoveToContent ();
!reader.EOF && reader.NodeType != XmlNodeType.EndElement;
reader.MoveToContent ()) {
string name = reader.Name;
if (name == "configSections") {
if (reader.HasAttributes)
ThrowException ("Unrecognized attribute in <configSections>.", reader);
if (reader.IsEmptyElement)
reader.Skip ();
else {
reader.Read ();
reader.MoveToContent ();
if (reader.NodeType != XmlNodeType.EndElement)
ReadSections (reader, null);
reader.ReadEndElement ();
}
} else if (name != null && name != "") {
StorePending (name, reader);
MoveToNextElement (reader);
} else {
MoveToNextElement (reader);
}
}
}
public object Deserialize(Stream inStream, ISoapMessage soapMessage)
{
ArrayList headers = null;
xmlReader = new XmlTextReader(inStream);
xmlReader.WhitespaceHandling = WhitespaceHandling.None;
mapper = new SoapTypeMapper(_binder);
try
{
// SOAP-ENV:Envelope
xmlReader.MoveToContent();
xmlReader.ReadStartElement ();
xmlReader.MoveToContent();
// Read headers
while (!(xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Body" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace))
{
if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Header" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace)
{
if (headers == null) headers = new ArrayList ();
DeserializeHeaders (headers);
}
else
xmlReader.Skip ();
xmlReader.MoveToContent();
}
// SOAP-ENV:Body
xmlReader.ReadStartElement();
xmlReader.MoveToContent();
// The root object
if (soapMessage != null)
{
if (DeserializeMessage (soapMessage)) {
_topObjectId = NextAvailableId;
RegisterObject (_topObjectId, soapMessage, null, 0, null, null);
}
xmlReader.MoveToContent();
if (headers != null)
soapMessage.Headers = (Header[]) headers.ToArray (typeof(Header));
}
while (xmlReader.NodeType != XmlNodeType.EndElement)
Deserialize();
// SOAP-ENV:Body
xmlReader.ReadEndElement ();
xmlReader.MoveToContent();
// SOAP-ENV:Envelope
xmlReader.ReadEndElement ();
}
finally
{
if(xmlReader != null) xmlReader.Close();
}
return TopObject;
}
/// <summary>
/// Deserialize settings
/// </summary>
/// <param name="serializedSettings"></param>
/// <returns></returns>
/// <exception cref="System.Xml.XmlException"></exception>
public static RegionSettings Deserialize(string serializedSettings)
{
RegionSettings settings = new RegionSettings();
StringReader sr = new StringReader(serializedSettings);
XmlTextReader xtr = new XmlTextReader(sr);
xtr.ReadStartElement("RegionSettings");
xtr.ReadStartElement("General");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "AllowDamage":
settings.AllowDamage = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandResell":
settings.AllowLandResell = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AllowLandJoinDivide":
settings.AllowLandJoinDivide = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockFly":
settings.BlockFly = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockLandShowInSearch":
settings.BlockShowInSearch = bool.Parse(xtr.ReadElementContentAsString());
break;
case "BlockTerraform":
settings.BlockTerraform = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisableCollisions":
settings.DisableCollisions = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisablePhysics":
settings.DisablePhysics = bool.Parse(xtr.ReadElementContentAsString());
break;
case "DisableScripts":
settings.DisableScripts = bool.Parse(xtr.ReadElementContentAsString());
break;
case "MaturityRating":
settings.Maturity = int.Parse(xtr.ReadElementContentAsString());
break;
case "RestrictPushing":
settings.RestrictPushing = bool.Parse(xtr.ReadElementContentAsString());
break;
case "AgentLimit":
settings.AgentLimit = int.Parse(xtr.ReadElementContentAsString());
break;
case "ObjectBonus":
settings.ObjectBonus = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("GroundTextures");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "Texture1":
settings.TerrainTexture1 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture2":
settings.TerrainTexture2 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture3":
settings.TerrainTexture3 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "Texture4":
settings.TerrainTexture4 = UUID.Parse(xtr.ReadElementContentAsString());
break;
case "ElevationLowSW":
settings.Elevation1SW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowNW":
settings.Elevation1NW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowSE":
settings.Elevation1SE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationLowNE":
settings.Elevation1NE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighSW":
settings.Elevation2SW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighNW":
settings.Elevation2NW = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighSE":
settings.Elevation2SE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "ElevationHighNE":
settings.Elevation2NE = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
}
}
xtr.ReadEndElement();
xtr.ReadStartElement("Terrain");
while (xtr.Read() && xtr.NodeType != XmlNodeType.EndElement)
{
switch (xtr.Name)
{
case "WaterHeight":
settings.WaterHeight = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "TerrainRaiseLimit":
settings.TerrainRaiseLimit = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "TerrainLowerLimit":
settings.TerrainLowerLimit = double.Parse(xtr.ReadElementContentAsString(), Culture.NumberFormatInfo);
break;
case "UseEstateSun":
settings.UseEstateSun = bool.Parse(xtr.ReadElementContentAsString());
break;
case "FixedSun":
settings.FixedSun = bool.Parse(xtr.ReadElementContentAsString());
break;
}
}
xtr.Close();
sr.Close();
return settings;
}
