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();
}
private void LoadEnemies(XmlReader reader) {
reader.ReadStartElement("Enemies");
GameObject enemy = null;
bool enemyToParse = reader.ReadToFollowing ("Enemy");
Debug.Log ("Started parsing enemies..." + enemyToParse);
do {
if(!enemyToParse)
break;
Debug.Log ("Found an enemy");
switch (reader.GetAttribute ("Type")) {
case "Bat":
enemy = Instantiate (prefabDictionary ["Bat"]);
break;
case "Blob":
enemy = Instantiate (prefabDictionary ["Blob"]);
break;
}
enemy.GetComponent<Enemy> ().Load (reader);
} while(reader.ReadToNextSibling("Enemy"));
}
/// <summary>
/// Write an object.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="input">
/// The input.
/// </param>
private void WriteObject(AmfContext context, AmfStreamWriter writer, XmlReader input)
{
context.References.Add(new AmfReference {
AmfxType = AmfxContent.Object
});
WriteTypeMarker(writer, Amf0TypeMarker.Object);
string typeName = string.Empty;
if (input.HasAttributes)
{
typeName = input.GetAttribute(AmfxContent.ObjectType);
}
var traits = new AmfTypeTraits {
TypeName = typeName
};
while (input.Read())
{
if (input.NodeType != XmlNodeType.Element && input.Name != AmfxContent.Traits)
{
continue;
}
if (!input.IsEmptyElement)
{
XmlReader traitsReader = input.ReadSubtree();
traitsReader.MoveToContent();
traitsReader.ReadStartElement();
var members = new List <string>();
while (input.NodeType != XmlNodeType.EndElement)
{
members.Add(traitsReader.ReadElementContentAsString());
}
traits.ClassMembers = members.ToArray();
traitsReader.Close();
}
break;
}
// Untyped object
if (string.IsNullOrEmpty(traits.TypeName))
{
WriteTypeMarker(writer, Amf0TypeMarker.Object);
}
// Strongly-typed object
else
{
WriteTypeMarker(writer, Amf0TypeMarker.TypedObject);
byte[] typeNameData = Encoding.UTF8.GetBytes(traits.TypeName);
writer.Write((ushort)typeNameData.Length);
writer.Write(typeNameData);
}
#region Write members
int i = 0;
while (input.Read())
{
if (input.NodeType != XmlNodeType.Element)
{
continue;
}
string memberName = traits.ClassMembers[i];
XmlReader memberReader = input.ReadSubtree();
memberReader.MoveToContent();
WriteUtf8(writer, memberName);
this.WriteAmfValue(context, memberReader, writer);
memberReader.Close();
i++;
}
#endregion
WriteUtf8(writer, string.Empty);
WriteTypeMarker(writer, Amf0TypeMarker.ObjectEnd);
}
// read
void ReadXml(XmlReader reader, bool fromSerializable)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
SetFeed(CreateFeedInstance());
reader.MoveToContent();
if (reader.MoveToFirstAttribute())
{
do
{
if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/")
{
continue;
}
if (reader.LocalName == "lang" && reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace")
{
Feed.Language = reader.Value;
continue;
}
if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, Feed, Version) && PreserveAttributeExtensions)
{
Feed.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
} while (reader.MoveToNextAttribute());
}
reader.ReadStartElement();
Collection <SyndicationItem> items = null;
for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
if (reader.NodeType != XmlNodeType.Element)
{
throw new XmlException("Only element node is expected under 'feed' element");
}
if (reader.NamespaceURI == AtomNamespace)
{
switch (reader.LocalName)
{
case "author":
SyndicationPerson p = Feed.CreatePerson();
ReadPerson(reader, p);
Feed.Authors.Add(p);
continue;
case "category":
SyndicationCategory c = Feed.CreateCategory();
ReadCategory(reader, c);
Feed.Categories.Add(c);
continue;
case "contributor":
p = Feed.CreatePerson();
ReadPerson(reader, p);
Feed.Contributors.Add(p);
continue;
case "generator":
Feed.Generator = reader.ReadElementContentAsString();
continue;
// "icon" is an extension
case "id":
Feed.Generator = reader.ReadElementContentAsString();
continue;
case "link":
SyndicationLink l = Feed.CreateLink();
ReadLink(reader, l);
Feed.Links.Add(l);
continue;
case "logo":
Feed.ImageUrl = CreateUri(reader.ReadElementContentAsString());
continue;
case "rights":
Feed.Copyright = ReadTextSyndicationContent(reader);
continue;
case "subtitle":
Feed.Description = ReadTextSyndicationContent(reader);
continue;
case "title":
Feed.Title = ReadTextSyndicationContent(reader);
continue;
case "updated":
// FIXME: somehow DateTimeOffset causes the runtime crash.
reader.ReadElementContentAsString();
// Feed.LastUpdatedTime = XmlConvert.ToDateTimeOffset (reader.ReadElementContentAsString ());
continue;
case "entry":
if (items == null)
{
items = new Collection <SyndicationItem> ();
Feed.Items = items;
}
items.Add(ReadItem(reader, Feed));
continue;
}
}
if (!TryParseElement(reader, Feed, Version))
{
if (PreserveElementExtensions)
{
// FIXME: what to specify for maxExtensionSize
LoadElementExtensions(reader, Feed, int.MaxValue);
}
else
{
reader.Skip();
}
}
}
reader.ReadEndElement();
}
/// <summary>
/// Populate this object's properties from XML.
/// </summary>
/// <param name="reader">Source of XML data.</param>
public void ReadXml(XmlReader reader)
{
Log.Trace("Reading train.");
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
GraphProperties = new GraphTrainPropertiesModel();
ToWork = new ToWorkModel();
LocoToWork = new ToWorkModel();
reader.MoveToContent();
Id = reader.GetAttribute("Id");
bool isEmptyElement = false;
if (reader.IsEmptyElement)
{
isEmptyElement = true;
}
reader.ReadStartElement();
if (isEmptyElement)
{
return;
}
reader.MoveToContent();
if (reader.LocalName == "Headcode")
{
Log.Trace("Reading <Headcode>");
Headcode = reader.ReadElementContentAsString();
reader.MoveToContent();
}
if (reader.LocalName == "LocoDiagram")
{
Log.Trace("Reading <LocoDiagram>");
LocoDiagram = reader.ReadElementContentAsString();
reader.MoveToContent();
}
if (reader.LocalName == "TrainClassId")
{
Log.Trace("Reading <TrainClassId>");
TrainClassId = reader.ReadElementContentAsString();
reader.MoveToContent();
}
if (reader.LocalName == "GraphProperties")
{
Log.Trace("Reading <GraphProperties>");
GraphProperties.ReadXml(reader);
reader.MoveToContent();
}
if (reader.LocalName == "TrainTimes")
{
Log.Trace("Reading <TrainTimes>");
ReadTrainTimes(reader);
reader.MoveToContent();
}
if (reader.LocalName == "FootnoteIds")
{
Log.Trace("Reading <FootnoteIds>");
ReadFootnotes(reader);
reader.MoveToContent();
}
if (reader.LocalName == "IncludeSeparatorAbove")
{
Log.Trace("Reading <IncludeSeparatorAbove>");
IncludeSeparatorAbove = reader.ReadElementContentAsBoolean();
reader.MoveToContent();
}
if (reader.LocalName == "IncludeSeparatorBelow")
{
Log.Trace("Reading <IncludeSeparatorBelow>");
IncludeSeparatorBelow = reader.ReadElementContentAsBoolean();
reader.MoveToContent();
}
if (reader.LocalName == "InlineNote")
{
Log.Trace("Reading <InlineNote>");
InlineNote = reader.ReadElementContentAsString();
reader.MoveToContent();
}
if (reader.LocalName == "ToWork")
{
Log.Trace("Reading <ToWork>");
ToWork.ReadXml(reader);
reader.MoveToContent();
}
if (reader.LocalName == "LocoToWork")
{
Log.Trace("Reading <LocoToWork>");
LocoToWork.ReadXml(reader);
reader.MoveToContent();
}
MoveToEndElement(reader);
reader.ReadEndElement();
}
public void ReadXml(XmlReader reader)
{
reader.ReadStartElement();
NodeDocument.File = reader.ReadString();
reader.ReadEndElement();
}
private static object xmlReadObject(Object Parent, XmlReader xdr, RepositoryItemBase targetObj = null)
{
string ClassName = xdr.Name;
// We do auto convert to classes which moved to GingerCoreCommon
if (ClassName == "GingerCore.Actions.ActInputValue")
{
ClassName = typeof(ActInputValue).FullName;
}
if (ClassName == "GingerCore.Actions.ActReturnValue" || ClassName == "GingerCore.Common.Actions.ActInputValue")
{
ClassName = typeof(ActReturnValue).FullName;
}
if (ClassName == "GingerCore.Actions.EnhancedActInputValue")
{
ClassName = typeof(EnhancedActInputValue).FullName;
}
try
{
object obj = null;
int level = xdr.Depth;
// We first try in current assembly = GingerCore
if (targetObj == null)
{
obj = GingerCoreAssembly.CreateInstance(ClassName);
}
else
{
obj = targetObj; //used for DeepCopy to objects fields
}
if (obj == null) //Ginger assembly
{
if (ClassName == "Ginger.Environments.Solution")
{
ClassName = "Ginger.SolutionGeneral.Solution";
}
obj = GingerAssembly.CreateInstance(ClassName);
obj = System.Reflection.Assembly.Load("Ginger").CreateInstance(ClassName);
}
if (obj == null)
{
obj = GingerCoreCommon.CreateInstance(ClassName);
}
if (obj == null) //GingerCoreCommon assembly
{
if (ClassName == "GingerCore.Actions.ActInputValue" || ClassName == "GingerCore.Common.Actions.ActInputValue")
{
ClassName = typeof(ActInputValue).FullName;
}
if (ClassName == "GingerCore.Actions.ActReturnValue")
{
ClassName = typeof(ActReturnValue).FullName;
}
if (ClassName == "GingerCore.Environments.GeneralParam")
{
ClassName = typeof(GeneralParam).FullName;
}
if (ClassName == "Ginger.TagsLib.RepositoryItemTag")
{
ClassName = typeof(RepositoryItemTag).FullName;
}
if (ClassName == "GingerCore.Platforms.ApplicationPlatform")
{
ClassName = typeof(ApplicationPlatform).FullName;
}
obj = GingerCoreCommon.CreateInstance(ClassName);
}
if (obj == null) //GingerCoreNET assembly
{
obj = GingerCoreNET.CreateInstance(ClassName);
}
if (obj == null)
{
throw new Exception("Error:Cannot create Class: " + ClassName);
}
SetObjectAttributes(xdr, obj);
xdr.Read();
// Set lists attrs
// read all object sub elements like lists - obj members
while (xdr.Depth == level + 1)
{
// Check if it one obj attr or list
string attrName = xdr.Name;
MemberInfo mi = obj.GetType().GetMember(attrName).SingleOrDefault();
// New to support prop and field - like BF.Activities
if (mi.MemberType == MemberTypes.Field)
{
FieldInfo FI = (FieldInfo)mi;
// We check if it is list by arg count - List<string> will have string etc...
// another option is check the nake to start with List, Observe...
//or find a better way
// meanwhile it is working
if (FI.FieldType.GenericTypeArguments.Count() > 0)
{
SetObjectListAttrs(xdr, obj);
}
else
{
// Read the attr name/move next
xdr.ReadStartElement();
// read the actual object we need to put on the attr
object item = xmlReadObject(obj, xdr);
// Set the attr val with the object
FI.SetValue(obj, item);
if (item is Email)//If should be removed- placing if for solving Run Set operation release issue with minimum risk
{
xdr.ReadEndElement();
}
}
}
else
{
PropertyInfo PI = (PropertyInfo)mi;
// obj.GetType().GetField(attrName);
// We check if it is list by arg count - List<string> will have string etc...
// another option is check the nake to start with List, Observe...
//or find a better way
// meanwhile it is working
if (PI.PropertyType.GenericTypeArguments.Count() > 0)
{
SetObjectListAttrs(xdr, obj);
}
else
{
// Read the attr name/move next
xdr.ReadStartElement();
// read the actual object we need to put on the attr
object item = xmlReadObject(obj, xdr);
// Set the attr val with the object
PI.SetValue(obj, item);
if (item is Email)//If should be removed- placing if for solving Run Set operation release issue with minimum risk
{
xdr.ReadEndElement();
}
}
}
if (xdr.NodeType == XmlNodeType.EndElement)
{
xdr.ReadEndElement();
}
}
return(obj);
}
catch (Exception ex)
{
throw new Exception("Error:Cannot create instance of: " + xdr.Name + " - " + ex.Message);
}
}
public ONCollection QueryByFilter_LMD(ref string ticket, ref ONOid agentOid, XmlReader xmlReader, ONDisplaySet displaySet, out ONOid startRowOID, out int blockSize, double dtdVersion, string clientName)
{
ONLinkedToList lLinkedTo = null;
ONFilterList lFilters = new ONFilterList();
// Read Request
blockSize = int.Parse(xmlReader.GetAttribute("BlockSize"));
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Query.Filter");
if (xmlReader.IsStartElement("StartRow"))
{
xmlReader.ReadStartElement("StartRow");
startRowOID = XML2ON(xmlReader, dtdVersion);
xmlReader.ReadEndElement(); // StartRow
}
else
{
startRowOID = null;
}
// Fill relations
lLinkedTo = GetLinkedTo(xmlReader, dtdVersion);
// Fill filter variables
lFilters["LMD"] = GetFilter_LMD(xmlReader, dtdVersion);
// Read Request
xmlReader.ReadEndElement(); // Query.Filter
}
else
{
xmlReader.ReadStartElement("Query.Filter");
lLinkedTo = new ONLinkedToList();
startRowOID = null;
}
// Read Order Criteria
string lOrderCriteria = "";
if (xmlReader.IsStartElement("Sort"))
{
lOrderCriteria = xmlReader.GetAttribute("Criterium");
xmlReader.Skip(); // Sort
}
//Read Filter Navigation
if (xmlReader.IsStartElement("NavFilt"))
{
xmlReader.Skip();
}
// Create Context
ONContext lOnContext = new ONContext();
lOnContext.OidAgent = agentOid;
// Execute
lOnContext.CalculateQueryInstancesNumber = true;
RevisionPasajeroQuery lQuery = new RevisionPasajeroQuery(lOnContext);
ONCollection lCollection = lQuery.QueryByFilter(lLinkedTo, lFilters, displaySet, lOrderCriteria, startRowOID, blockSize);
ticket = lOnContext.GetTicket(dtdVersion, clientName);
return(lCollection);
}
public void ReadXml(XmlReader reader)
{
reader.ReadStartElement("UserConfiguration");
if (ConfigurationDictionary.GetNode(reader, "Info") == null)
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "Info");
}
if (ConfigurationDictionary.GetAttribute(reader, "version") == null)
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "version");
}
if (reader.Value != "Exchange.12")
{
ExTraceGlobals.StorageTracer.TraceDebug <string>((long)this.GetHashCode(), "The version is not supported. Version = {0}.", reader.Value);
}
if (ConfigurationDictionary.GetNode(reader, "Data") == null)
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "Data");
}
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.Name == "e" && reader.HasAttributes)
{
reader.MoveToFirstAttribute();
object obj = null;
object obj2 = null;
bool flag = true;
do
{
if (reader.Name == "k")
{
if (obj == null)
{
obj = this.DeserializeObject(reader.Value);
}
}
else if (reader.Name == "v")
{
flag = false;
if (obj2 == null)
{
obj2 = this.DeserializeObject(reader.Value);
}
}
}while (reader.MoveToNextAttribute());
if (obj == null)
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNullKey, "k");
}
if (flag)
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "v");
}
if (base.Dictionary.Contains(obj))
{
this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedDuplicateKey(obj.ToString()), obj.ToString());
}
else
{
base.Dictionary.Add(obj, obj2);
}
}
reader.Read();
}
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.MoveToContent() != XmlNodeType.Element)
{
throw new InvalidOperationException();
}
var emptyCollection = reader.IsEmptyElement; // check if container element is empty
var locales = new Dictionary <string, Locale>();
_defaultLocale = reader.GetAttribute(_attributeDefault);
reader.ReadStartElement(); // consume the container element tag
if (!emptyCollection)
{
// children of container should each be elements representing individual collection items
// at the end of this loop, we must be positioned past each item, whether an end element or an empty element tag
while (reader.MoveToContent() == XmlNodeType.Element)
{
var emptyItem = reader.IsEmptyElement;
var locale = (Locale)null;
if (reader.Name == _elementLocale)
{
try
{
var culture = reader.GetAttribute(_attributeCulture);
var displayName = reader.GetAttribute(_attributeDisplayName);
locale = new Locale(culture, displayName);
}
catch (Exception ex)
{
Platform.Log(LogLevel.Debug, ex, "Invalid installed locale definition");
}
// consume the entire element
if (!emptyItem)
{
reader.ReadSubtree().Close(); // read start tag and all descendants
reader.ReadEndElement(); // read end tag
}
else
{
reader.ReadStartElement(); // read empty element tag
}
}
else
{
// if the child element is unrecognized, we still have to consume it!
// otherwise we will not be at the right position to pick up the next item
if (!emptyItem)
{
reader.ReadSubtree().Close(); // read start tag and all descendants
reader.ReadEndElement(); // read end tag
}
else
{
reader.ReadStartElement(); // read empty element tag
}
}
// ignore duplicate entries
if (locale != null && !locales.ContainsKey(locale.Culture.ToLowerInvariant()))
{
locales.Add(locale.Culture.ToLowerInvariant(), locale);
}
}
}
_installedLocales.Clear();
_installedLocales.AddRange(locales.Values);
_installedLocales.Sort((x, y) => string.Compare(x.DisplayName, y.DisplayName, StringComparison.InvariantCultureIgnoreCase));
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Skip();
return;
}
reader.ReadStartElement("MotionDataFrame");
string lengthStr;
int length;
while (reader.NodeType != XmlNodeType.None)
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (reader.Name)
{
case "Points":
if (reader.IsEmptyElement || (lengthStr = reader.GetAttribute("Length")) == null)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
if (int.TryParse(lengthStr, out length))
{
string contents = reader.ReadString();
readPointsFromString(length, contents);
}
while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
break;
case "Lines":
if (reader.IsEmptyElement || (lengthStr = reader.GetAttribute("Length")) == null)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
if (int.TryParse(lengthStr, out length))
{
string contents = reader.ReadString();
readLinesFromString(length, contents);
}
while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
break;
case "Cylinders":
if (reader.IsEmptyElement || (lengthStr = reader.GetAttribute("Length")) == null)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
if (int.TryParse(lengthStr, out length))
{
string contents = reader.ReadString();
readCylindersFromString(length, contents);
}
while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
break;
case "Spheres":
if (reader.IsEmptyElement || (lengthStr = reader.GetAttribute("Length")) == null)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
if (int.TryParse(lengthStr, out length))
{
string contents = reader.ReadString();
ReadSpheresFromString(length, contents);
}
while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
break;
case "Planes":
if (reader.IsEmptyElement || (lengthStr = reader.GetAttribute("Length")) == null)
{
reader.Skip();
}
else
{
reader.ReadStartElement();
if (int.TryParse(lengthStr, out length))
{
this.Planes = new MotionDataPlane[length];
int count = 0;
while (true)
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (count == length)
{
break;
}
switch (reader.Name)
{
case "MotionDataPlane":
this.Planes[count] = MotionDataPlane.Deserialize(reader);
count++;
break;
default:
reader.Skip();
break;
}
}
}
while (reader.NodeType != XmlNodeType.None && reader.NodeType != XmlNodeType.EndElement)
{
reader.Skip();
}
reader.ReadEndElement();
}
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
public override void ReadStartElement(string name)
{
_reader.ReadStartElement(name);
}
private void ReadStartElement()
{
_xmlReader.ReadStartElement();
_xmlReader.MoveToContent();
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (!reader.IsStartElement("extensionRegistry"))
{
throw new InvalidOperationException(
string.Concat("无效配置.期望节点是 'extensionRegistry 便实际是 '", reader.LocalName, "'."));
}
reader.ReadStartElement("extensionRegistry");
if (!reader.IsStartElement("extensionPoints"))
{
throw new InvalidOperationException(
string.Concat("无效配置.期望节点是 'extensionRegistry 便实际是 '", reader.LocalName, "'."));
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement("extensionPoints");
}
else
{
reader.ReadStartElement("extensionPoints");
while (reader.IsStartElement("extensionPoint"))
{
ExtensionPointConfiguration cfg = new ExtensionPointConfiguration();
cfg.ReadXml(reader);
List <ExtensionConfiguration> extensionConfigs = new List <ExtensionConfiguration>();
XmlUtils.ReadElementsIntoList <ExtensionConfiguration>(reader, "extensions", "extension", extensionConfigs);
IExtensionPoint point = new ExtensionPoint(cfg);
_registry._extensionPoints.Add(point.Id, point);
for (int i = 0; i < extensionConfigs.Count; i++)
{
IExtension ext = new Extension(extensionConfigs[i], _extensionBuilder);
_registry._extensions.Add(ext.Id, ext);
((ExtensionPoint)point).AddExtension(ext);
}
}
reader.ReadEndElement();
}
if (reader.IsStartElement("extensions"))
{
if (reader.IsEmptyElement)
{
reader.ReadStartElement("extensions");
}
else
{
// read the orphans
reader.ReadStartElement("extensions");
while (reader.IsStartElement("extension"))
{
ExtensionConfiguration extCfg = ExtensionConfiguration.FromXml(reader);
if (!_registry._extensions.ContainsKey(extCfg.Id))
{
IExtension ext = new Extension(extCfg, _extensionBuilder);
_registry._extensions.Add(ext.Id, ext);
}
}
reader.ReadEndElement();
}
}
reader.ReadEndElement(); //</extensionRegistry>
}
public void ReadXml(XmlReader reader)
{
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "LogGUID":
LogGUID = reader.ReadContentAsString();
break;
case "LogFileID":
LogFileID = reader.ReadContentAsString();
break;
case "LogTypeKey":
LogTypeKey = reader.ReadContentAsString();
break;
case "LogUserID":
LogUserID = reader.ReadContentAsInt();
break;
case "LogEventID":
LogEventID = reader.ReadContentAsInt();
break;
case "LogUserName":
LogUserName = reader.ReadContentAsString();
break;
case "LogPortalID":
LogPortalID = reader.ReadContentAsInt();
break;
case "LogPortalName":
LogPortalName = reader.ReadContentAsString();
break;
case "LogCreateDate":
LogCreateDate = DateTime.Parse(reader.ReadContentAsString());
break;
case "LogCreateDateNum":
LogCreateDateNum = reader.ReadContentAsLong();
break;
case "BypassBuffering":
BypassBuffering = bool.Parse(reader.ReadContentAsString());
break;
case "LogServerName":
LogServerName = reader.ReadContentAsString();
break;
case "LogConfigID":
LogConfigID = reader.ReadContentAsString();
break;
}
}
}
//Check for LogProperties child node
reader.Read();
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "LogProperties")
{
reader.ReadStartElement("LogProperties");
if (reader.ReadState != ReadState.EndOfFile && reader.NodeType != XmlNodeType.None && !String.IsNullOrEmpty(reader.LocalName))
{
LogProperties.ReadXml(reader);
}
}
//Check for Exception child node
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "Exception")
{
Exception.ReadXml(reader);
}
}
protected override void ReadXml(XmlReader reader)
{
reader.MoveToAttribute("Name");
Name = reader.ReadContentAsString();
reader.MoveToAttribute("Offset");
Offset = (UInt16)reader.ReadContentAsInt();
reader.MoveToElement();
reader.ReadStartElement();
JPCost = (ushort)reader.ReadElementContentAsInt();
LearnRate = (byte)reader.ReadElementContentAsInt();
AbilityType = (AbilityType)Enum.Parse(typeof(AbilityType), reader.ReadElementContentAsString(), true);
LearnWithJP = reader.ReadElementContentAsBoolean();
Action = reader.ReadElementContentAsBoolean();
LearnOnHit = reader.ReadElementContentAsBoolean();
Blank1 = reader.ReadElementContentAsBoolean();
Unknown1 = reader.ReadElementContentAsBoolean();
Unknown2 = reader.ReadElementContentAsBoolean();
Unknown3 = reader.ReadElementContentAsBoolean();
Blank2 = reader.ReadElementContentAsBoolean();
Blank3 = reader.ReadElementContentAsBoolean();
Blank4 = reader.ReadElementContentAsBoolean();
Blank5 = reader.ReadElementContentAsBoolean();
Unknown4 = reader.ReadElementContentAsBoolean();
AIFlags = new AIFlags();
((IXmlSerializable)AIFlags).ReadXml(reader);
IsNormal = ((Offset >= 0x000) && (Offset <= 0x16F));
IsItem = ((Offset >= 0x170) && (Offset <= 0x17D));
IsThrowing = ((Offset >= 0x17E) && (Offset <= 0x189));
IsJumping = ((Offset >= 0x18A) && (Offset <= 0x195));
IsCharging = ((Offset >= 0x196) && (Offset <= 0x19D));
IsArithmetick = ((Offset >= 0x19E) && (Offset <= 0x1A5));
IsOther = (Offset >= 0x1A6);
bool IsReaction = Offset >= 422 && Offset <= 453;
if (IsNormal || IsItem || IsReaction)
{
reader.MoveToAttribute("value");
ushort effectIndex = (ushort)reader.ReadElementContentAsInt();
reader.MoveToElement();
reader.ReadStartElement();
reader.ReadEndElement();
if (IsItem)
{
effectIndex &= (ushort)~ItemEffectPrefixValue;
}
Effect = ourContext == Context.US_PSP ? Effect.PSPEffects[effectIndex] : Effect.PSXEffects[effectIndex];
}
if (IsNormal)
{
Attributes = new AbilityAttributes(ourContext);
((IXmlSerializable)Attributes).ReadXml(reader);
}
else if (IsItem)
{
//ItemOffset = (ushort)reader.ReadElementContentAsInt();
SetItemOffset((ushort)reader.ReadElementContentAsInt(), ourContext);
}
else if (IsThrowing)
{
Throwing = (ItemSubType)Enum.Parse(typeof(ItemSubType),
reader.ReadElementContentAsString(), true);
}
else if (IsJumping)
{
reader.ReadStartElement();
JumpHorizontal = (byte)reader.ReadElementContentAsInt();
JumpVertical = (byte)reader.ReadElementContentAsInt();
reader.ReadEndElement();
}
else if (IsCharging)
{
reader.ReadStartElement();
ChargeCT = (byte)reader.ReadElementContentAsInt();
ChargeBonus = (byte)reader.ReadElementContentAsInt();
reader.ReadEndElement();
}
else if (IsArithmetick)
{
ArithmetickSkill = (byte)reader.ReadElementContentAsInt();
}
else if (IsOther)
{
OtherID = (byte)reader.ReadElementContentAsInt();
}
else
{
throw new InvalidOperationException("Invalid item type");
}
reader.ReadEndElement();
}
public void ReadLineXml(XmlReader r, PointF scaling)
{
r.ReadStartElement();
float length = 0;
SegmentF line = SegmentF.Empty;
calibrationAxis = CalibrationAxis.LineHorizontal;
while (r.NodeType == XmlNodeType.Element)
{
switch (r.Name)
{
case "Length":
length = float.Parse(r.ReadElementContentAsString(), CultureInfo.InvariantCulture);
break;
case "Segment":
line = ParseSegment(r, scaling);
break;
case "Origin":
// Import from older format.
origin = XmlHelper.ParsePointF(r.ReadElementContentAsString());
if (float.IsNaN(origin.X) || float.IsNaN(origin.Y))
{
origin = PointF.Empty;
}
origin = origin.Scale(scaling.X, scaling.Y);
break;
case "Axis":
calibrationAxis = (CalibrationAxis)Enum.Parse(typeof(CalibrationAxis), r.ReadElementContentAsString());
break;
case "Scale":
// Import and convert from older format.
// Create a fake line of 100 px horizontal at the origin.
float bakedScale = float.Parse(r.ReadElementContentAsString(), CultureInfo.InvariantCulture);
float lengthPixels = 100;
PointF start = origin;
PointF end = origin.Translate(lengthPixels, 0);
line = new SegmentF(start, end);
length = lengthPixels * bakedScale;
// The actual origin should be expressed in the calibrated plane coordinate system, which has its true origin at the A point of the quad.
origin = new PointF(0, length);
break;
default:
string unparsed = r.ReadOuterXml();
log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed);
break;
}
}
r.ReadEndElement();
// Update mapping.
size = new SizeF(length, length);
quadImage = MakeQuad(line.Start, line.End, calibrationAxis);
mapping.Update(new QuadrilateralF(size.Width, size.Height), quadImage);
valid = quadImage.IsConvex;
initialized = true;
}
public ReadTypes(string path)
{
chart = new List <List <float> >();
typeNames = new List <string>();
typeColor = new List <Color>();
abilities = new List <Abil>();
int typeCount = 0;
XmlReader read = XmlReader.Create(path);
read.ReadStartElement("Types");
while (read.Read())
{
if (read.Name.Equals("Type"))
{
typeNames.Add(read.GetAttribute("name"));
Color col = new Color();
col.R = Convert.ToByte(read.GetAttribute("r"));
col.G = Convert.ToByte(read.GetAttribute("g"));
col.B = Convert.ToByte(read.GetAttribute("b"));
//Console.WriteLine(col.R + " " + col.G + " " + col.B);
typeColor.Add(col);
while (!(read.NodeType == XmlNodeType.EndElement && read.Name.Equals("Type")))
{
if (read.Name.Equals("Abil") && read.NodeType == XmlNodeType.Element)
{
Abil cur = new Abil();
cur.name = read.GetAttribute("name");
cur.markTag = read.GetAttribute("tag");
if (cur.markTag == null)
{
cur.mark = false;
}
else
{
cur.mark = true;
}
cur.typeIndex = typeCount;
read.Read();
//Console.WriteLine(read.Value);
cur.modifier = (float)(Convert.ToDouble(read.Value));
abilities.Add(cur);
}
if (read.Name.Equals("DefList"))
{
List <float> row = new List <float>();
while (!(read.NodeType == XmlNodeType.EndElement && read.Name.Equals("DefList")))
{
if (read.Name.Equals("Defending") && read.NodeType == XmlNodeType.Element)
{
read.Read();
row.Add((float)(Convert.ToDouble(read.Value)));
}
read.Read();
}
chart.Add(row);
}
read.Read();
}
typeCount++;
}
}
}
/// <summary>
/// Creates an instance of a DpwsMetadata class.
/// </summary>
public DpwsMetadata(XmlReader reader, ProtocolVersion version)
{
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 == version.WsdpNamespaceUri + "/ThisModel")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisModel = new DpwsThisModel(reader, version);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == version.WsdpNamespaceUri + "/ThisDevice")
{
#if DEBUG
int depth = reader.Depth;
#endif
this.ThisDevice = new DpwsThisDevice(reader, version);
#if DEBUG
Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader));
#endif
}
else if (dialect == version.WsdpNamespaceUri + "/Relationship")
{
#if DEBUG
int depth = reader.Depth;
#endif
if (this.Relationship == null)
{
this.Relationship = new DpwsRelationship(reader, version);
}
else
{
this.Relationship.Append(reader, version);
}
#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
}
// This method handles z:Ref, xsi:nil and primitive types, and then delegates to DeserializeByMap() for anything else.
public object Deserialize(Type type, XmlReader reader)
{
#if !MOONLIGHT
if (type == typeof(XmlElement))
{
return(XmlDocument.ReadNode(reader));
}
else if (type == typeof(XmlNode []))
{
reader.ReadStartElement();
var l = new List <XmlNode> ();
for (; !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
{
l.Add(XmlDocument.ReadNode(reader));
}
reader.ReadEndElement();
return(l.ToArray());
}
#endif
QName graph_qname = null;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
Type internal_type = type.GetGenericArguments() [0];
if (types.FindUserMap(internal_type) != null)
{
graph_qname = types.GetQName(internal_type);
}
}
if (graph_qname == null)
{
graph_qname = types.GetQName(type);
}
string itype = reader.GetAttribute("type", XmlSchema.InstanceNamespace);
if (itype != null)
{
string [] parts = itype.Split(':');
if (parts.Length > 1)
{
graph_qname = new QName(parts [1], reader.LookupNamespace(reader.NameTable.Get(parts [0])));
}
else
{
graph_qname = new QName(itype, reader.LookupNamespace(String.Empty));
}
}
string label = reader.GetAttribute("Ref", KnownTypeCollection.MSSimpleNamespace);
if (label != null)
{
object o;
if (!references.TryGetValue(label, out o))
{
throw new SerializationException(String.Format("Deserialized object with reference Id '{0}' was not found", label));
}
reader.Skip();
return(o);
}
bool isNil = reader.GetAttribute("nil", XmlSchema.InstanceNamespace) == "true";
if (isNil)
{
reader.Skip();
if (!type.IsValueType || type == typeof(void))
{
return(null);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(null);
}
else
{
throw new SerializationException(String.Format("Value type {0} cannot be null.", type));
}
}
if (resolver != null)
{
Type t;
if (resolved_qnames.TryGetValue(graph_qname, out t))
{
type = t;
}
else // i.e. resolve name only once.
{
type = resolver.ResolveName(graph_qname.Name, graph_qname.Namespace, type, default_resolver) ?? type;
resolved_qnames.Add(graph_qname, type);
types.Add(type);
}
}
if (KnownTypeCollection.GetPrimitiveTypeFromName(graph_qname) != null)
{
string id = reader.GetAttribute("Id", KnownTypeCollection.MSSimpleNamespace);
object ret = DeserializePrimitive(type, reader, graph_qname);
if (id != null)
{
if (references.ContainsKey(id))
{
throw new InvalidOperationException(String.Format("Object with Id '{0}' already exists as '{1}'", id, references [id]));
}
references.Add(id, ret);
}
return(ret);
}
return(DeserializeByMap(graph_qname, type, reader));
}
public virtual void ReadXml(XmlReader reader)
{
reader.ReadStartElement("BusCommand", Context.YttriumNamespace);
_busRef = CommandReference.Deserialize("Bus", reader);
reader.ReadEndElement();
}
public override ONCollection QueryByRelated(ref string ticket, ref ONOid agentOid, XmlReader xmlReader, ONDisplaySet displaySet, out ONOid startRowOID, out int blockSize, double dtdVersion, string clientName)
{
ONLinkedToList lLinkedTo = null;
ONFilterList lFilters = new ONFilterList();
// Read Request
blockSize = int.Parse(xmlReader.GetAttribute("BlockSize"));
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Query.Related");
if (xmlReader.IsStartElement("StartRow"))
{
xmlReader.ReadStartElement("StartRow");
startRowOID = XML2ON(xmlReader, dtdVersion);
xmlReader.ReadEndElement(); // StartRow
}
else
{
startRowOID = null;
}
// Fill relations
lLinkedTo = GetLinkedTo(xmlReader, dtdVersion);
// Read Request
xmlReader.ReadEndElement(); // Query.Related
}
else
{
xmlReader.ReadStartElement("Query.Related");
lLinkedTo = new ONLinkedToList();
startRowOID = null;
}
// Read Order Criteria
string lOrderCriteria = "";
if (xmlReader.IsStartElement("Sort"))
{
lOrderCriteria = xmlReader.GetAttribute("Criterium");
xmlReader.Skip(); // Sort
}
//Read Navigational Filter
string lNavFilterId = "";
ONOid lSelectedObject = null;
if (xmlReader.IsStartElement("NavFilt"))
{
xmlReader.ReadStartElement("NavFilt");
if (xmlReader.IsStartElement("NavFilt.SelectedObject"))
{
lNavFilterId = xmlReader.GetAttribute("NavFilterID");
xmlReader.ReadStartElement("NavFilt.SelectedObject");
string lClassName = xmlReader.GetAttribute("Class");
if (lClassName == "")
{
lClassName = "GlobalTransaction";
}
object[] lArgs = new object[2];
lArgs[0] = xmlReader;
lArgs[1] = dtdVersion;
lSelectedObject = ONContext.InvoqueMethod(ONContext.GetType_XML(lClassName), "XML2ON", lArgs) as ONOid;
lArgs = new Object[1];
lArgs[0] = lSelectedObject;
lFilters.Add(lNavFilterId, ONContext.GetComponent_NavigationalFilter(lNavFilterId, lArgs) as ONFilter);
}
else if (xmlReader.IsStartElement("NavFilt.Argument"))
{
string lClassName = xmlReader.GetAttribute("Class");
if (lClassName == "")
{
lClassName = "GlobalTransaction";
}
string lServiceName = xmlReader.GetAttribute("Service");
string lArgumentName = xmlReader.GetAttribute("Argument");
xmlReader.ReadStartElement("NavFilt.Argument");
string lFilterName = lClassName + "_" + lServiceName + "Service_" + lArgumentName + "_NavigationalFilter";
if (xmlReader.IsStartElement("Arguments"))
{
object[] lArgs = new object[3];
lArgs[0] = xmlReader;
lArgs[1] = dtdVersion;
lArgs[2] = lArgumentName;
lFilters.Add(lFilterName, ONContext.InvoqueMethod(ONContext.GetComponent_XML(lClassName), typeof(ONNavigationalFilterXMLAttribute), "<Filter>" + lServiceName + "</Filter>", lArgs) as ONFilter);
}
else
{
lFilters.Add(lFilterName, ONContext.GetComponent_Filter(lFilterName, null) as ONFilter);
}
xmlReader.ReadEndElement(); //NavFilt.Argument
}
else if (xmlReader.IsStartElement("NavFilt.ServiceIU"))
{
lNavFilterId = xmlReader.GetAttribute("NavFilterID");
xmlReader.ReadStartElement("NavFilt.ServiceIU");
if (xmlReader.IsStartElement("Arguments"))
{
object[] lArgs = new object[2];
lArgs[0] = xmlReader;
lArgs[1] = dtdVersion;
ONServiceInfo lSInfo = new ONServiceInfo("", "", "", "");
lSInfo.XML2ON(xmlReader, dtdVersion, false);
HybridDictionary lArguments = new HybridDictionary(true);
foreach (ONArgumentInfo lArgument in lSInfo.mArgumentList.Values)
{
lArguments.Add(lArgument.Name, lArgument.Value);
}
lFilters.Add(lNavFilterId, ONContext.GetComponent_NavigationalFilter(lNavFilterId, new object[1] {
lArguments
}) as ONFilter);
}
else
{
lFilters.Add(lNavFilterId, ONContext.GetComponent_NavigationalFilter(lNavFilterId, null) as ONFilter);
}
xmlReader.ReadEndElement(); //NavFilt.ServiceIU
}
else if (xmlReader.IsStartElement("NavFilt.Variable"))
{
string lClassName = xmlReader.GetAttribute("Class");
string lSourceFilterName = xmlReader.GetAttribute("Filter");
string lVariableName = xmlReader.GetAttribute("Variable");
xmlReader.ReadStartElement("NavFilt.Variable");
string lFilterName = lClassName + "_" + lSourceFilterName + "Filter_" + lVariableName + "_NavigationalFilter";
if (xmlReader.IsStartElement("Filter.Variables"))
{
object[] lArgs = new object[3];
lArgs[0] = xmlReader;
lArgs[1] = dtdVersion;
lArgs[2] = lVariableName;
lFilters.Add(lFilterName, ONContext.InvoqueMethod(ONContext.GetComponent_XML(lClassName), typeof(ONNavigationalFilterXMLAttribute), "<Filter>" + lSourceFilterName + "</Filter>", lArgs) as ONFilter);
}
else
{
lFilters.Add(lFilterName, ONContext.GetComponent_Filter(lFilterName, null) as ONFilter);
}
xmlReader.ReadEndElement(); //NavFilt.Variable
}
}
// Create Context
ONContext lOnContext = new ONContext();
lOnContext.OidAgent = agentOid;
foreach (ONFilter lFilter in lFilters.Values)
{
lFilter.CheckFilterVariables(lOnContext);
}
// Execute
lOnContext.CalculateQueryInstancesNumber = true;
RevisionPasajeroQuery lQuery = new RevisionPasajeroQuery(lOnContext);
ONCollection lCollection = lQuery.QueryByFilter(lLinkedTo, lFilters, displaySet, lOrderCriteria, startRowOID, blockSize);
ticket = lOnContext.GetTicket(dtdVersion, clientName);
return(lCollection);
}
private void ParseResHeaderNode(XmlReader reader)
{
string name = reader[ResXResourceWriter.NameStr];
if (name != null)
{
reader.ReadStartElement();
// The "1.1" schema requires the correct casing of the strings
// in the resheader, however the "1.0" schema had a different
// casing. By checking the Equals first, we should
// see significant performance improvements.
if (name == ResXResourceWriter.VersionStr)
{
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderVersion = reader.ReadElementString();
}
else
{
_resHeaderVersion = reader.Value.Trim();
}
}
else if (name == ResXResourceWriter.ResMimeTypeStr)
{
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderMimeType = reader.ReadElementString();
}
else
{
_resHeaderMimeType = reader.Value.Trim();
}
}
else if (name == ResXResourceWriter.ReaderStr)
{
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderReaderType = reader.ReadElementString();
}
else
{
_resHeaderReaderType = reader.Value.Trim();
}
}
else if (name == ResXResourceWriter.WriterStr)
{
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderWriterType = reader.ReadElementString();
}
else
{
_resHeaderWriterType = reader.Value.Trim();
}
}
else
{
switch (name.ToLower(CultureInfo.InvariantCulture))
{
case ResXResourceWriter.VersionStr:
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderVersion = reader.ReadElementString();
}
else
{
_resHeaderVersion = reader.Value.Trim();
}
break;
case ResXResourceWriter.ResMimeTypeStr:
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderMimeType = reader.ReadElementString();
}
else
{
_resHeaderMimeType = reader.Value.Trim();
}
break;
case ResXResourceWriter.ReaderStr:
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderReaderType = reader.ReadElementString();
}
else
{
_resHeaderReaderType = reader.Value.Trim();
}
break;
case ResXResourceWriter.WriterStr:
if (reader.NodeType == XmlNodeType.Element)
{
_resHeaderWriterType = reader.ReadElementString();
}
else
{
_resHeaderWriterType = reader.Value.Trim();
}
break;
}
}
}
}
public static void ReadFolderRecursive(List <SiFolder> folders, XmlReader reader, int depth)
{
SiFolder newFolder = null;
while (!reader.EOF)
{
XmlNodeType nodeType = reader.NodeType;
switch (nodeType)
{
case XmlNodeType.Whitespace:
reader.Read();
break;
case XmlNodeType.Element:
switch (reader.Name)
{
case "Files":
reader.ReadStartElement();
ReadFolderRecursive(folders, reader, reader.Depth);
break;
case "File":
SiFile newFile = new SiFile();
folders.Last().Files.Add(newFile);
newFile.Filename = reader.GetAttribute("Name");
reader.ReadStartElement();
break;
case "Folders":
int newDepth = reader.Depth;
if (newDepth < depth)
{
return;
}
if (newDepth == depth)
{
newFolder = new SiFolder();
newFolder.Name = reader.GetAttribute("Name");
folders.Add(newFolder);
reader.ReadStartElement();
}
else
{
if (newFolder.Folders == null)
{
newFolder.Folders = new List <SiFolder>();
}
ReadFolderRecursive(newFolder.Folders, reader, newDepth);
}
break;
default:
reader.ReadStartElement();
break;
}
break;
case XmlNodeType.Attribute:
break;
default:
reader.Read();
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="transaction"></param>
internal static void Read(XmlReader reader, Transaction transaction, bool preApproval)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
if (preApproval == true)
{
reader.ReadStartElement(TransactionSerializerHelper.PreApproval);
}
else
{
reader.ReadStartElement(TransactionSerializerHelper.Transaction);
}
reader.MoveToContent();
while (!reader.EOF)
{
if (preApproval == true)
{
if (XMLParserUtils.IsEndElement(reader, TransactionSerializerHelper.PreApproval))
{
XMLParserUtils.SkipNode(reader);
break;
}
}
else
{
if (XMLParserUtils.IsEndElement(reader, TransactionSerializerHelper.Transaction))
{
XMLParserUtils.SkipNode(reader);
break;
}
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case TransactionSerializerHelper.Code:
transaction.Code = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Date:
transaction.Date = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.Reference:
transaction.Reference = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.TransactionType:
transaction.TransactionType = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.TransactionStatus:
if (preApproval == true)
{
transaction.Status = reader.ReadElementContentAsString();
}
else
{
transaction.TransactionStatus = reader.ReadElementContentAsInt();
}
break;
case TransactionSerializerHelper.GrossAmount:
transaction.GrossAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.DiscountAmount:
transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.FeeAmount:
transaction.FeeAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.NetAmount:
transaction.NetAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.ExtraAmount:
transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.LastEventDate:
transaction.LastEventDate = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.InstallmentCount:
transaction.InstallmentCount = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.Name:
transaction.Name = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Tracker:
transaction.Tracker = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Charge:
transaction.Charge = reader.ReadElementContentAsString();
break;
case PaymentMethodSerializer.PaymentMethod:
PaymentMethod paymentMethod = new PaymentMethod();
PaymentMethodSerializer.Read(reader, paymentMethod);
transaction.PaymentMethod = paymentMethod;
break;
case ItemListSerializer.Items:
ItemListSerializer.Read(reader, transaction.Items);
break;
case SenderSerializer.Sender:
Sender sender = new Sender();
SenderSerializer.Read(reader, sender);
transaction.Sender = sender;
break;
case ShippingSerializer.Shipping:
Shipping shipping = new Shipping();
ShippingSerializer.Read(reader, shipping);
transaction.Shipping = shipping;
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
{
LastDomOperation = reader.GetAttribute("LastDomOperation");
string needsSignatureAttribute = reader.GetAttribute("NeedsSignature");
if (!string.IsNullOrEmpty(needsSignatureAttribute))
{
NeedsSignature = bool.Parse(needsSignatureAttribute);
}
AlternativeIdentifier = reader.GetAttribute("AlternativeIdentifier");
CertHash = reader.GetAttribute("CertHash");
IdCardId = reader.GetAttribute("IdCardId");
Issuer = reader.GetAttribute("Issuer");
Password = reader.GetAttribute("Password");
Username = reader.GetAttribute("Username");
Version = reader.GetAttribute("Version");
var authenticationLevelAttribute = reader.GetAttribute("AuthenticationLevel");
if (!string.IsNullOrEmpty(authenticationLevelAttribute))
{
AuthenticationLevel = AuthenticationLevel.GetEnumeratedValue(int.Parse(authenticationLevelAttribute));
}
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Name == "CreatedDate")
{
reader.ReadStartElement();
this.CreatedDate = (DateTime) new XmlSerializer(typeof(DateTime)).Deserialize(reader);
reader.ReadEndElement();
}
if (reader.Name == "ExpiryDate")
{
reader.ReadStartElement();
this.ExpiryDate = (DateTime) new XmlSerializer(typeof(DateTime)).Deserialize(reader);
reader.ReadEndElement();
}
if (reader.Name == "Xassertion")
{
reader.ReadStartElement();
//this.Xassertion = XElement.ReadFrom(reader.ReadSubtree()).Parent;
this.Xassertion = XElement.Parse(reader.ReadOuterXml(), LoadOptions.PreserveWhitespace);
}
if (reader.Name == "SystemInfo")
{
this.SystemInfo = new SystemInfo(null, null);
(this.SystemInfo as IXmlSerializable).ReadXml(reader);
}
if (reader.Name == "UserInfo")
{
this.UserInfo = new UserInfo(null, null, null, null, null, null, null);
(this.UserInfo as IXmlSerializable).ReadXml(reader);
}
}
}
}
//reader.ReadEndElement();
}
public void ReadXML(XmlReader reader)
{
reader.ReadStartElement();
while (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "TimecodeFormat":
timecodeFormat = (TimecodeFormat)Enum.Parse(typeof(TimecodeFormat), reader.ReadElementContentAsString());
break;
case "SpeedUnit":
speedUnit = (SpeedUnit)Enum.Parse(typeof(SpeedUnit), reader.ReadElementContentAsString());
break;
case "AccelerationUnit":
accelerationUnit = (AccelerationUnit)Enum.Parse(typeof(AccelerationUnit), reader.ReadElementContentAsString());
break;
case "AngleUnit":
angleUnit = (AngleUnit)Enum.Parse(typeof(AngleUnit), reader.ReadElementContentAsString());
break;
case "AngularVelocityUnit":
angularVelocityUnit = (AngularVelocityUnit)Enum.Parse(typeof(AngularVelocityUnit), reader.ReadElementContentAsString());
break;
case "AngularAccelerationUnit":
angularAccelerationUnit = (AngularAccelerationUnit)Enum.Parse(typeof(AngularAccelerationUnit), reader.ReadElementContentAsString());
break;
case "CustomLengthUnit":
customLengthUnit = reader.ReadElementContentAsString();
break;
case "CustomLengthAbbreviation":
customLengthAbbreviation = reader.ReadElementContentAsString();
break;
case "AspectRatio":
aspectRatio = (ImageAspectRatio)Enum.Parse(typeof(ImageAspectRatio), reader.ReadElementContentAsString());
break;
case "DeinterlaceByDefault":
deinterlaceByDefault = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "InteractiveFrameTracker":
interactiveFrameTracker = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "WorkingZoneMemory":
workingZoneMemory = reader.ReadElementContentAsInt();
break;
case "SyncLockSpeed":
syncLockSpeed = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "SyncByMotion":
syncByMotion = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "ImageFormat":
imageFormat = (KinoveaImageFormat)Enum.Parse(typeof(KinoveaImageFormat), reader.ReadElementContentAsString());
break;
case "VideoFormat":
videoFormat = (KinoveaVideoFormat)Enum.Parse(typeof(KinoveaVideoFormat), reader.ReadElementContentAsString());
break;
case "Background":
backgroundColor = XmlHelper.ParseColor(reader.ReadElementContentAsString(), defaultBackgroundColor);
break;
case "InfoFading":
defaultFading.ReadXml(reader);
break;
case "DrawOnPlay":
drawOnPlay = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "RecentColors":
ParseRecentColors(reader);
break;
case "MaxRecentColors":
maxRecentColors = reader.ReadElementContentAsInt();
break;
case "TrackingProfile":
trackingProfile.ReadXml(reader);
break;
case "EnableFiltering":
enableFiltering = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "EnableCustomToolsDebugMode":
enableCustomToolsDebugMode = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "DefaultReplaySpeed":
string str = reader.ReadElementContentAsString();
defaultReplaySpeed = float.Parse(str, CultureInfo.InvariantCulture);
break;
case "DetectImageSequences":
detectImageSequences = XmlHelper.ParseBoolean(reader.ReadElementContentAsString());
break;
case "PreloadKeyframes":
preloadKeyframes = reader.ReadElementContentAsInt();
break;
case "PlaybackKVA":
playbackKVA = reader.ReadElementContentAsString();
break;
default:
reader.ReadOuterXml();
break;
}
}
reader.ReadEndElement();
}
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();
}
private void LoadSettings(ref bool UseLastFile, ref bool CompileBeforeUpload, ref string OpenedFile)
{
if (File.Exists(Path.Combine("Tools", "Settings.xml")))
{
XmlReader reader = null;
try
{
reader = XmlReader.Create(Path.Combine("Tools", "Settings.xml"));
reader.ReadStartElement("Settings");
string open = reader.ReadElementString("OpenLastFile");
string compile = reader.ReadElementString("CompileBeforeUpload");
string LastFile = reader.ReadElementString("LastFile");
string Optim = reader.ReadElementString("Optimalize");
string Brd = reader.ReadElementString("Board");
reader.Close();
if (open == "1")
{
UseLastFile = true;
}
else
{
UseLastFile = false;
}
if (compile == "1")
{
CompileBeforeUpload = true;
}
else
{
CompileBeforeUpload = false;
}
if (Optim == "Size")
{
Optimalize = Optimalize.Size;
}
else
{
Optimalize = Optimalize.Speed;
}
Board = (Board)Convert.ToInt32(Brd);
OpenedFile = LastFile;
if (LastFile == "" || !UseLastFile)
{
OpenedFile = FindNewNumber();
}
OpenNewTab(OpenedFile);
}
catch (Exception)
{
if (reader != null)
{
reader.Close();
}
File.Delete(Path.Combine("Tools", "Settings.xml"));
}
}
if (!File.Exists(Path.Combine("Tools", "Settings.xml")))
{
UseLastFile = false;
CompileBeforeUpload = true;
string max = "0";
foreach (FileInfo file in new DirectoryInfo("Projects").GetFiles("Project_*.cpp"))
{
max = file.Name.Substring(8, file.Name.Length - 8 - 4);
}
OpenedFile = Path.Combine("Projects", "Project_" + (Convert.ToInt32(max) + 1) + ".cpp");
SaveSettings(UseLastFile, CompileBeforeUpload, OpenedFile);
OpenNewTab(OpenedFile);
}
}
/// <summary>
/// Reads the XML.
/// </summary>
/// <param name="reader">The reader.</param>
/// <exception cref="InvalidDataException">
/// Invalid XML document for Db import. index is unset
/// or
/// Invalid XML document for Db import. type is unset
/// or
/// or
/// Invalid XML document for Db import. index for a table is unset
/// </exception>
public void ReadXml(XmlReader reader)
{
reader.Read();
reader.ReadStartElement(DatabaseName);
reader.ReadStartElement(ReprosIncluded);
var elements = new Dictionary <string, Type>();
do
{
var indexOfElementString = reader.GetAttribute("Index");
var typeString = reader.GetAttribute("Type");
if (indexOfElementString == null)
{
throw new InvalidDataException("Invalid XML document for Db import. index is unset");
}
if (typeString == null)
{
throw new InvalidDataException("Invalid XML document for Db import. type is unset");
}
var type = Type.GetType(typeString);
if (type == null)
{
throw new InvalidDataException(string.Format("Invalid XML document for Db import. type is invalid '{0}'",
typeString));
}
elements.Add(indexOfElementString, type);
} while (reader.Read() && reader.Name == ReproIncluded);
reader.ReadEndElement();
reader.ReadStartElement(DatabaseContent);
using (var transaction = new TransactionScope())
{
using (DbReposetoryIdentityInsertScope.CreateOrObtain())
{
do
{
var indexOfElementString = reader.GetAttribute("Index");
if (indexOfElementString == null)
{
throw new InvalidDataException("Invalid XML document for Db import. index for a table is unset");
}
reader.ReadStartElement(TableContentList);
var type = elements[indexOfElementString];
var table =
LocalDbManager.Scope.Database.First(s => s.Key.AssemblyQualifiedName == type.AssemblyQualifiedName).Value;
if (table == null)
{
throw new InvalidDataException("Invalid Database config for Db import. There is no Table for the type " + type);
}
reader.ReadStartElement(TableContentElementsList);
do
{
object emptyElement = table.TypeInfo.DefaultFactory();
reader.ReadStartElement(table.TypeInfo.TableName);
do
{
var propName = reader.Name;
var isNumm = reader.IsEmptyElement;
var value = reader.ReadElementContentAsString();
var dbPropertyInfoCache = table.TypeInfo.Propertys[table.TypeInfo.SchemaMappingDatabaseToLocal(propName)];
object contvertedValue = value;
if (!isNumm)
{
if (DataConverterExtensions.ChangeType(ref contvertedValue,
dbPropertyInfoCache.PropertyType))
{
dbPropertyInfoCache.Setter.Invoke(emptyElement, contvertedValue);
}
}
} while (reader.Name != table.TypeInfo.TableName);
reader.ReadEndElement();
table.Add(emptyElement);
} while (reader.Name == table.TypeInfo.TableName);
reader.ReadEndElement();
//for newer indexer tags. Currently unsupported
if (reader.Name == IndexerIncluded)
{
reader.ReadStartElement(IndexerIncluded);
reader.ReadEndElement();
}
} while (reader.Name != DatabaseContent);
transaction.Complete();
}
}
}
private void InternalRead(XmlReader reader)
{
_ancestors.Clear();
reader.MoveToContent();
reader.ReadStartElement(DilxElementName, DilxNamespace);
while (reader.MoveToContent() == XmlNodeType.Element)
{
if
(
String.Equals(reader.Name, AncestorElementName, StringComparison.OrdinalIgnoreCase) &&
String.Equals(reader.NamespaceURI, DilxNamespace, StringComparison.OrdinalIgnoreCase)
)
{
if (!reader.MoveToAttribute(AncestorDocumentAttributeName))
{
throw new BOPException(BOPException.Codes.InvalidNode, reader.Name);
}
_ancestors.Add(reader.Value);
reader.Skip();
}
else if
(
String.Equals(reader.Name, DocumentElementName, StringComparison.OrdinalIgnoreCase) &&
String.Equals(reader.NamespaceURI, DilxNamespace, StringComparison.OrdinalIgnoreCase)
)
{
reader.ReadStartElement();
// NOTE: This mechanism was added to prevent non-space whitespace from being converted to spaces by attribute normalization when reading the embedded document
// However, the use of a CDATA section makes the resulting DFDXs unreadable, so the writer will no longer write this way, but the reader must still be able to
// read content this way.
// Support either CDATA (new method) or direct embedding of the interface (for backwards compatability)
if (reader.MoveToContent() == XmlNodeType.CDATA)
{
_content = reader.ReadContentAsString();
}
else
{
_content = reader.ReadOuterXml();
// If we are reading as an Xml document, entities in attribute values will be converted to tab characters.
// These must be converted back to entities or they will be normalized away by subsequent xml readers.
_content = ConvertSignificantWhitespaceToEntities(_content);
}
// Strip out the dilx namespace due to embedding of document withing outer document
// TODO: Refactor this to actually parse the arguments
string defaultNamespace = String.Format("xmlns=\"{0}\"", DilxNamespace);
int contentIndex = _content.IndexOf(defaultNamespace);
if (contentIndex >= 0)
{
_content = _content.Remove(contentIndex, defaultNamespace.Length);
}
// Make sure there is nothing after the document node
reader.Skip();
while (reader.MoveToContent() == XmlNodeType.EndElement)
{
reader.Skip();
}
if (!reader.EOF)
{
throw new BOPException(BOPException.Codes.DocumentElementLast);
}
return;
}
else
{
throw new BOPException(BOPException.Codes.InvalidNode, reader.Name);
}
}
throw new BOPException(BOPException.Codes.DocumentElementRequired);
}
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();
}
}
PlistObjectBase LoadFromNode(XmlReader reader)
{
Debug.Assert(reader.NodeType == XmlNodeType.Element);
bool isEmpty = reader.IsEmptyElement;
switch (reader.LocalName)
{
case "dict":
var dict = new PlistDictionary(true);
if (!isEmpty)
{
if (reader.ReadToDescendant("key"))
{
dict = LoadDictionaryContents(reader, dict);
}
reader.ReadEndElement();
}
return(dict);
case "array":
if (isEmpty)
{
return(new PlistArray());
}
//advance to first node
reader.ReadStartElement();
while (reader.Read() && reader.NodeType != XmlNodeType.Element)
{
;
}
// HACK: plist data in iPods is not even valid in some cases! Way to go Apple!
// This hack checks to see if they really meant for this array to be a dict.
if (reader.LocalName == "key")
{
var ret = LoadDictionaryContents(reader, new PlistDictionary(true));
reader.ReadEndElement();
return(ret);
}
var arr = new PlistArray();
do
{
if (reader.NodeType == XmlNodeType.Element)
{
var val = LoadFromNode(reader);
if (val != null)
{
arr.Add(val);
}
}
} while (reader.Read() && reader.NodeType != XmlNodeType.EndElement);
reader.ReadEndElement();
return(arr);
case "string":
return(new PlistString(reader.ReadElementContentAsString()));
case "integer":
return(new PlistInteger(reader.ReadElementContentAsInt()));
case "real":
return(new PlistReal(reader.ReadElementContentAsFloat()));
case "false":
reader.ReadStartElement();
if (!isEmpty)
{
reader.ReadEndElement();
}
return(new PlistBoolean(false));
case "true":
reader.ReadStartElement();
if (!isEmpty)
{
reader.ReadEndElement();
}
return(new PlistBoolean(true));
case "data":
return(new PlistData(reader.ReadElementContentAsString()));
case "date":
#if NETFX_CORE
return(new PlistDate(DateTime.Parse(reader.ReadElementContentAsString())));
#else
return(new PlistDate(reader.ReadElementContentAsDateTime()));
#endif
default:
throw new XmlException(String.Format("Plist Node `{0}' is not supported", reader.LocalName));
}
}
