| public MoveToContent ( ) : System.Xml.XmlNodeType | ||
| return | System.Xml.XmlNodeType | |
internal static ResolveCriteria ReadXml (XmlReader reader, DiscoveryVersion version)
{
if (reader == null)
throw new ArgumentNullException ("reader");
var ret = new ResolveCriteria ();
reader.MoveToContent ();
if (!reader.IsStartElement ("ResolveType", version.Namespace) || reader.IsEmptyElement)
throw new XmlException ("Non-empty ResolveType element is expected");
reader.ReadStartElement ("ResolveType", version.Namespace);
// standard members
reader.MoveToContent ();
ret.Address = EndpointAddress.ReadFrom (version.MessageVersion.Addressing, reader);
// non-standard members
for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) {
if (reader.NamespaceURI == SerializationNS) {
switch (reader.LocalName) {
case "Duration":
ret.Duration = (TimeSpan) reader.ReadElementContentAs (typeof (TimeSpan), null);
break;
}
}
else
ret.Extensions.Add (XElement.Load (reader));
}
reader.ReadEndElement ();
return ret;
}
public object Deserialize(XmlReader xmlReader)
{
XmlRootAttribute xmlRootAttribute = (XmlRootAttribute) _type.GetCustomAttributes(typeof(XmlRootAttribute), false).SingleOrDefault();
string rootElement = null == xmlRootAttribute
? _type.Name
: xmlRootAttribute.ElementName;
xmlReader.MoveToContent();
if (xmlReader.LocalName != rootElement)
{
throw new XmlException("Unexpected element");
}
object res = DeserializeCheckedElement(xmlReader, _type);
// skip end tag
while (xmlReader.Read())
{
xmlReader.MoveToContent();
}
if (! xmlReader.EOF)
{
throw new XmlException("Invalid xml content");
}
return res;
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.AttributeCount == 0)
throw new MissingXmlAttributeException(@"Missing XML attribute ""value"".");
Name = reader["name"];
if (reader.IsEmptyElement)
{
reader.ReadEndElement();
return;
}
if (reader.ReadToDescendant(ChildXmlTag))
{
while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == ChildXmlTag)
{
reader.ReadStartElement();
reader.MoveToContent();
IilParameter p = IilParameter.fromString(reader.LocalName);
p.ReadXml(reader);
Parameters.Add(p);
reader.ReadEndElement();
}
}
reader.ReadEndElement();
//reader.Read();
}
public static IFeed GetFeed(Uri url, XmlReader reader) {
reader.MoveToContent();
string language = string.Empty;
FeedType feedType;
string namespaceUri = reader.NamespaceURI;
if(reader.LocalName.Equals("RDF") &&
reader.NamespaceURI.Equals("http://www.w3.org/1999/02/22-rdf-syntax-ns#")) {
feedType = FeedType.Rdf;
reader.Read();
reader.MoveToContent();
} else if(reader.LocalName.Equals("rss")) {
feedType = FeedType.Rss;
do {
reader.Read();
reader.MoveToContent();
} while(!reader.LocalName.Equals("channel") && !reader.LocalName.Equals("rss"));
} else if(reader.NamespaceURI.Equals("http://purl.org/atom/ns#") && reader.LocalName.Equals("feed")) {
if(reader.MoveToAttribute("version") && reader.Value.Equals("0.3")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
reader.MoveToElement();
} else {
throw new ApplicationException(string.Format("Unsupported Atom Version {0}", reader.Value));
}
} else if(reader.NamespaceURI.Equals("http://www.w3.org/2005/Atom") && reader.LocalName.Equals("feed")) {
feedType = FeedType.Atom;
language = reader.XmlLang;
} else {
throw new ApplicationException("Unknown Xml Dialect");
}
return PopulateFeed(url, reader, namespaceUri, feedType, language);
}
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();
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
var empty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!empty)
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (reader.Name == @"ProductName" && !reader.IsEmptyElement)
{
ProductName = reader.ReadElementString();
}
else if (reader.Name == @"GlyphColor" && !reader.IsEmptyElement)
{
GlyphColor = ParseColor(reader.ReadElementString());
}
else
{
// consume the bad element and skip to next sibling or the parent end element tag
reader.ReadOuterXml();
}
}
reader.MoveToContent();
reader.ReadEndElement();
}
}
private void ProcessItem(XmlReader reader)
{
reader.MoveToContent();
Material tmpMaterial = new Material();
tmpMaterial.name = reader.GetAttribute("displayname");
tmpMaterial.type = reader.GetAttribute("type");
if (reader.ReadToFollowing("ambient"))
{
reader.MoveToContent();
tmpMaterial.ambient.R = (float)Convert.ToDouble(reader.GetAttribute("r").Replace(".", ","));
tmpMaterial.ambient.G = (float)Convert.ToDouble(reader.GetAttribute("g").Replace(".", ","));
tmpMaterial.ambient.B = (float)Convert.ToDouble(reader.GetAttribute("b").Replace(".", ","));
tmpMaterial.ambient.A = (float)Convert.ToDouble(reader.GetAttribute("a").Replace(".", ","));
}
if (reader.ReadToFollowing("specular"))
{
reader.MoveToContent();
tmpMaterial.specular.R = (float)Convert.ToDouble(reader.GetAttribute("r").Replace(".", ","));
tmpMaterial.specular.G = (float)Convert.ToDouble(reader.GetAttribute("g").Replace(".", ","));
tmpMaterial.specular.B = (float)Convert.ToDouble(reader.GetAttribute("b").Replace(".", ","));
tmpMaterial.specular.A = (float)Convert.ToDouble(reader.GetAttribute("a").Replace(".", ","));
}
if (reader.ReadToFollowing("diffuse"))
{
reader.MoveToContent();
tmpMaterial.diffuse.R = (float)Convert.ToDouble(reader.GetAttribute("r").Replace(".", ","));
tmpMaterial.diffuse.G = (float)Convert.ToDouble(reader.GetAttribute("g").Replace(".", ","));
tmpMaterial.diffuse.B = (float)Convert.ToDouble(reader.GetAttribute("b").Replace(".", ","));
tmpMaterial.diffuse.A = (float)Convert.ToDouble(reader.GetAttribute("a").Replace(".", ","));
}
if (reader.ReadToFollowing("emissive"))
{
reader.MoveToContent();
tmpMaterial.emission.R = (float)Convert.ToDouble(reader.GetAttribute("r").Replace(".", ","));
tmpMaterial.emission.G = (float)Convert.ToDouble(reader.GetAttribute("g").Replace(".", ","));
tmpMaterial.emission.B = (float)Convert.ToDouble(reader.GetAttribute("b").Replace(".", ","));
tmpMaterial.emission.A = (float)Convert.ToDouble(reader.GetAttribute("a").Replace(".", ","));
}
if (reader.ReadToFollowing("shininess"))
{
reader.MoveToContent();
tmpMaterial.shininess = (float)Convert.ToDouble(reader.GetAttribute("value").Replace(".", ","));
}
if (reader.ReadToFollowing("texture"))
{
reader.MoveToContent();
tmpMaterial.LoadTexture(reader.GetAttribute("file"));
}
this.lstMaterial.Add(tmpMaterial);
}
private static PinboardData ReadPinboardXml(XmlReader reader)
{
PinboardData data = new PinboardData();
reader.ReadStartElement("Pinboard");
reader.MoveToContent();
data.ScreenRectInfo = ReadRectangleXml(reader);
data.RectInfos = ReadRectanglesXml(reader);
reader.ReadEndElement();
reader.MoveToContent();
return data;
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
inputController = System.Type.GetType(reader.ReadElementString("inputController"));
inputControllerBackup = System.Type.GetType(reader.ReadElementString("inputControllerBackup"));
xResolution = System.Convert.ToInt32(reader.ReadElementString("xResolution"));
yResolution = System.Convert.ToInt32(reader.ReadElementString("yResolution"));
fullscreen = System.Convert.ToBoolean(reader.ReadElementString("fullscreen"));
showDebug = System.Convert.ToBoolean(reader.ReadElementString("showDebug"));
showConfigurator = System.Convert.ToBoolean(reader.ReadElementString("showConfigurator"));
projectorBlend = System.Convert.ToBoolean(reader.ReadElementString("projectorBlend"));
brakeAxis = reader.ReadElementString("brakeAxis");
gasAxis = reader.ReadElementString("gasAxis");
minBrake = System.Convert.ToInt32(reader.ReadElementString("minBrake"));
maxBrake = System.Convert.ToInt32(reader.ReadElementString("maxBrake"));
minGas = System.Convert.ToInt32(reader.ReadElementString("minGas"));
maxGas = System.Convert.ToInt32(reader.ReadElementString("maxGas"));
minBrakeFanatec = System.Convert.ToInt32(reader.ReadElementString("minBrakeFanatec"));
maxBrakeFanatec = System.Convert.ToInt32(reader.ReadElementString("maxBrakeFanatec"));
minGasFanatec = System.Convert.ToInt32(reader.ReadElementString("minGasFanatec"));
maxGasFanatec = System.Convert.ToInt32(reader.ReadElementString("maxGasFanatec"));
FFBMultiplier = System.Convert.ToSingle(reader.ReadElementString("FFBMultiplier"));
reader.ReadEndElement();
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
num = int.Parse(reader.GetAttribute("number"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "class")
{
var sClass = new ScheduleClass();
sClass.ReadFromXml(reader);
classes.Add(sClass);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public virtual void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.HasAttributes)
while (reader.MoveToNextAttribute())
AttributeWasRead(reader.Name, reader.Value);
AllAttributesRead();
var isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
while (reader.Read())
{
var nodeType = reader.NodeType;
switch (nodeType)
{
case XmlNodeType.Text:
var content = reader.ReadContentAsString();
ContentWasRead(string.Empty, content);
break;
case XmlNodeType.Element:
var name = reader.Name;
ProcessElement(name, reader);
break;
}
}
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Transform":
XmlTransformElement transform = new XmlTransformElement();
transform.ReadXml(reader);
Transform = transform;
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Format":
Format = reader.ReadElementContentAsString();
break;
case "OnlineResource":
OnlineResource = new OnlineResource();
OnlineResource.ReadXml(reader);
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
}
}
}
public static KeyValuePair<string, Property> ReadXml(XmlReader reader)
{
var key = reader.GetAttribute("Key");
var type = reader.GetAttribute("Type");
reader.MoveToElement();
reader.ReadStartElement("PropertyEntry");
Property value = null;
try
{
var t = Type.GetType(type);
value = (Property)GetSerializer(t).Deserialize(reader);
}
catch (Exception ex)
{
Console.WriteLine("Deserialization failed: " + ex.Message);
Console.WriteLine("Property Key: " + key);
Console.WriteLine("Property Type Qualified Name: " + type);
Console.WriteLine("Stacktrace: " + ex.StackTrace);
}
reader.ReadEndElement();
reader.MoveToContent();
if (value == null)
throw new Exception();
return new KeyValuePair<string, Property>(key, value);
}
// ReSharper restore InconsistentNaming
#region Overrides of XmlObject
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.LocalName)
{
case "Format":
Format.Add(reader.ReadElementContentAsString());
break;
case "DCPType":
var tmp = new DCPType();
tmp.ReadXml(reader);
DCPType.Add(tmp);
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
}
}
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
CRS = reader.GetAttribute("CRS");
double val;
if (double.TryParse(reader.GetAttribute("minx"), NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
MinX = val;
if (double.TryParse(reader.GetAttribute("maxx"), NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
MaxX = val;
if (double.TryParse(reader.GetAttribute("miny"), NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
MinY = val;
if (double.TryParse(reader.GetAttribute("maxy"), NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
MaxY = val;
var res = reader.GetAttribute("resx");
if (res != null && double.TryParse(res, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
ResX = val;
res = reader.GetAttribute("resy");
if (res != null && double.TryParse(res, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out val))
ResY = val;
var isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (!isEmptyElement)
{
reader.ReadEndElement();
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
DefaultAnimation = reader["DefaultAnimation"];
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Activity":
XmlActivityElement activity = new XmlActivityElement();
activity.ReadXml(reader);
Activities.Add(activity);
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
/// <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 override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
Descriptor = Xml.Read<Descriptor>(reader);
Root = Xml.Read<Measure>(reader);
}
public IEnumerable<Node> ParseRequest(XmlReader rdr)
{
rdr.MoveToContent();
if (rdr.Name != "methodCall")
throw new XmlRpcInvalidXmlRpcException(
"Request XML not valid XML-RPC - root element not methodCall.");
int mcDepth = rdr.Depth;
MoveToChild(rdr, "methodName", true);
int mnDepth = rdr.Depth;
string methodName = rdr.ReadElementContentAsString();
if (methodName == "")
throw new XmlRpcInvalidXmlRpcException(
"Request XML not valid XML-RPC - empty methodName.");
yield return CreateMethodName(methodName);
if (MovetoSibling(rdr, "params", false))
{
yield return new ParamsNode(_depth);
int psDepth = rdr.Depth;
bool gotP = MoveToChild(rdr, "param", false);
while (gotP)
{
foreach (Node node in ParseParam(rdr))
yield return node;
gotP = MovetoSibling(rdr, "param");
}
MoveToEndElement(rdr, psDepth);
}
MoveToEndElement(rdr, mcDepth);
}
public static bool CanRead (XmlReader xmlReader)
{
xmlReader.MoveToContent ();
return xmlReader.NodeType == XmlNodeType.Element &&
xmlReader.LocalName == "discovery" &&
xmlReader.NamespaceURI == Namespace;
}
public void ReadXml(XmlReader reader)
{
int count;
reader.MoveToContent();
int.TryParse(reader["ChildrenCount"], out count);
reader.ReadStartElement("Professionbuddy");
PrioritySelector ps = (PrioritySelector)DecoratedChild;
for (int i = 0; i < count; i++)
{
Type type = Type.GetType("HighVoltz.Composites." + reader.Name);
if (type != null)
{
IPBComposite comp = (IPBComposite)Activator.CreateInstance(type);
if (comp != null)
{
comp.ReadXml(reader);
ps.AddChild((Composite)comp);
}
}
else
{
Professionbuddy.Err("PB:Failed to load type {0}", type);
}
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement();
}
public void ReadXml(XmlReader reader)
{
DebugStates = new List<DebugState>();
reader.MoveToContent();
reader.ReadStartElement();
while(reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugState")
{
var item = new DebugState();
item.ReadXml(reader);
DebugStates.Add(item);
}
reader.ReadEndElement();
}
private void ReadElement(XmlReader reader, Bag parent) {
var name = XmlConvert.DecodeName(reader.LocalName);
var type = reader["type"];
// is it a value node ? i.e. type=""
if (type != null) {
if (type == "Array") {
// go to first item
parent.SetMember(name, ReadArray(reader));
reader.Read();
}
else {
var typeCode = (TypeCode)Enum.Parse(typeof(TypeCode), type);
var value = SConvert.XmlDecode(typeCode, reader.ReadElementString());
parent.SetMember(name, value);
}
}
else {
var grappe = new Bag();
reader.Read();
parent.SetMember(name, grappe);
while (reader.MoveToContent() == XmlNodeType.Element) {
ReadElement(reader, grappe);
}
reader.Read();
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
type = reader.GetAttribute("type");
code = reader.GetAttribute("code");
location = reader.GetAttribute("location");
string time = reader.GetAttribute("time");
if (time.Length == 5)
{
hours = int.Parse(time.Substring(0, 2));
minutes = int.Parse(time.Substring(3, 2));
}
else if (time.Length == 4)
{
hours = int.Parse(time.Substring(0, 1));
minutes = int.Parse(time.Substring(2, 2));
}
string weekStr;
if ((weekStr = reader.GetAttribute("week")) != null)
week = int.Parse(weekStr);
else
week = 0;
if ((group = reader.GetAttribute("group")) == null)
group = "";
reader.Skip();
}
public override bool CanRead (XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException ("reader");
reader.MoveToContent ();
return reader.LocalName == "service" && reader.NamespaceURI == Version;
}
public IEnumerable<Node> ParseResponse(XmlReader rdr)
{
rdr.MoveToContent();
if (rdr.Name != "methodResponse")
throw new XmlRpcInvalidXmlRpcException(
"Response XML not valid XML-RPC - root element not methodResponse.");
int mrDepth = rdr.Depth;
MoveToChild(rdr, "params", "fault");
if (rdr.Name == "params")
{
yield return new ResponseNode(_depth);
int psDepth = rdr.Depth;
bool gotP = MoveToChild(rdr, "param");
if (gotP)
{
foreach (Node node in ParseParam(rdr))
yield return node;
}
MoveToEndElement(rdr, psDepth);
}
else
{
int fltDepth = rdr.Depth;
foreach (Node node in ParseFault(rdr))
yield return node;
MoveToEndElement(rdr, fltDepth);
}
MoveToEndElement(rdr, mrDepth);
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.MoveToContent() == XmlNodeType.Element &&
reader.LocalName == "model-item")
{
var type_ = reader["type"];
if (type_ != null)
type = (XName)type_;
var readOnly_ = reader["readonly"];
if (readOnly_ != null)
readOnly = bool.Parse(readOnly_);
var required_ = reader["required"];
if (required_ != null)
required = bool.Parse(required_);
var relevant_ = reader["relevant"];
if (relevant_ != null)
relevant = bool.Parse(relevant_);
var constraint_ = reader["constraint"];
if (constraint_ != null)
constraint = bool.Parse(constraint_);
var valid_ = reader["valid"];
if (valid_ != null)
valid = bool.Parse(valid_);
}
}
public void ReadFromXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) { reader.Read(); return; }
semesterStart = DateTime.Parse(reader.GetAttribute("semesterStart"));
reader.Read();
while (!reader.EOF)
{
if (reader.IsStartElement())
{
if (reader.Name == "weekday")
{
var weekday = new ScheduleWeekday();
weekday.ReadFromXml(reader);
weekdays.Add(weekday);
}
else
{
reader.Skip();
}
}
else
{
reader.Read();
break;
}
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Repeat = Convert.ToInt32(reader["Repeat"], CultureInfo.InvariantCulture);
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Frames":
ReadFramesXml(reader);
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Source = reader["Source"];
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Sprite":
XmlSpriteElement sprite = new XmlSpriteElement();
sprite.ReadXml(reader);
Sprites.Add(sprite);
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
/// <summary>
/// Initializes the object with a XML reader.
/// </summary>
public XmlDecoder(System.Type systemType, XmlReader reader, ServiceMessageContext context)
{
Initialize();
m_reader = reader;
m_context = context;
string ns = null;
string name = null;
if (systemType != null)
{
XmlQualifiedName typeName = EncodeableFactory.GetXmlName(systemType);
ns = typeName.Namespace;
name = typeName.Name;
}
if (ns == null)
{
m_reader.MoveToContent();
ns = m_reader.NamespaceURI;
name = m_reader.Name;
}
int index = name.IndexOf(':');
if (index != -1)
{
name = name.Substring(index + 1);
}
PushNamespace(ns);
BeginField(name, false);
}
public static string InnerXml(this XElement node)
{
Debug.Assert(node != null);
System.Xml.XmlReader reader = node.CreateReader();
_ = reader.MoveToContent();
return(reader.ReadInnerXml());
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
if (wasEmpty)
{
return;
}
string line = "";
if ((line = reader.GetAttribute("ItemAlias")) != null)
{
itemAlias = line;
}
if ((line = reader.GetAttribute("KeyAlias")) != null)
{
keyAlias = line;
}
if ((line = reader.GetAttribute("ValueAlias")) != null)
{
valueAlias = line;
}
reader.Read();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement(itemAlias);
reader.ReadStartElement(keyAlias);
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(valueAlias);
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
//bool keyIsString = typeof(TKey) == typeof(string);
bool keyIsString = typeof(TKey).FindInterfaces((n, k) => n.ToString() == k.ToString(), "System.IConvertible").Length > 0;
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (keyIsString)
{
/*
* var ms = new MemoryStream(Encoding.Unicode.GetBytes(reader.GetAttribute("key")));
* TKey key = (TKey)keySerializer.Deserialize(ms);
*/
string at = reader.GetAttribute("key");
TKey key = (TKey)Convert.ChangeType(at, typeof(TKey));
reader.ReadStartElement("item");
TValue value = (TValue)valueSerializer.Deserialize(reader);
this.Add(key, value);
}
else
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
}
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
var isKeySimpleType = typeof(TKey).IsEnum || typeof(TKey).IsValueType || typeof(TKey) == typeof(string);
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = default(TKey);
if (isKeySimpleType)
{
if (typeof(TKey) == typeof(string))
{
Object t = reader.GetAttribute("key_value");
key = (TKey)t;
}
}
else
{
key = (TKey)valueSerializer.Deserialize(reader);
}
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
// XmlSerializer valueSerializer = new XmlSerializer( typeof( TValue ) );
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = ( TKey )keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
System.Runtime.Serialization.DataContractSerializer serializer =
new System.Runtime.Serialization.DataContractSerializer(typeof(TValue), null, int.MaxValue, false, false, null, new Microsoft.Xrm.Sdk.KnownTypesResolver());
TValue value = (TValue)serializer.ReadObject(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string key = reader.Name;
reader.ReadStartElement();
string value = reader.ReadContentAsString();
reader.ReadEndElement();
this[key] = value;
reader.MoveToContent();
}
reader.ReadEndElement();
}
int RecurseWorkUnit(AssetType in_type, System.IO.FileInfo in_workUnit, string in_currentPathInProj, string in_currentPhysicalPath, LinkedList <AkWwiseProjectData.PathElement> in_pathAndIcons, string in_parentPhysicalPath = "")
{
m_WwuToProcess.Remove(in_workUnit.FullName);
System.Xml.XmlReader reader = null;
int wwuIndex = -1;
try
{
//Progress bar stuff
string msg = "Parsing Work Unit " + in_workUnit.Name;
EditorUtility.DisplayProgressBar(s_progTitle, msg, (float)m_currentWwuCnt / (float)m_totWwuCnt);
m_currentWwuCnt++;
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name), AkWwiseProjectData.WwiseObjectType.WORKUNIT));
string WwuPhysicalPath = System.IO.Path.Combine(in_currentPhysicalPath, in_workUnit.Name);
AkWwiseProjectData.WorkUnit wwu = null;
ReplaceWwuEntry(WwuPhysicalPath, in_type, out wwu, out wwuIndex);
wwu.ParentPhysicalPath = in_parentPhysicalPath;
wwu.PhysicalPath = WwuPhysicalPath;
wwu.Guid = "";
wwu.SetLastTime(System.IO.File.GetLastWriteTime(in_workUnit.FullName));
reader = System.Xml.XmlReader.Create(in_workUnit.FullName);
reader.MoveToContent();
reader.Read();
while (!reader.EOF && reader.ReadState == System.Xml.ReadState.Interactive)
{
if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("WorkUnit"))
{
if (wwu.Guid.Equals(""))
{
wwu.Guid = reader.GetAttribute("ID");
}
string persistMode = reader.GetAttribute("PersistMode");
if (persistMode == "Reference")
{
// ReadFrom advances the reader
var matchedElement = System.Xml.Linq.XNode.ReadFrom(reader) as System.Xml.Linq.XElement;
string newWorkUnitPath = System.IO.Path.Combine(in_workUnit.Directory.FullName, matchedElement.Attribute("Name").Value + ".wwu");
var newWorkUnit = new System.IO.FileInfo(newWorkUnitPath);
// Parse the referenced Work Unit
if (m_WwuToProcess.Contains(newWorkUnit.FullName))
{
RecurseWorkUnit(in_type, newWorkUnit, in_currentPathInProj, in_currentPhysicalPath, in_pathAndIcons, WwuPhysicalPath);
}
}
else
{
// If the persist mode is "Standalone" or "Nested", it means the current XML tag
// is the one corresponding to the current file. We can ignore it and advance the reader
reader.Read();
}
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("AuxBus"))
{
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.AUXBUS));
bool isEmpty = reader.IsEmptyElement;
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
if (isEmpty)
{
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
}
}
// Busses and folders act the same for the Hierarchy: simply add them to the path
else if (reader.NodeType == System.Xml.XmlNodeType.Element && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus")))
{
//check if node has children
if (!reader.IsEmptyElement)
{
// Add the folder/bus to the path
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
if (reader.Name.Equals("Folder"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.FOLDER));
}
else if (reader.Name.Equals("Bus"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.BUS));
}
}
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.EndElement && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus") || reader.Name.Equals("AuxBus")))
{
// Remove the folder/bus from the path
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals(in_type.XmlElementName))
{
// Add the element to the list
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
}
else
{
reader.Read();
}
}
// Sort the newly populated Wwu alphabetically
SortWwu(in_type.RootDirectoryName, wwuIndex);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
wwuIndex = -1;
}
if (reader != null)
{
reader.Close();
}
in_pathAndIcons.RemoveLast();
return(wwuIndex);
}
/// <summary>
/// Generates a serializable continuation token from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the continuation token is deserialized.</param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
reader.MoveToContent();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement(Constants.ContinuationConstants.ContinuationTopElement);
if (!isEmptyElement)
{
while (true)
{
if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
{
switch (reader.Name)
{
case Constants.ContinuationConstants.VersionElement:
string version = reader.ReadElementContentAsString();
if (version != Constants.ContinuationConstants.CurrentVersion)
{
throw new System.Xml.XmlException(string.Format(SR.UnexpectedElement, version));
}
break;
case Constants.ContinuationConstants.NextPartitionKeyElement:
this.NextPartitionKey = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.NextRowKeyElement:
this.NextRowKey = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.NextTableNameElement:
this.NextTableName = reader.ReadElementContentAsString();
break;
case Constants.ContinuationConstants.TypeElement:
string continuationType = reader.ReadElementContentAsString();
if ("Table" != continuationType)
{
throw new System.Xml.XmlException(SR.UnexpectedContinuationType);
}
break;
default:
throw new System.Xml.XmlException(string.Format(SR.UnexpectedElement, reader.Name));
}
}
else
{
reader.ReadEndElement();
return;
}
}
}
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
LinkItem item = new LinkItem();
while (reader.IsStartElement())
{
reader.MoveToContent();
reader.Read();
if (reader.IsStartElement("Id"))
{
reader.MoveToContent();
item.Id = int.Parse(reader.ReadString());
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Id element was expected.");
}
if (reader.IsStartElement("Title"))
{
reader.MoveToContent();
item.Title = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Title element was expected.");
}
if (reader.IsStartElement("Description"))
{
reader.MoveToContent();
item.Description = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Description element was expected.");
}
if (reader.IsStartElement("DateStart"))
{
reader.MoveToContent();
reader.Read();
item.DateStart = reader.ReadContentAsDateTime();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: DateStart element was expected.");
}
if (reader.IsStartElement("DateEnd"))
{
reader.MoveToContent();
reader.Read();
item.DateEnd = reader.ReadContentAsDateTime();
reader.MoveToContent();
reader.ReadEndElement();
}
// optional
if (reader.IsStartElement("Url"))
{
reader.MoveToContent();
item.Url = reader.ReadString();
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
throw new XmlException("ExpectedElementMissing: Url element was expected.");
}
reader.MoveToContent();
reader.ReadEndElement();
}
this.m_linkItem = item;
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
ResourceManager.Instance.CurrentScene.ObjectsDictionary = new Dictionary <uint, GameObject>();
ResourceManager.Instance.CurrentScene.PointLights = new List <LightPoint>();
DirectionalLights = new LightDirectional[ResourceManager.DIRECTIONAL_MAX_LIGHTS];
if (reader.Name == "SceneParams")
{
Params = new SceneParams(0, "null");
(Params as IXmlSerializable).ReadXml(reader);
}
if (reader.Name == "AmbientLight")
{
AmbientLight = new LightAmbient(0, "null");
(AmbientLight as IXmlSerializable).ReadXml(reader);
}
int ctr = 0;
reader.ReadStartElement("DirectionalLights");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "DirectionalLight")
{
reader.ReadStartElement();
if (reader.Name != "null")
{
LightDirectional obj = new LightDirectional(0, "");
(obj as IXmlSerializable).ReadXml(reader);
DirectionalLights[ctr] = obj;
++ctr;
}
else
{
reader.ReadElementString("null", "");
reader.ReadEndElement();
++ctr;
}
}
}
reader.ReadEndElement();
reader.ReadStartElement("PointLights");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "PointLight")
{
reader.ReadStartElement();
LightPoint pl = new LightPoint(0, "");
ResourceManager.Instance.CurrentScene.PointLights.Add(pl);
(pl as IXmlSerializable).ReadXml(reader);
if (pl.CastShadows)
{
pl.SetupShadowRender();
}
reader.ReadEndElement();
}
else
{
reader.ReadElementString("null", "");
}
}
reader.ReadEndElement();
reader.ReadStartElement("ObjectsDictionary");
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "GameObject")
{
reader.ReadStartElement();
GameObject obj = null;
uint key = (uint)reader.ReadElementContentAsInt("GameObjectKey", "");
if (ResourceManager.Instance.CurrentScene.ObjectsDictionary.TryGetValue(key, out obj))
{
Debug.Log("GameObject successfully loaded - " + obj.Name);
GameObject tmp = null;
(tmp as IXmlSerializable).ReadXml(reader);
}
else
{
obj = new GameObject(0, "");
ResourceManager.Instance.CurrentScene.ObjectsDictionary.Add(key, obj);
(obj as IXmlSerializable).ReadXml(reader);
Debug.Log("New Gameobject successfully loaded - " + obj.Name);
}
}
reader.ReadEndElement();
}
reader.ReadEndElement();
if (reader.Name == "Camera")
{
Cam = new Camera(0, "null", Vector3.Zero, Vector3.Zero, Vector3.Zero, Vector3.Zero, MathHelper.Pi / 3.0f, 1.0f, 0.1f, 2000.0f);
reader.ReadStartElement();
(Cam as IXmlSerializable).ReadXml(reader);
}
ObjectsDictionary = ResourceManager.Instance.CurrentScene.ObjectsDictionary;
PointLights = ResourceManager.Instance.CurrentScene.PointLights;
reader.ReadEndElement();
}
/// <summary>
/// Updates an existing <see cref="NameValueCollection" /> object from
/// its XML representation.
/// </summary>
private static void UpcodeTo(XmlReader reader, NameValueCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
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"))
{
string name = reader.GetAttribute("name");
bool isNull = reader.IsEmptyElement;
reader.Read(); // <item>
if (!isNull)
{
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.IsStartElement("value")) // <value ...>
{
string 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 void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
Name = reader.ReadElementString("Name", "");
MyEffect = ResourceManager.Instance.LoadEffect(reader.ReadElementString("EffectPath", ""));
uint normColor = 0xFFFF0F0F;
uint blackColor = 0xFF000000;
Texture2D defDiff = null;
if (!ResourceManager.Instance.Textures.TryGetValue("DefaultDiffuse", out defDiff))
{
defDiff = new Texture2D(TrashSoupGame.Instance.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
defDiff.SetData <uint>(new uint[] { blackColor });
ResourceManager.Instance.Textures.Add("DefaultDiffuse", defDiff);
}
Texture2D defNrm = null;
if (!ResourceManager.Instance.Textures.TryGetValue("DefaultNormal", out defNrm))
{
defNrm = new Texture2D(TrashSoupGame.Instance.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
defNrm.SetData <uint>(new uint[] { normColor });
ResourceManager.Instance.Textures.Add("DefaultNormal", defNrm);
}
TextureCube defCbc = null;
if (!ResourceManager.Instance.TexturesCube.TryGetValue("DefaultCube", out defCbc))
{
defCbc = new TextureCube(TrashSoupGame.Instance.GraphicsDevice, 1, false, SurfaceFormat.Color);
defCbc.SetData <uint>(CubeMapFace.NegativeX, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveX, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.NegativeY, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveY, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.NegativeZ, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveZ, new uint[] { blackColor });
ResourceManager.Instance.TexturesCube.Add("DefaultCube", defCbc);
}
DiffuseMap = ResourceManager.Instance.LoadTexture(reader.ReadElementString("DiffusePath", ""));
if (reader.Name == "NormalPath")
{
NormalMap = ResourceManager.Instance.LoadTexture(reader.ReadElementString("NormalPath", ""));
}
if (reader.Name == "CubePath")
{
CubeMap = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubePath", ""));
}
reader.ReadStartElement("DiffuseColor");
DiffuseColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
reader.ReadStartElement("SpecularColor");
SpecularColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
Glossiness = reader.ReadElementContentAsFloat("Glossiness", "");
reader.ReadStartElement("ReflectivityColor");
ReflectivityColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
ReflectivityBias = reader.ReadElementContentAsFloat("ReflectivityBias", "");
Transparency = reader.ReadElementContentAsFloat("Transparency", "");
PerPixelLighting = reader.ReadElementContentAsBoolean("PerPixelLighting", "");
RecieveShadows = reader.ReadElementContentAsBoolean("ReceiveShadows", "");
Unlit = reader.ReadElementContentAsBoolean("Unlit", "");
AssignParamsInitialize();
if (this.GetType() == typeof(Material))
{
reader.ReadEndElement();
}
}
public new void ReadXmlContent(System.Xml.XmlReader reader)
{
base.ReadXmlContent(reader);
bool done = false;
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case "readAccessMode":
READ_ACCESS_MODE.ReadXml(reader);
break;
case "writeAccessMode":
WRITE_ACCESS_MODE.ReadXml(reader);
break;
case "allowedValues":
if (reader.ReadToDescendant("allowedValue"))
{
List <WSValue> values = new List <WSValue>();
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (!reader.IsEmptyElement)
{
string aName = reader.GetAttribute("name");
if (string.IsNullOrEmpty(aName))
{
reader.Skip();
}
else
{
WSValue value = new WSValue(aName);
value.ReadXml(reader);
values.Add(value);
}
}
reader.MoveToContent();
if (!reader.Read())
{
break;
}
}
ALLOWED_VALUES = values;
}
break;
default:
{
reader.Skip();
done = true;
break;
}
}
reader.MoveToContent();
if (done || !reader.Read())
{
break;
}
}
}
//<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
//<Telegram xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="LancePlatform">
// <Response requestId="0">
// <record type="Response_moduleGetRecord">
// <param-list>
// <param name="m_moduleConfigs" type="sequence" sequenceType="record">
// <item>
// <record type="moduleConfigParamRecord">
// <param-list>
// <param name="m_moduleId" type="wstring">A</param>
// <param name="m_sensorId" type="wstring" />
// <param name="m_tempSensorId" type="wstring" />
// </param-list>
// </record>
// </item>
// </param>
// </param-list>
// </record>
// </Response>
//</Telegram>;
protected void ReadProperty(System.Xml.XmlReader reader)
{
string nodeName = reader.Name;
if (nodeName.Equals("param") && (reader.NodeType == XmlNodeType.Element))
{
string valueType = reader.GetAttribute("type");
string valueName = reader.GetAttribute("name");
if (_propertyTypeDic != null && _propertyTypeDic.ContainsKey(valueName))
{
if (valueType == "sequence")
{
string sequenceType = reader.GetAttribute("sequenceType");
if (sequenceType == PdkXmlSerializer.RecordElementname)
{
Type arrayType = _propertyTypeDic[valueName];
Type elementType = arrayType.GetElementType();
if (elementType == typeof(moduleConfigParamRecord))
{
moduleConfigParamRecord[] array = CreatFromXml <moduleConfigParamRecord>(reader);
_propertyInfoDic[valueName].SetValue(this, array);
}
}
if (sequenceType == PdkXmlSerializer.SequenceTypeAttributename)
{
; // fill it
}
else
if (sequenceType == "wstring")
{
XmlSerializer stringSerializer = new XmlSerializer(typeof(string));
List <string> list = new List <string>();
reader.Read();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement(PdkXmlSerializer.ItemElementname);
string content = reader.ReadString();
list.Add(content);
reader.ReadEndElement();
reader.MoveToContent();
}
_propertyInfoDic[valueName].SetValue(this, list.ToArray(), null);
}
}
else
if (valueType == "record")
{
}
else
{
reader.ReadStartElement(nodeName);
object tempValue = null;
tempValue = CreateFormString(_propertyTypeDic[valueName], reader.ReadString());
reader.Read();
if (tempValue != null && _propertyInfoDic != null && _propertyInfoDic.ContainsKey(valueName))
{
_propertyInfoDic[valueName].SetValue(this, tempValue, null);
}
}
} //if "param"
} // if
}
private void ReadXmlAndEnumerateTypes()
{
using (Xml.XmlReader reader = Xml.XmlReader.Create("TestXml.xml"))
{
// funkcja ktora przeskakuje do czesci xmla zawierajacej dane. Omija takie typy nodow jak:
// ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.
reader.MoveToContent();
//
//
// PRZECHODZENIE PO NODACH ODBYWA SIE STRASZNIE SPECYFICZNIE:
// 1. <author>
// 2. text z authora
// 3. </author>
// i tak node po nodzie!!!!
//
//
// Parse the file and display each of the nodes.
while (reader.Read())
{
switch (reader.NodeType)
{
case Xml.XmlNodeType.Element:
Console.Write("<{0}>", reader.Name);
break;
case Xml.XmlNodeType.Text:
Console.Write(reader.Value);
break;
case Xml.XmlNodeType.CDATA:
Console.Write("<![CDATA[{0}]]>", reader.Value);
break;
case Xml.XmlNodeType.ProcessingInstruction:
Console.Write("<?{0} {1}?>", reader.Name, reader.Value);
break;
case Xml.XmlNodeType.Comment:
Console.Write("<!--{0}-->", reader.Value);
break;
case Xml.XmlNodeType.XmlDeclaration:
Console.Write("<?xml version='1.0'?>");
break;
case Xml.XmlNodeType.Document:
break;
case Xml.XmlNodeType.DocumentType:
Console.Write("<!DOCTYPE {0} [{1}]", reader.Name, reader.Value);
break;
case Xml.XmlNodeType.EntityReference:
Console.Write(reader.Name);
break;
case Xml.XmlNodeType.EndElement:
Console.Write("</{0}>", reader.Name);
break;
}
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
var s = new XmlSerializer(typeof(string));
var b = new XmlSerializer(typeof(bool));
var l = new XmlSerializer(typeof(List <AutoAnswer>));
if (reader.IsEmptyElement || !reader.Read())
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement("TaskInfo");
//taskid
reader.ReadStartElement("TaskId");
TaskId = new Guid((string)s.Deserialize(reader));
reader.ReadEndElement();
//plugin name
reader.ReadStartElement("PluginName");
PluginName = (string)s.Deserialize(reader);
reader.ReadEndElement();
//url
reader.ReadStartElement("Url");
Url = (string)s.Deserialize(reader);
reader.ReadEndElement();
//title
reader.ReadStartElement("Title");
Title = (string)s.Deserialize(reader);
reader.ReadEndElement();
//Status
reader.ReadStartElement("Status");
Status = (DownloadStatus)Enum.Parse(typeof(DownloadStatus), (string)s.Deserialize(reader), true);
reader.ReadEndElement();
//createtime
reader.ReadStartElement("CreateTime");
CreateTime = DateTime.Parse((string)s.Deserialize(reader));
reader.ReadEndElement();
//finishtime
if (reader.IsStartElement("FinishTime"))
{
reader.ReadStartElement("FinishTime");
FinishTime = DateTime.Parse((string)s.Deserialize(reader));
reader.ReadEndElement();
}
//savedirectory
reader.ReadStartElement("SaveDirectory");
SaveDirectory = new DirectoryInfo((string)s.Deserialize(reader));
reader.ReadEndElement();
//partcount
reader.ReadStartElement("PartCount");
PartCount = Int32.Parse((string)s.Deserialize(reader));
reader.ReadEndElement();
//currentpart
reader.ReadStartElement("CurrentPart");
CurrentPart = Int32.Parse((string)s.Deserialize(reader));
reader.ReadEndElement();
//is be added
reader.ReadStartElement("IsBeAdded");
IsBeAdded = (bool)b.Deserialize(reader);
reader.ReadEndElement();
//partialfinished
reader.ReadStartElement("PartialFinished");
PartialFinished = (bool)b.Deserialize(reader);
reader.ReadEndElement();
//partialfinished detail
reader.ReadStartElement("PartialFinishedDetail");
PartialFinishedDetail = (string)s.Deserialize(reader);
reader.ReadEndElement();
//autoanswer
reader.ReadStartElement("AutoAnswers");
this.AutoAnswer = (List <AutoAnswer>)l.Deserialize(reader);
reader.ReadEndElement();
//extract cache
reader.ReadStartElement("ExtractCache");
ExtractCache = (bool)b.Deserialize(reader);
reader.ReadEndElement();
//filepath
reader.ReadStartElement("Files");
FilePath = new List <string>();
while (reader.IsStartElement("File"))
{
reader.ReadStartElement("File");
FilePath.Add((string)s.Deserialize(reader));
reader.ReadEndElement();
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
//subfilepath
SubFilePath = new List <string>();
reader.ReadStartElement("SubFiles");
while (reader.IsStartElement("SubFile"))
{
reader.ReadStartElement("SubFile");
SubFilePath.Add((string)s.Deserialize(reader));
reader.ReadEndElement();
}
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
//downsub
reader.ReadStartElement("DownSub");
DownSub = (DownloadSubtitleType)Enum.Parse(typeof(DownloadSubtitleType), (string)s.Deserialize(reader), true);
reader.ReadEndElement();
//proxy
XmlSerializer sProxy = new XmlSerializer(typeof(AcDownProxy));
reader.ReadStartElement("Proxy");
AcDownProxy pxy = (AcDownProxy)sProxy.Deserialize(reader);
if (pxy.Address == "" && pxy.Port == 0)
{
Proxy = null;
}
else
{
Proxy = pxy.ToWebProxy();
}
reader.ReadEndElement();
//sourceUrl
reader.ReadStartElement("SourceUrl");
SourceUrl = (string)s.Deserialize(reader);
reader.ReadEndElement();
//Comment
reader.ReadStartElement("Comment");
Comment = (string)s.Deserialize(reader);
reader.ReadEndElement();
//Hash
reader.ReadStartElement("Hash");
_hash = (string)s.Deserialize(reader);
reader.ReadEndElement();
//Progress
reader.ReadStartElement("Progress");
if (!double.TryParse((string)s.Deserialize(reader), out _progress))
{
_progress = 0;
}
if (_progress > 1.0)
{
_progress = 1.0;
}
if (_progress < 0.0)
{
_progress = 0;
}
if (double.IsNaN(_progress))
{
_progress = 0;
}
reader.ReadEndElement();
//settings
reader.ReadStartElement("Settings");
if (!reader.IsEmptyElement)
{
XmlSerializer sSettings = new XmlSerializer(typeof(SerializableDictionary <string, string>));
Settings = (SerializableDictionary <string, string>)sSettings.Deserialize(reader);
}
else
{
Settings = new SerializableDictionary <string, string>();
reader.Read();
}
reader.ReadEndElement();
//结束读取
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
string clipname = reader["clipname"];
if (!string.IsNullOrEmpty(clipname))
{
Clipname = clipname;
}
else
{
Clipname = "";
}
string videoLayer = reader["videoLayer"];
if (!string.IsNullOrEmpty(videoLayer))
{
VideoLayer = Int32.Parse(videoLayer);
}
string channelLayout = reader["channel_lyout"];
if (!string.IsNullOrEmpty(channelLayout))
{
ChannelLayout = (ChannelLayout)Enum.Parse(typeof(ChannelLayout), channelLayout);
}
string seek = reader["seek"];
if (!string.IsNullOrEmpty(seek))
{
Seek = Int32.Parse(seek);
}
string length = reader["length"];
if (!string.IsNullOrEmpty(length))
{
Length = Int32.Parse(length);
}
string loop = reader["loop"];
bool bLoop = false;
bool.TryParse(loop, out bLoop);
Loop = bLoop;
reader.ReadStartElement();
if (reader.Name == "transition")
{
int duration;
int pause;
Easing easing;
string typeString = reader["type"];
string durationString = reader["duration"];
string pauseString = reader["pause"];
int.TryParse(pauseString, out pause);
string easingString = reader["easing"];
Enum.TryParse <Easing>(easingString, out easing);
if (Int32.TryParse(durationString, out duration) && Enum.IsDefined(typeof(TransitionType), typeString.ToUpper()))
{
transition_ = new Transition((TransitionType)Enum.Parse(typeof(TransitionType), typeString.ToUpper()), duration, pause, easing);
}
else
{
transition_ = new Transition();
}
}
}
public async Task <HttpResponseMessage> PostRawBufferManual()
{
string connStr = "";
string loc = "";
try
{
string request = await Request.Content.ReadAsStringAsync();
var addin = Globals.ThisAddIn;
var app = addin.Application;
var wb = app.ActiveWorkbook;
loc = wb.FullName; //@"D:\Data\Presentations\Drop Your DAX\demos\02 DAX filter similar.xlsx";
// parse request looking for workbook name in Workstation ID
// we are using the Workstation ID property to tunnel the location property through
// from the UI to the PowerPivot engine. The Location property does not appear to get
// serialized through into the XMLA request so we "hijack" the Workstation ID
var wsid = ParseRequestForWorkstationID(request);
if (!string.IsNullOrEmpty(wsid))
{
loc = wsid;
}
connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location=\"{0}\"", loc);
//connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location={0}", loc);
// 2010 conn str
//connStr = string.Format("Provider=MSOLAP.5;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Cell Error Mode=TextValue;Location={0}", loc);
//connStr = string.Format("Provider=MSOLAP;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Location={0};", loc);
AmoWrapper.AmoType amoType = AmoWrapper.AmoType.AnalysisServices;
if (float.Parse(app.Version, CultureInfo.InvariantCulture) >= 15)
{
amoType = AmoWrapper.AmoType.Excel;
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Loading Microsoft.Excel.Amo");
}
else
{
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "defaulting to Microsoft.AnalysisServices");
}
var svr = new AmoWrapper.AmoServer(amoType);
svr.Connect(connStr);
// STEP 1: send the request to server.
Log.Verbose("{class} {method} request: {request}", "XmlaController", "PostRawBufferManual", request);
System.IO.TextReader streamWithXmlaRequest = new StringReader(request);
System.Xml.XmlReader xmlaResponseFromServer = null; // will be used to parse the XML/A response from server
string fullEnvelopeResponseFromServer = "";
try
{
//xmlaResponseFromServer = svr.SendXmlaRequest( XmlaRequestType.Undefined, streamWithXmlaRequest);
xmlaResponseFromServer = svr.SendXmlaRequest(streamWithXmlaRequest);
// STEP 2: read/parse the XML/A response from server.
xmlaResponseFromServer.MoveToContent();
fullEnvelopeResponseFromServer = xmlaResponseFromServer.ReadOuterXml();
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
//result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
//result.Content = new StringContent(String.Format("An unexpected error occurred (sending XMLA request): \n{0}", ex.Message));
}
finally
{
streamWithXmlaRequest.Close();
}
HttpResponseMessage result;
try
{
result = new HttpResponseMessage(HttpStatusCode.OK);
result.Content = new StringContent(fullEnvelopeResponseFromServer);
result.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml");
result.Headers.TransferEncodingChunked = true;
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
result.Content = new StringContent(String.Format("An unexpected error occurred (reading XMLA response): \n{0}", ex.Message));
}
finally
{
// STEP 3: close the System.Xml.XmlReader, to release the connection for future use.
if (xmlaResponseFromServer != null)
{
xmlaResponseFromServer.Close();
}
}
return(result);
}
catch (Exception ex)
{
Log.Error("ERROR Connecting: {class} {method} loc: '{loc}' conn:'{connStr}' ex: {exception}", "XmlaController", "PostRawBufferManual", loc, connStr, ex);
var expResult = new HttpResponseMessage(HttpStatusCode.InternalServerError);
expResult.Content = new StringContent(String.Format("An unexpected error occurred: \n{0}", ex.Message));
return(expResult);
}
}
public void Set() => _reader.MoveToContent();
public override XmlNodeType MoveToContent()
{
CheckAsync();
return(_coreReader.MoveToContent());
}
