public static DatabaseConfiguration Read (string file)
{
DatabaseConfiguration config = new DatabaseConfiguration ();
StreamReader s = new StreamReader (file);
using (s) {
XmlTextReader tr = new XmlTextReader (s);
tr.MoveToContent ();
tr.ReadStartElement ("Configuration");
tr.MoveToContent ();
tr.ReadStartElement ("DisabledAddins");
tr.MoveToContent ();
if (!tr.IsEmptyElement) {
while (tr.NodeType != XmlNodeType.EndElement) {
if (tr.NodeType == XmlNodeType.Element) {
if (tr.LocalName == "Addin")
config.DisabledAddins.Add (tr.ReadElementString ());
}
else
tr.Skip ();
tr.MoveToContent ();
}
}
}
return config;
}
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 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 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;
}
/// <summary>
/// Parses the input stream and return the associated project type. The stream should point to a project file (csproj or vbproj)
/// </summary>
/// <param name="st">The stream</param>
/// <returns>the project type</returns>
public static string GetProjectType(Stream st)
{
XmlTextReader rd = new XmlTextReader(st);
using (rd)
{
rd.ReadStartElement("Project");
rd.ReadToNextSibling("PropertyGroup");
rd.ReadStartElement("PropertyGroup");
rd.ReadToNextSibling("OutputType");
return rd.ReadString();
}
}
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 override void Deserialize(Node node, string data)
{
TextReader tr = new StringReader(data);
Dictionary<string, object> properties = new Dictionary<string, object>();
using(XmlReader xmlReader = new XmlTextReader(tr))
{
xmlReader.ReadStartElement("root");
do {
if (xmlReader.NodeType == XmlNodeType.Element) {
string name = xmlReader.Name;
if (xmlReader.Read()) {
switch (xmlReader.NodeType) {
case XmlNodeType.Text:
properties.Add(name, xmlReader.ReadContentAs(xmlReader.ValueType, null));
break;
case XmlNodeType.Element:
List<object> objs = new List<object>();
while(xmlReader.Read() && xmlReader.NodeType != XmlNodeType.EndElement) {
if (xmlReader.Name == "item")
objs.Add(xmlReader.ReadElementContentAs(xmlReader.ValueType, null));
}
properties.Add(name, objs.ToArray());
break;
}
}
}
} while(xmlReader.Read());
}
UpdateNode (node, properties);
}
static void PopulateCache(Dictionary<Key, GenericXmlSecurityToken> cache, Stream stream)
{
XmlTextReader reader = new XmlTextReader(stream);
while (reader.IsStartElement("Entry"))
{
reader.ReadStartElement();
Uri target = new Uri(reader.ReadElementString("Target"));
string issuerStr = reader.ReadElementString("Issuer");
Uri issuer = string.IsNullOrEmpty(issuerStr) ? null : new Uri(issuerStr);
reader.ReadStartElement("Token");
reader.ReadStartElement("XML");
XmlDocument doc = new XmlDocument();
XmlElement tokenXml = doc.ReadNode(reader) as XmlElement;
reader.ReadEndElement();
byte[] key = Convert.FromBase64String(reader.ReadElementString("Key"));
reader.ReadElementString("Id");
DateTime validFrom = Convert.ToDateTime(reader.ReadElementString("ValidFrom"));
DateTime validTo = Convert.ToDateTime(reader.ReadElementString("ValidTo"));
WSSecurityTokenSerializer serializer = new WSSecurityTokenSerializer();
reader.ReadStartElement("InternalTokenReference");
SecurityKeyIdentifierClause internalReference = serializer.ReadKeyIdentifierClause(reader);
reader.ReadEndElement();
reader.ReadStartElement("ExternalTokenReference");
SecurityKeyIdentifierClause externalReference = serializer.ReadKeyIdentifierClause(reader);
reader.ReadEndElement();
reader.ReadEndElement(); // token
reader.ReadEndElement(); // entry
List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>();
GenericXmlSecurityToken token = new GenericXmlSecurityToken(tokenXml, new BinarySecretSecurityToken(key), validFrom, validTo, internalReference, externalReference,
new ReadOnlyCollection<IAuthorizationPolicy>(policies));
cache.Add(new Key(target, issuer), token);
}
}
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);
}
}
public async Task<int> Execute()
{
using (var reader = new StreamReader(FileName, Encode))
{
XmlReader xmlReader = new XmlTextReader(reader);
xmlReader.ReadStartElement();
while (xmlReader.Read())
{
var xdoc = new XmlDocument();
string content = xmlReader.ReadOuterXml();
if (string.IsNullOrEmpty(content))
{
break;
}
xdoc.LoadXml(content);
for (int i = 0; i < xdoc.DocumentElement.ChildNodes.Count; i++)
{
var xele = xdoc.DocumentElement.ChildNodes[i] as XmlElement;
if (i != 0)
{
_logger.InfoLine(",");
}
_logger.InfoLine(xele.InnerText);
}
_logger.InfoLine("");
}
xmlReader.Close();
return 0;
}
}
public static VexObject Load(string fileFullPathAndName)
{
VexObject vo;
string rootFolder = Path.GetDirectoryName(fileFullPathAndName);
string fileNameOnly = Path.GetFileNameWithoutExtension(fileFullPathAndName);
Environment.CurrentDirectory = rootFolder;
string definitionsFolder = "";
string instancesFolder = "";
uint rootId = 0;
vo = new VexObject(fileNameOnly);
FileStream fs = new FileStream(fileFullPathAndName, FileMode.Open);
XmlTextReader r = new XmlTextReader(fs);
r.ReadStartElement("UIL");
while (r.Read())
{
if (r.IsStartElement())
{
switch (r.Name)
{
case "DefinitionsFolder":
if (r.Read())
{
definitionsFolder = r.Value.Trim();
}
break;
case "InstancesFolder":
if (r.Read())
{
instancesFolder = r.Value.Trim();
}
break;
case "RootId":
if (r.Read())
{
rootId = uint.Parse(r.Value.Trim(), NumberStyles.Any);
}
break;
}
}
}
fs.Close();
string defsPath = rootFolder + Path.DirectorySeparatorChar + fileNameOnly + definitionsFolder;
LoadDefinitions(defsPath, vo);
string instsPath = rootFolder + Path.DirectorySeparatorChar + fileNameOnly + instancesFolder;
LoadInstances(instsPath, vo);
vo.Root = (Timeline)vo.Definitions[rootId];
return vo;
}
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
};
}
void Load(string fileName)
{
// chargement des valeurs des options depuis le fichier Config.xml
try
{
using (XmlTextReader reader = new XmlTextReader(fileName))
{
reader.ReadStartElement("Config");
do
{
if (!reader.IsStartElement()) continue;
string value = reader.ReadString();
switch (reader.Name)
{
case "VLCPath": VLCPath = value; break;
case "DVDLetter": DVDLetter = value; break;
case "VlcPort": VlcPort = value; break;
case "SoundExts": SoundExts = value; break;
case "PictureExts": PictureExts = value; break;
case "VideoExts": VideoExts = value; break;
case "AudioLanguage": AudioLanguage = value; break;
case "SubLanguage": SubLanguage = value; break;
case "ShowVLC": ShowVLC = (value == "1") || (value == System.Boolean.TrueString); break;
case "Transcode":
switch (value.ToUpper())
{
case "MPGA": TranscodeAudio = AudioTranscode.MPGA; break;
case "A52": TranscodeAudio = AudioTranscode.A52; break;
case "PC": TranscodeAudio = AudioTranscode.PC; break;
default: TranscodeAudio = AudioTranscode.None; break;
}
break;
case "StartMinimized": StartMinimized = (value == "1") || (value == System.Boolean.TrueString); break;
case "MinimizeToTray": MinimizeToTray = (value == "1") || (value == System.Boolean.TrueString); break;
case "FFMpegInterlace": FFMpegInterlace = (value == "1") || (value == System.Boolean.TrueString); break;
case "HalfScale": HalfScale = (value == "1") || (value == System.Boolean.TrueString); break;
case "LIRCActive": LIRCActive = (value == "1") || (value == System.Boolean.TrueString); break;
case "TranscodeVB": TranscodeVB = value; break;
case "PCControlAllowed": PCControlAllowed = Convert.ToBoolean(value); break;
case "LessIconsInExplorer": LessIconsInExplorer = Convert.ToBoolean(value); break;
case "BlackBkgnds": BlackBkgnds = Convert.ToBoolean(value); break;
case "TranscodeVideo":
switch (value.ToUpper())
{
case "MPG2": TranscodeVideo = VideoTranscode.MPG2; break;
default: TranscodeVideo = VideoTranscode.None; break;
}
break;
}
} while (reader.Read());
}
}
catch (FileNotFoundException) { }
}
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;
}
public static IList<GameObject> Load(XmlTextReader reader, string path)
{
List<GameObject> listGameObject = new List<GameObject>();
reader.ReadStartElement("Objects");
while (reader.NodeType != XmlNodeType.EndElement || reader.Name != "Objects")
{
reader.Read();
if (reader.IsStartElement("Item"))
{
GameObject g_obj = readGameObject(reader);
listGameObject.Add(g_obj);
}
}
return listGameObject;
}
//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();
}
}
private void calculateDistancesFromKml(XmlTextReader reader)
{
reader.ReadStartElement("kml");
reader.Read();
if (reader.Name == "Document" || reader.Name == "Folder"){
string name = "";
string coordinates;
while (reader.Read()) {
if (reader.Name == "Placemark"){
while (reader.Read() && reader.Name != "Placemark"){
if (reader.Name == "name"){
name = reader.ReadElementString();
}
if (reader.Name == "LineString"){
while (reader.Read() && reader.Name != "LineString"){
if (reader.Name == "coordinates"){
CoordinatesDistanceSummarizer summarizer = new CoordinatesDistanceSummarizer();
coordinates = reader.ReadElementString();
KmlCoordinatesParser parser = new KmlCoordinatesParser(coordinates);
double[] coordinate;
while (parser.NextCoordinate(out coordinate)){
summarizer.AddCoordinate(coordinate[1],coordinate[0]);
}
DistanceLine dl = new DistanceLine(name,summarizer.Summarize());
distanceLines.Add(dl);
}
}
}
}
}
}
}
}
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);
}
}
}
}
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;
}
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;
}
}
}
static string ReadGenericProjectType (string file)
{
using (XmlTextReader tr = new XmlTextReader (file)) {
tr.MoveToContent ();
if (tr.LocalName != "Project")
return null;
if (tr.IsEmptyElement)
return null;
tr.ReadStartElement ();
tr.MoveToContent ();
if (tr.LocalName != "PropertyGroup")
return null;
if (tr.IsEmptyElement)
return null;
tr.ReadStartElement ();
tr.MoveToContent ();
while (tr.NodeType != XmlNodeType.EndElement) {
if (tr.NodeType == XmlNodeType.Element && !tr.IsEmptyElement && tr.LocalName == "ItemType")
return tr.ReadElementString ();
tr.Skip ();
}
return null;
}
}
/// <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;
}
public TemplateInfo[] ReadTemplates()
{
ArrayList result = new ArrayList();
if(Directory.Exists(_templateFolder))
{
foreach(string dir in Directory.GetDirectories(_templateFolder))
{
string templateFile = Path.Combine(dir, "template.xml");
if( File.Exists(templateFile ) )
{
XmlTextReader reader = new XmlTextReader(templateFile);
try
{
reader.Read();
reader.ReadStartElement("Template");
reader.ReadStartElement("TemplateData");
reader.ReadStartElement("Name");
string name = reader.ReadString();
DirectoryInfo directoryInfo = new DirectoryInfo(dir);
TemplateInfo templateInfo = new TemplateInfo(name, directoryInfo.Name );
result.Add(templateInfo);
}
finally
{
reader.Close();
}
}
}
}
return (TemplateInfo[])result.ToArray(typeof(TemplateInfo));
}
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));
}
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;
}