public void ReadXml(XmlReader reader)
{
reader.ReadStartElement(); //wrapping element
this.name = reader.ReadElementContentAsString();
this.extension = reader.ReadElementContentAsString();
string tempFileName = Path.GetTempFileName();
this.streamFileName = tempFileName;
using (FileStream fs = File.Create(tempFileName))
{
byte[] buffer = new byte[1000];
int bytesRead;
reader.ReadStartElement();
do
{
bytesRead = reader.ReadContentAsBase64(buffer, 0, buffer.Length);
fs.Write(buffer, 0, bytesRead);
} while (bytesRead > 0);
reader.ReadEndElement();
}
reader.ReadEndElement(); //wrapping element
}
void IXmlSerializable.ReadXml(XmlReader r)
{
r.MoveToContent();
r.ReadStartElement("Employee");
r.ReadStartElement("Name");
FirstName = r.ReadElementString("First", ns);
LastName = r.ReadElementString("Last", ns);
r.ReadEndElement();
r.MoveToContent();
ID = Int32.Parse(r.ReadElementString("ID", ns));
r.ReadEndElement();
}
public override object ReadObject(XmlReader reader)
{
ArrayOfLoanStateCompositeType ArrayOfLoanStateCompositeTypeField = null;
if (IsParentStartElement(reader, false, true))
{
ArrayOfLoanStateCompositeTypeField = new ArrayOfLoanStateCompositeType();
reader.Read();
LoanStateCompositeTypeDataContractSerializer LoanStateCompositeTypeDCS = new LoanStateCompositeTypeDataContractSerializer("LoanStateCompositeType", "http://schemas.datacontract.org/2004/07/", "http://schemas.datacontract.org/2004/07/");
System.Collections.ArrayList LoanStateCompositeType_List = new System.Collections.ArrayList();
for (int i = 0; (i > -1); i = (i + 1))
{
if (!IsChildStartElement(reader, "LoanStateCompositeType", false, false))
{
ArrayOfLoanStateCompositeTypeField.LoanStateCompositeType = new LoanStateCompositeType[LoanStateCompositeType_List.Count];
LoanStateCompositeType_List.CopyTo(ArrayOfLoanStateCompositeTypeField.LoanStateCompositeType);
break;
}
LoanStateCompositeType_List.Add(((LoanStateCompositeType)(LoanStateCompositeTypeDCS.ReadObject(reader))));
}
reader.ReadEndElement();
}
return ArrayOfLoanStateCompositeTypeField;
}
private Workspace ReadWorkspace(XmlReader reader, ServiceDocument document)
{
Workspace result = CreateWorkspace(document);
result.BaseUri = document.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, Version))
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", preserveAttributeExtensions: true);
}
else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace))
{
result.Collections.Add(ReadCollection(reader, result));
}
else if (!TryParseElement(reader, result, Version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
return(result);
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public void ReadXml(XmlReader reader)
{
/* The position class uses the GML 3.0 specification for XML.
*
* <gml:pos>X Y Z</gml:pos>
*
* ... but it is also helpful to be able to READ older versions
* of GML, such as this one for GML 2.0:
*
* <gml:coord>
* <gml:X>double</gml:X>
* <gml:Y>double</gml:Y> // optional
* <gml:Z>double</gml:Z> // optional
* </gml:coord>
*
*/
// .NET whines if we don't fully assign all values
_x = Distance.Empty;
_y = Distance.Empty;
_z = Distance.Empty;
// Move to the <gml:pos> or <gml:coord> element
if (!reader.IsStartElement("pos", Xml.GML_XML_NAMESPACE) &&
!reader.IsStartElement("coord", Xml.GML_XML_NAMESPACE))
{
reader.ReadStartElement();
}
switch (reader.LocalName.ToLower(CultureInfo.InvariantCulture))
{
case "pos":
// Read the "X Y" string, then split by the space between them
string[] values = reader.ReadElementContentAsString().Split(' ');
// Deserialize the X
_x = Distance.FromMeters(double.Parse(values[0], CultureInfo.InvariantCulture));
// Deserialize the Y
if (values.Length >= 2)
{
_y = Distance.FromMeters(double.Parse(values[1], CultureInfo.InvariantCulture));
}
// Deserialize the Z
if (values.Length == 3)
{
_z = Distance.FromMeters(double.Parse(values[2], CultureInfo.InvariantCulture));
}
break;
case "coord":
// Read the <gml:coord> start tag
reader.ReadStartElement();
// Now read up to 3 elements: X, and optionally Y or Z
for (int index = 0; index < 3; index++)
{
switch (reader.LocalName.ToLower(CultureInfo.InvariantCulture))
{
case "x":
// Read X as meters (there's no unit type in the spec :P morons)
_x = Distance.FromMeters(reader.ReadElementContentAsDouble());
break;
case "y":
// Read Y as meters (there's no unit type in the spec :P morons)
_y = Distance.FromMeters(reader.ReadElementContentAsDouble());
break;
case "z":
// Read Z as meters (there's no unit type in the spec :P morons)
_z = Distance.FromMeters(reader.ReadElementContentAsDouble());
break;
}
// If we're at an end element, stop
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
// Read the </gml:coord> end tag
reader.ReadEndElement();
break;
}
reader.Read();
}
void LoadGlyph()
{
glyphList = new List <Glyph>();
// load font config file
using (Stream stream = new MemoryStream(xmlFile.bytes))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
using (XmlReader reader = XmlReader.Create(stream, settings))
{
reader.MoveToContent();
reader.ReadStartElement("fontconfig");
{
// typeface
if (reader.Name == "font")
{
lineHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// texture info
if (reader.Name == "texture")
{
textureWidth = int.Parse(reader.GetAttribute("width"));
textureHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// texture info
reader.ReadToFollowing("size");
if (reader.Name == "size")
{
glyphWidth = int.Parse(reader.GetAttribute("width"));
glyphHeight = int.Parse(reader.GetAttribute("height"));
// move to next
reader.Read();
}
// images
reader.ReadToFollowing("images");
if (!reader.IsEmptyElement)
{
List <string> images = new List <string>();
reader.ReadStartElement("images");
if (reader.Name == "image")
{
do
{
string imagePath = reader.GetAttribute("path");
images.Add(imagePath);
}while (reader.ReadToNextSibling("image"));
}
reader.ReadEndElement();
if (images.Count > 0)
{
// only handle one texture
texturePath = images[0];
}
else
{
Debug.LogError("image path missing");
return;
}
}
else
{
reader.Read();
}
// glyph
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("glyphs");
if (reader.Name == "glyph")
{
do
{
char character = char.Parse(reader.GetAttribute("char"));
int pageIndex = int.Parse(reader.GetAttribute("page"));
int x = int.Parse(reader.GetAttribute("x"));
int y = int.Parse(reader.GetAttribute("y"));
int w = int.Parse(reader.GetAttribute("w"));
int h = int.Parse(reader.GetAttribute("h"));
int ix = int.Parse(reader.GetAttribute("ix"));
int iy = int.Parse(reader.GetAttribute("iy"));
int iw = int.Parse(reader.GetAttribute("iw"));
int ih = int.Parse(reader.GetAttribute("ih"));
Glyph glyph = new Glyph();
glyph.code = character;
glyph.bound = new Rect(x, y, w, h);
glyph.interiorBound = new Rect(ix, iy, iw, ih);
glyph.baseline = int.Parse(reader.GetAttribute("baseline"));
glyph.spacingA = int.Parse(reader.GetAttribute("spacingA"));
glyph.spacingB = int.Parse(reader.GetAttribute("spacingB"));
glyph.spacingC = int.Parse(reader.GetAttribute("spacingC"));
baseline = glyph.baseline;
glyphList.Add(glyph);
}while (reader.ReadToNextSibling("glyph"));
}
reader.ReadEndElement();
}
else
{
reader.Read();
}
}
reader.ReadEndElement();
}
}
}
/// <summary>
/// Updates an existing <see cref="NameValueCollection" /> object from
/// its XML representation.
/// </summary>
private static void UpcodeTo(XmlReader reader, NameValueCollection collection)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (collection == null)
{
throw new ArgumentNullException("collection");
}
Debug.Assert(!reader.IsEmptyElement);
reader.Read();
//
// Add entries into the collection as <item> elements
// with child <value> elements are found.
//
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("item"))
{
var name = reader.GetAttribute("name");
var isNull = reader.IsEmptyElement;
reader.Read(); // <item>
if (!isNull)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("value")) // <value ...>
{
var value = reader.GetAttribute("string");
collection.Add(name, value);
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement(); // </item>
}
else
{
collection.Add(name, null);
}
}
else
{
reader.Skip();
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
public virtual void ReadXml(XmlReader reader)
{
XmlSerializer timersCyclesSerializer = new XmlSerializer(typeof(TimerLoopSerializableSortedDictionary));
try {
// Читает текущий элемент с заданным именем и смещает указатель к следующему элементу
// иначе бросает исключение
reader.ReadStartElement("PresetCollection");
if (reader.IsEmptyElement)
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
Preset preset = new Preset();
// <Preset name=_ >
preset.PresetName = reader.GetAttribute("name");
reader.Read();
// <StartTime> (ReadElementContentAs... - читает и перекидывает на следующий элемент)
preset.StartTime = TimeSpan.Parse(reader.ReadElementContentAsString());
// </StartrTime>
// <InfiniteLoop> (Boolean - это "0", либо "1")
if (reader.ReadElementContentAsBoolean())
{
preset.SetInfiniteLoop();
}
// </InfiniteLoop>
// <Tag>
if (!reader.IsEmptyElement)
{
preset.Tag = reader.ReadElementContentAsString();
}
else
{
reader.Read();
}
// </Tag
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("TimePointCollection");
var timePoints = new List <TimePoint>();
// <TimePointCollection>
while (reader.NodeType != XmlNodeType.EndElement)
{
TimePoint tp = new TimePoint();
tp.Name = reader.GetAttribute("name");
reader.Read();
tp.Time = TimeSpan.Parse(reader.ReadElementContentAsString());
tp.ChangeTimePointType((TimePointKinds)(reader.ReadElementContentAsInt()));
tp.LoopNumber = (byte)(reader.ReadElementContentAsInt());
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
tp.Tag = reader.ReadElementContentAsString();
}
reader.ReadEndElement();
timePoints.Add(tp);
}
// </TimePointCollection>
reader.ReadEndElement();
preset.AddTimePoints(timePoints);
}
else
{
reader.Read();
}
// <TimerLoopDictionary>
if (!reader.IsEmptyElement)
{
preset.TimerLoopDictionary = (TimerLoopSerializableSortedDictionary)timersCyclesSerializer.Deserialize(reader);
}
else
{
reader.Read();
}
// </TimerLoopDictionary>
// </Preset>
reader.ReadEndElement();
this.Add(preset);
}
// </PresetCollection>
reader.ReadEndElement();
}
catch {
this.Clear();
//throw;
}
}
/// <summary>
/// Deserializes the current BusinessObject from a XML stream.
/// </summary>
/// <param name="r">Active XML stream reader.</param>
/// <remarks>Reads the outer element. Leaves the reader at the same depth.</remarks>
public virtual void ReadXml(XmlReader r)
{
var isEmpty = r.IsEmptyElement;
ReadAndHandleXmlStartElement(r);
if (isEmpty)
{
return;
}
var properties = GetAllDataProperties().ToList();
while (r.NodeType == XmlNodeType.Element)
{
var property = properties
.FirstOrDefault(prop =>
prop
.GetCustomAttributes(typeof(XmlElementAttribute), false)
.Any(ca => ((XmlElementAttribute)ca).ElementName == r.Name));
if (property == null)
{
property = properties.FirstOrDefault(n => n.Name.Equals(r.Name));
}
if (property == null)
{
r.Skip();
continue;
}
var type = property.PropertyType;
var value = property.GetValue(this, null);
if (type.IsSubclassOfBusinessObject())
{
((BaseClassSerializable)value).ReadXml(r);
continue;
}
// if property type is List<T>, try to fetch the list from XML.
if (type.IsGenericList())
{
ReadXmlList(value, type, r.Name, r);
continue;
}
// ReadElementContentAs won't accept a nullable type.
if (type == typeof(DateTime?))
{
type = typeof(DateTime);
}
if (type == typeof(decimal?))
{
type = typeof(decimal);
}
if (type == typeof(int?))
{
type = typeof(int);
}
property.SetValue(this, r.ReadElementContentAs(type, null), null);
}
if (r.NodeType == XmlNodeType.Text)
{
r.Skip();
}
r.ReadEndElement();
}
/// <summary>
/// Load an instance using the specified reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override void Load (XmlReader reader)
{
reader.ReadToFollowing ("Wizard");
base.Load (reader);
reader.ReadEndElement ();
}
private void ReadDocument(XmlReader reader)
{
ServiceDocument result = CreateDocumentInstance();
try
{
SyndicationFeedFormatter.MoveToStartElement(reader);
bool elementIsEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.Language = reader.Value;
}
else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, Version))
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
if (!elementIsEmpty)
{
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(App10Constants.Workspace, App10Constants.Namespace))
{
result.Workspaces.Add(ReadWorkspace(reader, result));
}
else if (!TryParseElement(reader, result, Version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
extWriter?.Close();
}
}
reader.ReadEndElement();
}
catch (FormatException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
catch (ArgumentException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
SetDocument(result);
}
public static void ReadObject(XmlReader reader, object obj, PropertyConversionHandler handler = null)
{
if (obj == null)
throw new ArgumentNullException("obj");
reader.MoveToContent();
if (obj is IXmlSerializable)
{
((IXmlSerializable)obj).ReadXml(reader);
}
else
{
object oVal = null;
string oName = GetAttributeValue(obj.GetType(), typeof(XmlRootAttribute), "ElementName", true, ref oVal) ? oVal.ToString() : obj.GetType().Name;
if (reader.LocalName != oName)
throw new XmlException("XML element name does not match object.");
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
reader.MoveToContent();
ReadObjectProperties(reader, obj, handler);
reader.ReadEndElement();
}
else
reader.Skip();
}
}
private ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace)
{
ResourceCollectionInfo result = CreateCollection(workspace);
result.BaseUri = workspace.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, Version))
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", preserveAttributeExtensions: true);
}
else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
{
result.Categories.Add(ReadCategories(reader,
result.BaseUri,
() => CreateInlineCategories(result),
() => CreateReferencedCategories(result),
Version,
_maxExtensionSize));
}
else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
{
result.Accepts.Add(reader.ReadElementString());
}
else if (!TryParseElement(reader, result, Version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
return(result);
}
private static void ReadReferencedCategories(XmlReader reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, int maxExtensionSize)
{
referencedCategories.BaseUri = baseUri;
referencedCategories.Link = link;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value);
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.Language = reader.Value;
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
continue;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, referencedCategories, version))
{
referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
reader.MoveToElement();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (!TryParseElement(reader, referencedCategories, version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, referencedCategories);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
}
}
private static void ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, int maxExtensionSize)
{
inlineCategories.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.Language = reader.Value;
}
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
{
inlineCategories.IsFixed = (reader.Value == "yes");
}
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
{
inlineCategories.Scheme = reader.Value;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, inlineCategories, version))
{
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
}
}
}
SyndicationFeedFormatter.MoveToStartElement(reader);
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions: true, preserveElementExtensions: true, maxExtensionSize);
category.Scheme ??= inlineCategories.Scheme;
inlineCategories.Categories.Add(category);
}
else if (!TryParseElement(reader, inlineCategories, version))
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, inlineCategories);
}
finally
{
extWriter?.Close();
}
reader.ReadEndElement();
}
}
/// <summary>
/// Creates an instance of a DpwsMetadata class.
/// </summary>
public DpwsMetadata(XmlReader reader)
{
reader.ReadStartElement("Metadata", WsWellKnownUri.WsxNamespaceUri);
while (reader.IsStartElement("MetadataSection", WsWellKnownUri.WsxNamespaceUri))
{
reader.MoveToAttribute("Dialect");
String dialect = reader.Value;
reader.MoveToElement();
reader.Read(); // MetadataSection
if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisModel")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisModel = new DpwsThisModel(reader);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisDevice")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisDevice = new DpwsThisDevice(reader);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/Relationship")
{
#if DEBUG
int depth = reader.Depth;
#endif
if (this.Relationship == null)
{
this.Relationship = new DpwsRelationship(reader);
}
else
{
this.Relationship.Append(reader);
}
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else // known dialect
{
reader.Skip();
}
reader.ReadEndElement(); // MetadataSection
}
if (this.ThisModel == null || this.ThisDevice == null || this.Relationship == null)
{
// Metadata must include ThisModel (R2038, R2012), ThisDevice(R2039, R2014),
// at least one Relationship(R2040, R2029)
throw new XmlException();
}
XmlReaderHelper.SkipAllSiblings(reader); // xs:any
reader.ReadEndElement(); // Metadata
}
/// <summary>
/// Loads the status.
/// </summary>
/// <param name="reader">Reader.</param>
protected override void LoadStatus (XmlReader reader)
{
base.LoadStatus (reader);
reader.ReadToNextSibling ("Mana");
mana.value = reader.ReadElementContentAsFloat ();
Debug.Log("Found Exp field: " + reader.ReadToNextSibling ("Exp"));
Debug.Log("Found level field: " + reader.ReadToNextSibling ("Level"));
GetComponent<Inventory> ().LoadInventory (reader);
reader.ReadEndElement ();
}
public override object ReadObject(XmlReader reader)
{
LoanCompositeType LoanCompositeTypeField = null;
if (IsParentStartElement(reader, false, true))
{
LoanCompositeTypeField = new LoanCompositeType();
reader.Read();
if (IsChildStartElement(reader, "BookID", false, false))
{
reader.Read();
LoanCompositeTypeField.BookID = XmlConvert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "DeliveryDate", true, false))
{
reader.Read();
//LoanCompositeTypeField.DeliveryDate = XmlConvert.ToDateTime(reader.ReadString());
LoanCompositeTypeField.DeliveryDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "ExpirationDate", false, false))
{
reader.Read();
//LoanCompositeTypeField.ExpirationDate = XmlConvert.ToDateTime(reader.ReadString());
LoanCompositeTypeField.ExpirationDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "StartDate", false, false))
{
reader.Read();
//LoanCompositeTypeField.StartDate = XmlConvert.ToDateTime(reader.ReadString());
LoanCompositeTypeField.StartDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "UserID", false, false))
{
reader.Read();
LoanCompositeTypeField.UserID = XmlConvert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
reader.ReadEndElement();
}
return LoanCompositeTypeField;
}
private void ReadNode(XmlReader reader, CremaDataRow parentRow)
{
var dataTable = this.GetTable(reader, parentRow);
var dataRow = dataTable.NewRow();
var relationXmls = new List <string>();
// <a /> 는 기본값을 의미하고
// 태그 조차도 없는것은 null값을 의미 하기 때문
// <a /> 처럼 기본값이 있는 태그가 존재하면 read할때 한번 호출이 되기 때문에 그때 기본값을 입력하고 지금은 다 초기화 시킴
// 3.5에서는 이부분을 수정했지만 이하 버전에서는 구분이 되어 있지 않았음.
if (this.version.Major >= CremaSchema.MajorVersion && this.version.Minor >= CremaSchema.MinorVersion)
{
foreach (var item in dataTable.Columns)
{
if (item.AllowDBNull == true && object.Equals(item.DefaultValue, DBNull.Value) == false)
{
dataRow[item] = DBNull.Value;
}
}
}
this.ReadNodeAttributes(reader, dataTable, dataRow);
reader.MoveToContent();
if (reader.IsEmptyElement == false)
{
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType == XmlNodeType.Element)
{
var dataColumn = dataTable.Columns[reader.Name];
if (dataColumn != null)
{
this.ReadValue(reader, dataRow, dataColumn);
}
else if (dataTable.Childs.Contains(reader.Name) == true)
{
if (dataRow.RowState == DataRowState.Detached)
{
this.OnRowInsertAction(dataTable, dataRow);
}
this.ReadNode(reader, dataRow);
reader.MoveToContent();
}
else
{
reader.Skip();
reader.MoveToContent();
}
}
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
reader.Skip();
}
reader.MoveToContent();
if (parentRow != null)
{
dataRow.ParentID = parentRow.RelationID;
}
if (dataRow.RowState == DataRowState.Detached)
{
this.OnRowInsertAction(dataTable, dataRow);
}
}
public override object ReadObject(XmlReader reader)
{
ArrayOfstring ArrayOfstringField = null;
if (IsParentStartElement(reader, false, true))
{
ArrayOfstringField = new ArrayOfstring();
reader.Read();
System.Collections.ArrayList string_List = new System.Collections.ArrayList();
for (int i = 0; (i > -1); i = (i + 1))
{
if (!IsChildStartElement(reader, "string", false, false))
{
ArrayOfstringField.STRING = new string[string_List.Count];
string_List.CopyTo(ArrayOfstringField.STRING);
break;
}
string_List.Add(ReadString(reader));
}
reader.ReadEndElement();
}
return ArrayOfstringField;
}
internal static void ThrowFaultException(XmlReader reader, WsWsaHeader header)
{
WsFaultType type = WsFaultType.Exception;
string message = "";
string detail = "";
string subcode;
reader.ReadStartElement("Body", WsWellKnownUri.SoapNamespaceUri);
reader.ReadStartElement("Fault", WsWellKnownUri.SoapNamespaceUri);
while (true)
{
if (reader.IsStartElement("Code", WsWellKnownUri.SoapNamespaceUri))
{
reader.ReadStartElement(); //<Code>
if (reader.IsStartElement("Value", WsWellKnownUri.SoapNamespaceUri))
{
reader.ReadElementString();
}
if (reader.IsStartElement("Subcode", WsWellKnownUri.SoapNamespaceUri))
{
reader.ReadStartElement();
subcode = reader.ReadElementString("Value", WsWellKnownUri.SoapNamespaceUri);
int idx = subcode.IndexOf(':');
if (idx != -1)
{
subcode = subcode.Substring(idx + 1);
}
switch (subcode)
{
case "ArgumentException":
type = WsFaultType.ArgumentException;
break;
case "ArgumentNullException":
type = WsFaultType.ArgumentNullException;
break;
case "Exception":
type = WsFaultType.Exception;
break;
case "InvalidOperationException":
type = WsFaultType.InvalidOperationException;
break;
case "XmlException":
type = WsFaultType.XmlException;
break;
case "InvalidMessageInformationHeader":
type = WsFaultType.WsaInvalidMessageInformationHeader;
break;
case "MessageInformationHeaderRequired":
type = WsFaultType.WsaMessageInformationHeaderRequired;
break;
case "DestinationUnreachable":
type = WsFaultType.WsaDestinationUnreachable;
break;
case "ActionNotSupported":
type = WsFaultType.WsaActionNotSupported;
break;
case "EndpointUnavailable":
type = WsFaultType.WsaEndpointUnavailable;
break;
case "DeliverModeRequestedUnavailable":
type = WsFaultType.WseDeliverModeRequestedUnavailable;
break;
case "InvalidExpirationTime":
type = WsFaultType.WseInvalidExpirationTime;
break;
case "UnsupportedExpirationType":
type = WsFaultType.WseUnsupportedExpirationType;
break;
case "FilteringNotSupported":
type = WsFaultType.WseFilteringNotSupported;
break;
case "FilteringRequestedUnavailable":
type = WsFaultType.WseFilteringRequestedUnavailable;
break;
case "EventSourceUnableToProcess":
type = WsFaultType.WseEventSourceUnableToProcess;
break;
case "UnableToRenew":
type = WsFaultType.WseUnableToRenew;
break;
case "InvalidMessage":
type = WsFaultType.WseInvalidMessage;
break;
}
reader.ReadEndElement();
}
reader.ReadEndElement(); // </Code>
}
if (reader.IsStartElement("Reason", WsWellKnownUri.SoapNamespaceUri))
{
reader.ReadStartElement();
message = reader.ReadElementString("Text", WsWellKnownUri.SoapNamespaceUri);
reader.ReadEndElement();
}
if (reader.IsStartElement("Detail", WsWellKnownUri.SoapNamespaceUri))
{
detail = reader.ReadElementString("Detail", WsWellKnownUri.SoapNamespaceUri);
}
if (!reader.IsStartElement())
{
break;
}
}
reader.ReadEndElement(); // </Fault>
reader.ReadEndElement(); // </Body>
throw new WsFaultException(header, type, message, detail);
}
public override void ReadEndElement()
{
this.IsCalled = true; _wrappedreader.ReadEndElement();
}
public MFTestResults SPOTXml_XmlReader_MethodsTest3()
{
/// <summary>
/// Tests all of the XmlReader methods in SPOT.Xml
/// </summary>
///
bool testResult = true;
try
{
Log.Comment("Creating XmlReader with Stream");
XmlReader testReader = XmlReader.Create(new TestStream());
Log.Comment("Close");
testReader.Close();
if (testReader.ReadState != ReadState.Closed)
{
testResult = false;
Log.Exception("Close did not function properly");
}
testReader = XmlReader.Create(new TestStream());
Log.Comment("GetAttribute");
try
{
if ("" == testReader.GetAttribute(0))
{
testResult = false;
Log.Exception("GetAttribute succeeded with 0 attributes");
}
}
catch (ArgumentOutOfRangeException e) {
Log.Exception("ArgumentOutOfRangeException caught in SPOTXml_XmlReader_MethodsTest3::GetAttribute(0): ", e);
}
// Add Additional tests for the overloaded GetAttribute
// public abstract string GetAttribute(string name);
// public abstract string GetAttribute(string name, string namespaceURI);
Log.Comment("IsStartElement");
if (!testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned false before read");
}
testReader.Read();
if (!testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned false after read to 1st elt");
}
testReader.Read();
testReader.Read();
if (testReader.IsStartElement())
{
testResult = false;
Log.Exception("IsStartElement returned true after read to an end elt");
}
testReader = XmlReader.Create(new TestStream());
if (!testReader.IsStartElement("root"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned false for root");
}
if (testReader.IsStartElement("TestElement1"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned true for TestElement1");
}
if (testReader.IsStartElement("FakeData"))
{
testResult = false;
Log.Exception("IsStartElement(string) returned true for FakeData");
}
testReader = XmlReader.Create(new TestStream());
if (!testReader.IsStartElement("root", ""))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned false for root, namespace");
}
if (testReader.IsStartElement("root", "FakeNamespaceURI"))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned true for root, FakeNamespaceURI");
}
if (testReader.IsStartElement("TestElement1", ""))
{
testResult = false;
Log.Exception("IsStartElement(string,string) returned true for TestElement1");
}
testReader = XmlReader.Create(new TestStream());
if (testReader.LookupNamespace("XT") != null)
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data");
}
testResult &= testReader.Read();
if (testReader.LookupNamespace("XT") != "TestNS")
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data after read");
}
if (testReader.LookupNamespace("") != "")
{
testResult = false;
Log.Exception("LookupNamespace returned incorrect data for bad arg after read");
}
testReader = XmlReader.Create(new TestStream());
Log.Comment("MoveToX methods");
testReader.MoveToContent();
if (testReader.Name != "root")
{
testResult = false;
Log.Exception("MoveToContent went to wrong node");
}
testReader.MoveToElement();
if (testReader.Name != "root")
{
testResult = false;
Log.Exception("MoveToElementwent to wrong node");
}
testResult &= testReader.MoveToFirstAttribute();
if (testReader.Name != "xmlns:XT")
{
testResult = false;
Log.Exception("MoveToFirstAttribute went to wrong node");
}
testResult &= testReader.MoveToNextAttribute();
if (testReader.Name != "XT:TestLocalName")
{
testResult = false;
Log.Exception("MoveToFirstAttribute went to wrong node");
}
Log.Comment("ReadElementString");
testReader = XmlReader.Create(new TestStream());
//TODO: Exception testing here under investigation
//testReader.ReadElementString();
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString() != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString() != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadString() != "")
{
testResult = false;
Log.Exception("ReadString returned bad data for empty node");
}
testReader.Read();
testReader.Read();
if (testReader.ReadString() != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString("ChildOfTestElement1") != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString("TestElement2") != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Read();
if (testReader.ReadElementString("ChildOfTestElement1", "") != "")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for empty node");
}
testReader.Read();
if (testReader.ReadElementString("TestElement2", "") != "TestElement2Data")
{
testResult = false;
Log.Exception("ReadElementString returned bad data for full node");
}
testReader = XmlReader.Create(new TestStream());
//Add tests for overloaded ReadStartElement
// public virtual void ReadStartElement(string name);
// public virtual void ReadStartElement(string localname, string ns);
testReader.ReadStartElement();
if (testReader.Name != "TestElement1")
{
testResult = false;
Log.Exception("ReadStartElement failed on start element");
}
try
{
testReader.ReadEndElement();
testResult = false;
Log.Comment("FAILURE - ReadEndElement succeded on Start element ");
}
catch (XmlException e) {
Log.Exception("XMLException - ReadEndElement succeeded on Start element ", e);
}
testReader.Read();
testReader.Read();
testReader.ReadEndElement();
if (testReader.Name != "TestElement2")
{
testResult = false;
Log.Exception("ReadEndElement failed on end element");
}
testReader.Read();
try
{
testReader.ReadStartElement();
testResult = false;
Log.Comment("FAILURE - ReadStartElement succeeded on end element ");
}
catch (XmlException e) {
Log.Exception("ReadStartElement failed on end element", e);
}
testReader = XmlReader.Create(new TestStream());
//Add tests for the overloaded ReadToDescendant
// public virtual bool ReadToDescendant(string localName, string namespaceURI);
testReader.ReadToDescendant("ChildOfTestElement1");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToDescendant read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
// public virtual bool ReadToDescendant(string Name)
// passing in empty string.
try
{
testReader.ReadToDescendant("");
}
catch (ArgumentException e)
{
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant read to a location erroneously ", e);
}
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement2");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement1", "");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToDescendant with namesapce read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToDescendant("ChildOfTestElement2", "");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToDescendant with namesapce read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
//Add tests for the overloaded ReadToDescendant
// public virtual bool ReadToFollowing(string localName, string namespaceURI);
testReader.ReadToFollowing("ChildOfTestElement1");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToFollowing read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement2");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToFollowing read to a location erroneously");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement1", "");
if (testReader.Name != "ChildOfTestElement1")
{
testResult = false;
Log.Exception("ReadToFollowing with namesapce read to wrong location");
}
testReader = XmlReader.Create(new TestStream());
testReader.ReadToFollowing("ChildOfTestElement2", "");
if (testReader.Name != "")
{
testResult = false;
Log.Exception("ReadToFollowing with namesapce read to a location erroneously");
}
Log.Comment("ReadToNextSibling method");
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
if (!testReader.ReadToNextSibling("TestElement2"))
{
testResult = false;
Log.Exception("ReadToNextSibling return false for TestElement2");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
if (testReader.ReadToNextSibling("TestElement1", ""))
{
testResult = false;
Log.Exception("Bug 57189: ReadToNextSibling return true for TestElement1");
}
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
if (!testReader.ReadToNextSibling("TestElement2", ""))
{
testResult = false;
Log.Exception("ReadToNextSibling return false for TestElement2");
}
Log.Comment("Skip");
testReader = XmlReader.Create(new TestStream());
testReader.Read();
testReader.Read();
testReader.Skip();
if (testReader.Name != "TestElement2")
{
testResult = false;
Log.Exception("Skip failed to advance to correct node");
}
}
catch (Exception e)
{
testResult = false;
Log.Exception("Incorrect exception caught: ", e);
}
return(testResult ? MFTestResults.Pass : MFTestResults.Fail);
}
protected override void OnReadXml(XmlReader aXmlReader, SepaMessageInfo aMessageInfo)
{
string str2;
if (aMessageInfo.MessageType != SepaMessageType.DirectDebitPaymentInitiation)
{
throw new ArgumentException();
}
base.ReadPmtIdXml(aXmlReader);
base.ReadInstdAmtXml(aXmlReader);
if (aXmlReader.IsStartElement("ChrgBr"))
{
aXmlReader.Skip();
}
aXmlReader.ReadStartElement("DrctDbtTx");
aXmlReader.ReadStartElement("MndtRltdInf");
this.m_sMndtId = aXmlReader.ReadElementString("MndtId");
this.m_dtMndtDtOfSgntr = SepaUtil.ReadDtXml(aXmlReader, "DtOfSgntr");
bool flag = false;
if (aXmlReader.IsStartElement("AmdmntInd"))
{
flag = XmlConvert.ToBoolean(aXmlReader.ReadElementString());
}
if (flag)
{
aXmlReader.ReadStartElement("AmdmntInfDtls");
if (aXmlReader.IsStartElement("OrgnlMndtId"))
{
this.m_sOrgnlMndtId = aXmlReader.ReadElementString();
}
if (aXmlReader.IsStartElement("OrgnlCdtrSchmeId"))
{
aXmlReader.ReadStartElement();
if (aXmlReader.IsStartElement("Nm"))
{
this.m_sOrgnlCdtrNm = aXmlReader.ReadElementString();
}
if (aXmlReader.IsStartElement("Id"))
{
this.m_sOrgnlCdtrSchmeId = SepaUtil.ReadSepaIdXml(aXmlReader);
}
aXmlReader.ReadEndElement();
}
if (aXmlReader.IsStartElement("OrgnlDbtrAcct"))
{
string str;
this.m_tOrgnlDbtrAcctIBAN = SepaUtil.ReadAcctXml(aXmlReader, "OrgnlDbtrAcct", out str);
}
if (aXmlReader.IsStartElement("OrgnlDbtrAgt"))
{
aXmlReader.Skip();
this.m_fSMNDA = true;
}
aXmlReader.ReadEndElement();
}
if (aXmlReader.IsStartElement("ElctrncSgntr"))
{
aXmlReader.Skip();
}
aXmlReader.ReadEndElement();
if (aXmlReader.IsStartElement("CdtrSchmeId"))
{
this.m_sCdtrSchmeIdRead = SepaUtil.ReadCdtrSchmeIdXml(aXmlReader);
}
aXmlReader.ReadEndElement();
if (aXmlReader.IsStartElement("UltmtCdtr"))
{
aXmlReader.Skip();
}
this.m_tDbtrAgtBIC = SepaUtil.ReadAgtBIC(aXmlReader, "DbtrAgt");
this.m_aDbtr.ReadXml(aXmlReader, aMessageInfo);
this.m_tDbtrAcctIBAN = SepaUtil.ReadAcctXml(aXmlReader, "DbtrAcct", out str2);
if (aXmlReader.IsStartElement("UltmtDbtr"))
{
this.m_aUltmtDbtr.ReadXml(aXmlReader, aMessageInfo);
}
base.ReadPurpXml(aXmlReader);
base.ReadRmtInfXml(aXmlReader);
}
public override void ReadXml(XmlReader reader)
{
if (CheckEmptyNode(reader, "Capability", string.Empty))
{
throw WmsParsingException.ElementNotFound("Capability");
}
bool baseLayerCreated = false;
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Request":
_requestField = new Request();
_requestField.ReadXml(reader.ReadSubtree());
break;
case "Exception":
if (_exceptionField == null)
{
_exceptionField = new List <string>();
}
var subReader = reader.ReadSubtree();
while (!subReader.EOF)
{
reader.ReadStartElement("Format");
var format = reader.ReadContentAsString();
reader.ReadEndElement();
_exceptionField.Add(format);
}
break;
case "Layer":
if (_layerField == null)
{
_layerField = new Layer();
_layerField.ReadXml(reader);
}
else
{
if (!baseLayerCreated)
{
var tmp = _layerField;
_layerField = new Layer();
_layerField.Name = _layerField.Title = "Created base layer";
_layerField.ChildLayers.Add(tmp);
baseLayerCreated = true;
}
var layer = new Layer();
layer.ReadXml(reader);
_layerField.ChildLayers.Add(layer);
}
break;
default:
ExtendedCapabilities.Add(XName.Get(reader.LocalName, reader.NamespaceURI), XNode.ReadFrom(reader));
break;
}
}
else
{
reader.Read();
}
}
}
public void ReadXml(XmlReader xmlReader, PointF scale, TimestampMapper timestampMapper)
{
// The tool id must be read before the point list.
if (xmlReader.MoveToAttribute("id"))
{
identifier = new Guid(xmlReader.ReadContentAsString());
}
if (xmlReader.MoveToAttribute("name"))
{
name = xmlReader.ReadContentAsString();
}
xmlReader.ReadStartElement();
while (xmlReader.NodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "ToolId":
toolId = new Guid(xmlReader.ReadElementContentAsString());
genericPosture = GenericPostureManager.Instanciate(toolId, true);
break;
case "Positions":
if (genericPosture != null)
{
ParsePointList(xmlReader, scale);
}
else
{
xmlReader.ReadOuterXml();
}
break;
case "DrawingStyle":
style = new DrawingStyle(xmlReader);
BindStyle();
break;
case "InfosFading":
infosFading.ReadXml(xmlReader);
break;
default:
string unparsed = xmlReader.ReadOuterXml();
log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
break;
}
}
xmlReader.ReadEndElement();
SignalAllTrackablePointsMoved();
if (genericPosture != null)
{
InitOptionMenus();
}
else
{
genericPosture = new GenericPosture("", true, false);
}
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
XmlSerializer keySerializer = null;
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
Type keyType = typeof(TKey);
bool isFlatKey = (keyType.FullName == "System.String" || keyType.FullName == "System.Drawing.Point" || keyType.IsEnum);
if (!isFlatKey)
{
keySerializer = new XmlSerializer(typeof(TKey));
}
reader.Read();
while (reader.ReadToNextSibling(this.ItemNodeName))
{
TKey key;
TValue value;
if (isFlatKey)
{
if (keyType.FullName == "System.String")
{
key = (TKey)(object)reader.GetAttribute(this.KeyNodeName);
}
else if (keyType.FullName == "System.Drawing.Point")
{
key = (TKey)(object)PointEx.Parse(reader.GetAttribute(this.KeyNodeName));
}
else if (keyType.IsEnum)
{
string keyRaw = reader.GetAttribute(this.KeyNodeName);
if (keyRaw == null)
{
throw new FormatException(
$"The XML-Attribute \"{this.KeyNodeName}\" is missing on element \"{reader.Name}\"."
);
}
key = (TKey)Enum.Parse(keyType, keyRaw);
}
else
{
throw new InvalidOperationException();
}
reader.ReadStartElement(this.ItemNodeName);
value = (TValue)valueSerializer.Deserialize(reader);
}
else
{
reader.ReadStartElement(this.ItemNodeName);
reader.ReadStartElement(this.KeyNodeName);
key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(this.ValueNodeName);
value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
}
reader.ReadEndElement();
this.Add(key, value);
}
reader.ReadEndElement();
}
public static void ReadStringsFromStreamAsXml(string FileName, StreamReader sr, Hashtable Strings, AdvancedOptions adv_opt)
{
XmlReaderSettings xrs = new XmlReaderSettings();
//xrs.IgnoreWhitespace = true;
xrs.CloseInput = true;
XmlReader reader = XmlTextReader.Create(new StreamReader(FileName, System.Text.Encoding.UTF8), xrs);
try
{
reader.Read();
}
catch
{
System.Text.Encoding enc = sr.CurrentEncoding;
reader.Close();
sr.Close();
ReadStringsFromStream(new StreamReader(FileName, enc), Strings);
return;
}
//reader.ReadStartElement("options");
reader.ReadStartElement("general_options");
string prefix = "";
while (reader.ReadToNextSibling("option"))
{
string option_name = reader.GetAttribute("name");
string option_value = reader.ReadString();
if (option_name == "%PREFIX%")
{
prefix = option_value;
}
else
{
Strings[prefix + option_name] = option_value;
}
}
reader.ReadEndElement();
/*reader.ReadEndElement();
* if (!reader.EOF)
* {
* reader.ReadStartElement("advanced_options");
* if (!reader.IsEmptyElement)
* {
* reader.ReadStartElement("open_files");
* while (reader.ReadToNextSibling("open_file"))
* {
* adv_opt.open_files.Add(new SourceFileInfo(reader.GetAttribute("file_name"),
* Convert.ToInt32(reader.GetAttribute("line")),Convert.ToInt32(reader.GetAttribute("column"))));
*
* }
* reader.ReadEndElement();
* }
* else
* reader.ReadStartElement("open_files");
* reader.ReadStartElement("watch_list");
* if (!reader.IsEmptyElement)
* {
*
* while (reader.ReadToNextSibling("watch_expr"))
* {
* adv_opt.watch_list.Add(reader.GetAttribute("expr"));
* }
* reader.ReadEndElement();
* }
* reader.ReadStartElement("breakpoints_list");
* if (!reader.IsEmptyElement)
* {
*
* while (reader.ReadToNextSibling("breakpoint"))
* {
* adv_opt.breakpoints.Add(new BreakpointInfo(reader.GetAttribute("file_name"),
* Convert.ToInt32(reader.GetAttribute("line")),Convert.ToBoolean(reader.GetAttribute("is_conditional")),
* reader.GetAttribute("expression"),Convert.ToInt32(reader.GetAttribute("concrete_condition"))));
*
* }
* reader.ReadEndElement();
* }
* if (!reader.IsEmptyElement)
* {
* reader.ReadStartElement("bookmarks_list");
* while (reader.ReadToNextSibling("bookmark"))
* {
* adv_opt.bookmarks.Add(new BookmarkInfo(reader.GetAttribute("file_name"),
* Convert.ToInt32(reader.GetAttribute("line"))));
*
* }
* reader.ReadEndElement();
* }
* reader.ReadEndElement();
* }
* reader.ReadEndElement();*/
reader.Close();
sr.Close();
}
public virtual void ReadXml(XmlReader reader)
{
reader.ReadStartElement("NewCommand", Config.YttriumNamespace);
_ref = CommandReference.Deserialize("New", reader);
reader.ReadEndElement();
}
public override void ReadEndElement()
{
reader.ReadEndElement();
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
ReadXmlAttributes(reader);
ReadXmlElements(reader);
reader.ReadEndElement();
}
public static MotionDataObjectInfo Deserialize(XmlReader reader, MotionDataHeader parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent", "'parent' cannot be null");
}
reader.MoveToContent();
if (reader.IsEmptyElement)
{
return(null);
}
else
{
string name = "", groupName = "";
Color color = Color.White;
MotionDataObjectType type = MotionDataObjectType.Undefined;
int index = -1;
bool visible = true;
bool isVirtual = false;
reader.ReadStartElement(typeof(MotionDataObjectInfo).Name);
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent())
{
if (reader.IsEmptyElement)
{
reader.Skip();
continue;
}
switch (reader.Name)
{
case "Name":
name = reader.ReadElementContentAsString();
break;
case "GroupName":
groupName = reader.ReadElementContentAsString();
break;
case "ObjectType":
type = (MotionDataObjectType)Enum.Parse(typeof(MotionDataObjectType), reader.ReadElementContentAsString());
break;
case "ObjectIndex":
index = reader.ReadElementContentAsInt();
break;
case "Show":
case "Visible":
visible = reader.ReadElementContentAsBoolean();
break;
case "Virtual":
isVirtual = reader.ReadElementContentAsBoolean();
break;
case "Color":
var cstr = reader.ReadElementContentAsString();
int cint;
if (int.TryParse(cstr, out cint))
{
color = Color.FromArgb(cint);
}
else
{
color = ColorTranslator.FromHtml(cstr);
}
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
if (type == MotionDataObjectType.Undefined || index == -1)
{
return(null);
}
var ret = new MotionDataObjectInfo(parent, type, index);
ret.Name = name;
ret.GroupName = groupName;
ret.Color = color;
ret.Visible = visible;
ret.Virtual = isVirtual;
return(ret);
}
}
protected virtual void ReadXmlElements(XmlReader reader)
{
reader.ReadStartElement();
Title = reader.ReadElementString("Title").NullIfEmpty();
PositionTitle = reader.ReadOptionalElementString("PositionTitle").NullIfEmpty();
if (reader.IsStartElement("BulletPoints"))
{
reader.ReadStartElement("BulletPoints");
BulletPoints = reader.ReadStringList("BulletPoint").ToArray();
reader.ReadEndElement("BulletPoints");
}
else
{
BulletPoints = null;
}
Summary = reader.ReadOptionalElementString("Summary").NullIfEmpty();
Content = reader.ReadElementString("Content").NullIfEmpty();
EmployerCompanyName = reader.ReadOptionalElementString("EmployerCompanyName").NullIfEmpty();
JobTypes = reader.ReadElementString("JobTypes").DeserializeEnum <JobTypes>();
Location = reader.ReadOptionalElementString("Location").NullIfEmpty();
if (reader.IsStartElement("Salary"))
{
Salary = new Salary();
ReadXml(reader, Salary);
}
else
{
Salary = null;
}
PackageDetails = reader.ReadOptionalElementString("PackageDetails").NullIfEmpty();
Postcode = reader.ReadOptionalElementString("Postcode").NullIfEmpty();
ResidencyRequired = XmlConvert.ToBoolean(reader.ReadElementString("ResidencyRequired"));
ContactDetails = new ContactDetails();
var readPerson = ReadContactPersonXml(reader, ContactDetails);
var readDetails = ReadContactDetailsXml(reader, ContactDetails);
if (!readPerson && !readDetails)
{
ContactDetails = null;
}
Industries = new List <string>();
reader.ReadStartElement("Industries");
while (reader.IsStartElement("Industry"))
{
var name = reader.ReadElementString();
if (!string.IsNullOrEmpty(name))
{
Industries.Add(name);
}
}
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Industries")
{
reader.ReadEndElement("Industries");
}
ExternalApplyUrl = reader.ReadOptionalElementString("ExternalApplyUrl").NullIfEmpty();
CssFilename = reader.ReadOptionalElementString("CssFilename").NullIfEmpty();
}
private static void DeserializeAttributeElement(XmlReader reader, ResultSerializer.ResultDialect dialect, ADWSResultEntry entry)
{
string str = null;
string str1 = null;
string str2 = null;
string str3 = null;
bool flag = false;
if (string.IsNullOrEmpty(reader.Prefix))
{
if (!string.Equals(reader.NamespaceURI, "http://schemas.microsoft.com/2008/1/ActiveDirectory", StringComparison.Ordinal))
{
flag = false;
}
else
{
flag = true;
}
}
else
{
string str4 = reader.LookupNamespace(reader.Prefix);
if (!string.Equals(str4, "http://schemas.microsoft.com/2008/1/ActiveDirectory", StringComparison.Ordinal))
{
flag = false;
//reader.Prefix;
}
else
{
flag = true;
//reader.Prefix;
}
}
if (!flag)
{
bool flag1 = false;
string str5 = string.Intern(reader.LocalName);
if (str5.Equals("objectClass", StringComparison.OrdinalIgnoreCase))
{
flag1 = true;
}
XmlUtility.DeserializeLdapAttributeOption(reader, ref str5);
object obj = null;
reader.Read();
ADValueSerializer.Deserialize(reader, flag1, out obj);
entry.DirObject.SetValue(str5, new ADPropertyValueCollection(obj));
reader.ReadEndElement();
return;
}
else
{
string localName = reader.LocalName;
if (!string.Equals(localName, "container-hierarchy-parent", StringComparison.Ordinal))
{
if (!string.Equals(localName, "distinguishedName", StringComparison.Ordinal))
{
if (!string.Equals(localName, "relativeDistinguishedName", StringComparison.Ordinal))
{
if (!string.Equals(localName, "objectReferenceProperty", StringComparison.Ordinal))
{
throw new ArgumentException(string.Format(StringResources.ADWSXmlParserInvalidAttribute, localName));
}
else
{
reader.ReadStartElement("objectReferenceProperty", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
ADValueSerializer.DeserializeSingleValue <string>(reader, out str3);
entry.ObjectReferenceProperty = str3;
reader.ReadEndElement();
return;
}
}
else
{
reader.ReadStartElement("relativeDistinguishedName", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
ADValueSerializer.DeserializeSingleValue <string>(reader, out str2);
entry.RelativeDistinguishedName = str2;
reader.ReadEndElement();
return;
}
}
else
{
reader.ReadStartElement("distinguishedName", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
ADValueSerializer.DeserializeSingleValue <string>(reader, out str1);
entry.DistinguishedName = str1;
reader.ReadEndElement();
return;
}
}
else
{
reader.ReadStartElement("container-hierarchy-parent", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
ADValueSerializer.DeserializeSingleValue <string>(reader, out str);
entry.ParentContainer = str;
reader.ReadEndElement();
return;
}
}
}
public void InstallSet(string filename)
{
SQLiteTransaction trans = GamesRepository.DatabaseConnection.BeginTransaction();
try
{
using (Package package = Package.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
PackageRelationship defRelationship =
package.GetRelationshipsByType("http://schemas.octgn.org/set/definition").First();
PackagePart definition = package.GetPart(defRelationship.TargetUri);
var settings = new XmlReaderSettings
{
ValidationType = ValidationType.Schema, IgnoreWhitespace = true
};
using (
Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream(typeof(GamesRepository),
"CardSet.xsd"))
//CardSet.xsd determines the "attributes" of a card (name, guid, alternate, dependent)
if (s != null)
{
using (XmlReader reader = XmlReader.Create(s))
settings.Schemas.Add(null, reader);
}
// Read the cards
using (XmlReader reader = XmlReader.Create(definition.GetStream(), settings))
{
reader.ReadToFollowing("set"); // <?xml ... ?>
var set = new Set(filename, reader, Repository);
if (set.Game != this)
{
throw new ApplicationException(
string.Format("The set '{0}' is not built for the game '{1}'.", set.Name, Name));
}
if (set.GameVersion.Major != Version.Major || set.GameVersion.Minor != Version.Minor)
{
throw new ApplicationException(
string.Format(
"The set '{0}' is incompatible with the installed game version.\nGame version: \nSet made for version: {1:2}.",
set.Name, set.GameVersion));
}
InsertSet(set);
if (reader.IsStartElement("packaging"))
{
reader.ReadStartElement(); // <packaging>
while (reader.IsStartElement("pack"))
{
string xml = reader.ReadOuterXml();
var pack = new Pack(set, xml);
InsertPack(pack, xml, set.Id);
}
reader.ReadEndElement(); // </packaging>
}
if (reader.IsStartElement("markers"))
{
reader.ReadStartElement(); // <markers>
while (reader.IsStartElement("marker"))
{
reader.MoveToAttribute("name");
string markerName = reader.Value;
reader.MoveToAttribute("id");
var markerId = new Guid(reader.Value);
Uri markerImageUri = definition.GetRelationship("M" + markerId.ToString("N")).TargetUri;
string markerUri = markerImageUri.OriginalString;
if (!package.PartExists(markerImageUri))
{
throw new ApplicationException(
string.Format(
"Image for marker '{0}', with URI '{1}' was not found in the package.",
markerName, markerUri));
}
reader.Read(); // <marker />
InsertMarker(markerId, markerName, markerUri, set.Id);
}
reader.ReadEndElement(); // </markers>
}
if (reader.IsStartElement("cards"))
{
reader.ReadStartElement(); // <cards>
while (reader.IsStartElement("card"))
{
InsertCard(new CardModel(reader, this, set, definition, package));
}
// cards are parsed through the CardModel constructor, which are then inserted individually into the database
reader.ReadEndElement(); // </cards>
}
reader.ReadEndElement();
}
CopyDecks(package);
package.Close();
// Commit the changes
trans.Commit();
}
}
catch (Exception e)
{
trans.Rollback();
throw e;
}
if (SimpleDataTableCache.CacheExists())
{
SimpleDataTableCache.ClearCache();
}
}
public override object ReadObject(XmlReader reader)
{
BookCompositeType BookCompositeTypeField = null;
if (IsParentStartElement(reader, false, true))
{
BookCompositeTypeField = new BookCompositeType();
reader.Read();
schemas.microsoft.com.Serialization.Arrays.ArrayOfstringDataContractSerializer AuthorsDCS = new schemas.microsoft.com.Serialization.Arrays.ArrayOfstringDataContractSerializer("Authors", "http://schemas.datacontract.org/2004/07/", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");
AuthorsDCS.BodyParts = this.BodyParts;
BookCompositeTypeField.Authors = ((schemas.microsoft.com.Serialization.Arrays.ArrayOfstring)(AuthorsDCS.ReadObject(reader)));
if (IsChildStartElement(reader, "Description", true, false))
{
reader.Read();
BookCompositeTypeField.Description = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "ID", false, false))
{
reader.Read();
BookCompositeTypeField.ID = XmlConvert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "ISBN", true, false))
{
reader.Read();
BookCompositeTypeField.ISBN = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Language", true, false))
{
reader.Read();
BookCompositeTypeField.Language = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "PublicationDate", false, false))
{
reader.Read();
//BookCompositeTypeField.PublicationDate = XmlConvert.ToDateTime(reader.ReadString());
BookCompositeTypeField.PublicationDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Publisher", true, false))
{
reader.Read();
BookCompositeTypeField.Publisher = reader.ReadString();
reader.ReadEndElement();
}
schemas.microsoft.com.Serialization.Arrays.ArrayOfstringDataContractSerializer SubjectsDCS = new schemas.microsoft.com.Serialization.Arrays.ArrayOfstringDataContractSerializer("Subjects", "http://schemas.datacontract.org/2004/07/", "http://schemas.microsoft.com/2003/10/Serialization/Arrays");
SubjectsDCS.BodyParts = this.BodyParts;
BookCompositeTypeField.Subjects = ((schemas.microsoft.com.Serialization.Arrays.ArrayOfstring)(SubjectsDCS.ReadObject(reader)));
if (IsChildStartElement(reader, "Title", true, false))
{
reader.Read();
BookCompositeTypeField.Title = reader.ReadString();
reader.ReadEndElement();
}
reader.ReadEndElement();
}
return BookCompositeTypeField;
}
internal static DataCollectorSettings FromXml(XmlReader reader)
{
DataCollectorSettings settings = new DataCollectorSettings();
settings.IsEnabled = true;
bool empty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "uri":
ValidateArg.NotNullOrEmpty(reader.Value, "uri");
settings.Uri = new Uri(reader.Value);
break;
case "assemblyQualifiedName":
ValidateArg.NotNullOrEmpty(reader.Value, "assemblyQualifiedName");
settings.AssemblyQualifiedName = reader.Value;
break;
case "friendlyName":
ValidateArg.NotNullOrEmpty(reader.Value, "FriendlyName");
settings.FriendlyName = reader.Value;
break;
case "enabled":
settings.IsEnabled = bool.Parse(reader.Value);
break;
case "codebase":
settings.CodeBase = reader.Value; // Optional.
break;
default:
throw new SettingsException(
String.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsXmlAttribute,
Constants.DataCollectionRunSettingsName,
reader.Name));
}
}
}
if (string.IsNullOrWhiteSpace(settings.FriendlyName))
{
throw new SettingsException(
String.Format(CultureInfo.CurrentCulture, Resources.Resources.MissingDataCollectorAttributes, "FriendlyName"));
}
reader.Read();
if (!empty)
{
while (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Configuration":
XmlDocument doc = new XmlDocument();
XmlElement element = doc.CreateElement("Configuration");
element.InnerXml = reader.ReadInnerXml();
settings.Configuration = element;
break;
default:
throw new SettingsException(
String.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsXmlElement,
Constants.DataCollectionRunSettingsName,
reader.Name));
}
}
reader.ReadEndElement();
}
return(settings);
}
public override object ReadObject(XmlReader reader)
{
LoanStateCompositeType LoanStateCompositeTypeField = null;
if (IsParentStartElement(reader, false, true))
{
LoanStateCompositeTypeField = new LoanStateCompositeType();
reader.Read();
if (IsChildStartElement(reader, "BookID", false, false))
{
reader.Read();
LoanStateCompositeTypeField.BookID = XmlConvert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Description", true, false))
{
reader.Read();
LoanStateCompositeTypeField.Description = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "ISBN", true, false))
{
reader.Read();
LoanStateCompositeTypeField.ISBN = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Language", true, false))
{
reader.Read();
LoanStateCompositeTypeField.Language = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "LoanExpirationDate", false, false))
{
reader.Read();
// LoanStateCompositeTypeField.LoanExpirationDate = XmlConvert.ToDateTime(reader.ReadString());
LoanStateCompositeTypeField.LoanExpirationDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "LoanStartDate", false, false))
{
reader.Read();
// LoanStateCompositeTypeField.LoanStartDate = XmlConvert.ToDateTime(reader.ReadString());
LoanStateCompositeTypeField.LoanStartDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "PublicationDate", false, false))
{
reader.Read();
// LoanStateCompositeTypeField.PublicationDate = XmlConvert.ToDateTime(reader.ReadString());
LoanStateCompositeTypeField.PublicationDate = LibraryTerminal.Utils.Parse(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Publisher", true, false))
{
reader.Read();
LoanStateCompositeTypeField.Publisher = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "Title", true, false))
{
reader.Read();
LoanStateCompositeTypeField.Title = reader.ReadString();
reader.ReadEndElement();
}
reader.ReadEndElement();
}
return LoanStateCompositeTypeField;
}
static void ReadAllowFromElement(XmlReader reader, AccessPolicy policy)
{
if (IsNonEmptyElement(reader))
{
reader.Skip();
return;
}
bool valid = true;
string headers = null;
string methods = null; // new in SL3
if (reader.HasAttributes)
{
int n = reader.AttributeCount;
headers = reader.GetAttribute("http-request-headers");
if (headers != null)
{
n--;
}
methods = reader.GetAttribute("http-methods");
if (methods != null)
{
n--;
}
valid = (n == 0);
}
var v = new AllowFrom();
v.HttpRequestHeaders.SetHeaders(headers);
v.AllowAnyMethod = (methods == "*"); // only legal value defined, otherwise restricted to GET and POST
reader.ReadStartElement("allow-from", String.Empty);
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (IsNonElement(reader) || !String.IsNullOrEmpty(reader.NamespaceURI))
{
reader.Skip();
continue;
}
switch (reader.LocalName)
{
case "domain":
var d = reader.GetAttribute("uri");
if (d == "*")
{
v.AllowAnyDomain = true;
}
else
{
v.Domains.Add(d);
}
reader.Skip();
break;
default:
valid = false;
reader.Skip();
continue;
}
}
if (valid)
{
policy.AllowedServices.Add(v);
}
reader.ReadEndElement();
}
public override object ReadObject(XmlReader reader)
{
UserCompositeType UserCompositeTypeField = null;
if (IsParentStartElement(reader, false, true))
{
UserCompositeTypeField = new UserCompositeType();
reader.Read();
if (IsChildStartElement(reader, "Delay", false, false))
{
reader.Read();
UserCompositeTypeField.Delay = XmlConvert.ToBoolean(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "FirstName", true, false))
{
reader.Read();
UserCompositeTypeField.FirstName = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "ID", false, false))
{
reader.Read();
UserCompositeTypeField.ID = XmlConvert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "LastName", true, false))
{
reader.Read();
UserCompositeTypeField.LastName = reader.ReadString();
reader.ReadEndElement();
}
if (IsChildStartElement(reader, "MaxLoansReached", false, false))
{
reader.Read();
UserCompositeTypeField.MaxLoansReached = XmlConvert.ToBoolean(reader.ReadString());
reader.ReadEndElement();
}
reader.ReadEndElement();
}
return UserCompositeTypeField;
}
object DeserializeGenericCollection(Type collectionType, Type elementType)
{
reader.ReadStartElement();
object ret;
if (collectionType.IsInterface)
{
collectionType = typeof(List <>).MakeGenericType(elementType);
}
if (TypeMap.IsDictionary(collectionType))
{
object dic = Activator.CreateInstance(collectionType);
var itemSetter = dic.GetType().GetProperty("Item");
var keyarr = new object [1];
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (!reader.IsStartElement("item"))
{
throw SerializationError(String.Format("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
}
// reading a KeyValuePair in the form of <Key .../><Value .../>
reader.Read();
reader.MoveToContent();
object key = ReadObject(elementType.GetGenericArguments() [0]);
reader.MoveToContent();
object val = ReadObject(elementType.GetGenericArguments() [1]);
reader.Read();
keyarr [0] = key;
itemSetter.SetValue(dic, val, keyarr);
}
ret = dic;
}
else if (typeof(IList).IsAssignableFrom(collectionType))
{
#if NET_2_1
Type listType = collectionType.IsArray ? typeof(List <>).MakeGenericType(elementType) : null;
#else
Type listType = collectionType.IsArray ? typeof(ArrayList) : null;
#endif
IList c = (IList)Activator.CreateInstance(listType ?? collectionType);
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (!reader.IsStartElement("item"))
{
throw SerializationError(String.Format("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
}
Type et = elementType == typeof(object) || elementType.IsAbstract ? null : elementType;
object elem = ReadObject(et ?? typeof(object));
c.Add(elem);
}
#if NET_2_1
if (collectionType.IsArray)
{
Array array = Array.CreateInstance(elementType, c.Count);
c.CopyTo(array, 0);
ret = array;
}
else
{
ret = c;
}
#else
ret = collectionType.IsArray ? ((ArrayList)c).ToArray(elementType) : c;
#endif
}
else
{
object c = Activator.CreateInstance(collectionType);
MethodInfo add = collectionType.GetMethod("Add", new Type [] { elementType });
if (add == null)
{
var icoll = typeof(ICollection <>).MakeGenericType(elementType);
if (icoll.IsAssignableFrom(c.GetType()))
{
add = icoll.GetMethod("Add");
}
}
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (!reader.IsStartElement("item"))
{
throw SerializationError(String.Format("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
}
object elem = ReadObject(elementType);
add.Invoke(c, new object [] { elem });
}
ret = c;
}
reader.ReadEndElement();
return(ret);
}
public string ReadString(XmlReader reader)
{
reader.Read();
string s = reader.ReadString();
reader.ReadEndElement();
return s;
}
protected void LoadPosition(XmlReader reader) {
reader.ReadToFollowing ("Position");
reader.ReadToDescendant ("x");
Vector3 loadedPosition = new Vector3 ();
loadedPosition.x = reader.ReadElementContentAsFloat ();
reader.ReadToNextSibling ("y");
loadedPosition.y = reader.ReadElementContentAsFloat ();
reader.ReadToNextSibling ("z");
loadedPosition.z = reader.ReadElementContentAsFloat ();
transform.position = loadedPosition;
reader.ReadEndElement ();
}
