public override void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, object oldValue, ref object value)
{
if (node.ClrType != typeof(object))
XmlTypeSerializer.For(node.ClrType).SetValue(node, parent, accessor, oldValue, ref value);
else
node.Clear();
}
private void PushParentNamespaces(IXmlNode node, XmlNamespaceManager manager)
{
List<IXmlNode> list = (List<IXmlNode>) null;
IXmlNode xmlNode1 = node;
while ((xmlNode1 = xmlNode1.ParentNode) != null)
{
if (xmlNode1.NodeType == XmlNodeType.Element)
{
if (list == null)
list = new List<IXmlNode>();
list.Add(xmlNode1);
}
}
if (list == null)
return;
list.Reverse();
foreach (IXmlNode xmlNode2 in list)
{
manager.PushScope();
foreach (IXmlNode xmlNode3 in (IEnumerable<IXmlNode>) xmlNode2.Attributes)
{
if (xmlNode3.NamespaceUri == "http://www.w3.org/2000/xmlns/" && xmlNode3.LocalName != "xmlns")
manager.AddNamespace(xmlNode3.LocalName, xmlNode3.Value);
}
}
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
using (var reader = new XmlSubtreeReader(node, Root))
return serializer.CanDeserialize(reader)
? serializer.Deserialize(reader)
: null;
}
public override void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, ref object value)
{
var source = (Array) value;
var target = (Array) null;
var itemType = source.GetType().GetElementType();
var subaccessor = accessor.GetCollectionAccessor(itemType);
var cursor = subaccessor.SelectCollectionItems(node, true);
var serializer = subaccessor.Serializer;
var references = XmlAdapter.For(parent).References;
for (var i = 0; i < source.Length; i++)
{
var originalItem = source.GetValue(i);
var assignedItem = originalItem;
subaccessor.SetValue(cursor, parent, references, cursor.MoveNext(), null /* TODO: Get Value */, ref assignedItem);
if (target != null)
{
target.SetValue(assignedItem, i);
}
else if (!Equals(assignedItem, originalItem))
{
target = Array.CreateInstance(itemType, source.Length);
Array.Copy(source, target, i);
target.SetValue(assignedItem, i);
}
}
cursor.RemoveAllNext();
if (target != null)
value = target;
}
public override void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, object oldValue, ref object value)
{
var newNode = (XmlNode) value;
using (var writer = new XmlSubtreeWriter(node))
newNode.WriteTo(writer);
}
public XmlSubtreeWriter(IXmlNode node)
{
if (node == null)
throw Error.ArgumentNull("node");
this.node = node;
}
public override IXmlCursor SelectPropertyNode(IXmlNode node, bool mutable)
{
var flags = Serializer.Kind == XmlTypeKind.Simple
? CursorFlags.AllNodes
: CursorFlags.Elements;
return node.SelectChildren(KnownTypes, Context, flags.MutableIf(mutable));
}
private void ParsePartwise(IXmlNode element)
{
var version = element.GetAttribute("version");
if (!string.IsNullOrEmpty(version) && version != "2.0")
{
throw new UnsupportedFormatException();
}
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "movement-title":
_score.Title = Std.GetNodeValue(c.FirstChild);
break;
case "identification":
ParseIdentification(c);
break;
case "part-list":
ParsePartList(c);
break;
case "part":
ParsePart(c);
break;
}
}
});
}
public static XmlRpcValue Parse(IXmlNode node)
{
switch (node.NodeName.ToLower())
{
case "array":
return new XmlRpcArray(node);
break;
case "struct":
return new XmlRpcStruct(node);
break;
case "boolean":
return new XmlRpcBoolean(node);
break;
case "int":
return new XmlRpcInt(node);
break;
case "i4":
return new XmlRpcInt(node);
break;
case "double":
return new XmlRpcDouble(node);
break;
case "datetime.iso8601":
return new XmlRpcDateTime(node);
break;
default:
return new XmlRpcString(node);
}
return null;
}
private object GetValueCore(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
var itemType = node.ClrType.GetGenericArguments()[0];
var listType = ListTypeConstructor.MakeGenericType(itemType);
var subaccessor = accessor.GetCollectionAccessor(itemType);
return Activator.CreateInstance(listType, node, parent, subaccessor);
}
private void PopulateIdentity(int id, IXmlNode node)
{
Entry entry;
if (!entriesById.TryGetValue(id, out entry))
entriesById.Add(id, new Entry(id, node));
if (nextId <= id)
nextId = ++id;
}
private string ResolveFullName(IXmlNode node, XmlNamespaceManager manager)
{
string str = node.NamespaceUri == null || node.LocalName == "xmlns" && node.NamespaceUri == "http://www.w3.org/2000/xmlns/" ? (string) null : manager.LookupPrefix(node.NamespaceUri);
if (!string.IsNullOrEmpty(str))
return str + ":" + node.LocalName;
else
return node.LocalName;
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
var source = node.AsRealizable<XmlNode>();
return (source != null && source.IsReal)
? source.Value
: null;
}
private void PopulateReference(int id, IXmlNode node, ICollection<Reference> references)
{
Entry entry;
if (entriesById.TryGetValue(id, out entry))
entry.AddReference(node);
else
references.Add(new Reference(id, node));
}
public XmlRpcDouble(IXmlNode node)
{
double val = -1;
double.TryParse(node.InnerText, out val);
Value = val;
}
public XmlReferenceManager(IXmlNode root, IXmlReferenceFormat format)
{
entriesById = new Dictionary<int, Entry>();
entriesByValue = new WeakKeyDictionary<object, Entry>(ReferenceEqualityComparer<object>.Instance);
this.format = format;
this.nextId = 1;
Populate(root);
}
private void AddSuggestionFromNode(IXmlNode node, SearchSuggestionCollection suggestions)
{
string text = "";
string description = "";
string url = "";
string imageUrl = "";
string imageAlt = "";
foreach (IXmlNode subNode in node.ChildNodes)
{
if (subNode.NodeType != NodeType.ElementNode)
{
continue;
}
if (subNode.NodeName.Equals("Text", StringComparison.CurrentCultureIgnoreCase))
{
text = subNode.InnerText;
}
else if (subNode.NodeName.Equals("Description", StringComparison.CurrentCultureIgnoreCase))
{
description = subNode.InnerText;
}
else if (subNode.NodeName.Equals("Url", StringComparison.CurrentCultureIgnoreCase))
{
url = subNode.InnerText;
}
else if (subNode.NodeName.Equals("Image", StringComparison.CurrentCultureIgnoreCase))
{
if (subNode.Attributes.GetNamedItem("source") != null)
{
imageUrl = subNode.Attributes.GetNamedItem("source").InnerText;
}
if (subNode.Attributes.GetNamedItem("alt") != null)
{
imageAlt = subNode.Attributes.GetNamedItem("alt").InnerText;
}
}
}
if (string.IsNullOrWhiteSpace(text))
{
// No proper suggestion item exists
}
else if (string.IsNullOrWhiteSpace(url))
{
suggestions.AppendQuerySuggestion(text);
}
else
{
// The following image should not be used in your application for Result Suggestions. Replace the image with one that is tailored to your content
Uri uri = string.IsNullOrWhiteSpace(imageUrl) ? new Uri("ms-appx:///Assets/SDK_ResultSuggestionImage.png") : new Uri(imageUrl);
RandomAccessStreamReference imageSource = RandomAccessStreamReference.CreateFromUri(uri);
suggestions.AppendResultSuggestion(text, description, url, imageSource, imageAlt);
Debug.WriteLine("\n Search Result ({0}): {1}", text, description);
}
}
private void Populate(IXmlNode node)
{
var references = new List<Reference>();
var iterator = node.SelectSubtree();
while (iterator.MoveNext())
PopulateFromNode(iterator, references);
PopulateDeferredReferences(references);
}
static void SetNodeValueString(string str, IXmlDocument xmldoc, IXmlNode node) {
IXmlText textNode;
int res = xmldoc.CreateTextNode(str, out textNode);
ComFunctions.CheckHRESULT(res);
IXmlNode textNodeAsNode = (IXmlNode)textNode;
IXmlNode appendedChild;
res = node.AppendChild(textNodeAsNode, out appendedChild);
ComFunctions.CheckHRESULT(res);
}
public XmlSubtreeReader(IXmlNode node, string rootLocalName, string rootNamespaceUri)
{
if (null == node)
throw Error.ArgumentNull("node");
if (null == rootLocalName)
throw Error.ArgumentNull("rootLocalName");
this.reader = node.ReadSubtree();
this.rootLocalName = reader.NameTable.Add(rootLocalName);
this.rootNamespaceURI = rootNamespaceUri ?? string.Empty;
}
private static void ParseTied(IXmlNode element, Note note)
{
if (element.GetAttribute("type") == "start")
{
note.IsTieOrigin = true;
}
else
{
note.IsTieDestination = true;
}
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
var items = new ArrayList();
var itemType = node.ClrType.GetElementType();
var references = XmlAdapter.For(parent).References;
accessor
.GetCollectionAccessor(itemType)
.GetCollectionItems(node, parent, references, items);
return items.ToArray(itemType);
}
private void LoadConferenceData(IXmlNode nodeConference)
{
Conference.Title = nodeConference.SelectSingleNode("title").InnerText;
Conference.Subtitle = nodeConference.SelectSingleNode("subtitle").InnerText;
Conference.Venue = nodeConference.SelectSingleNode("venue").InnerText;
Conference.City = nodeConference.SelectSingleNode("city").InnerText;
Conference.Start = DateTime.Parse(nodeConference.SelectSingleNode("start").InnerText);
Conference.End = DateTime.Parse(nodeConference.SelectSingleNode("end").InnerText);
Conference.NumberOfDays = int.Parse(nodeConference.SelectSingleNode("days").InnerText);
Conference.DayChange = TimeSpan.Parse(nodeConference.SelectSingleNode("day_change").InnerText);
Conference.TimeslotDuration = TimeSpan.Parse(nodeConference.SelectSingleNode("timeslot_duration").InnerText);
}
public SysXmlSubtreeIterator(IXmlNode parent, IXmlNamespaceSource namespaces)
: base(namespaces, parent)
{
if (null == parent)
throw Error.ArgumentNull("parent");
var source = parent.RequireRealizable<XmlNode>();
if (source.IsReal)
node = source.Value;
type = typeof(object);
}
private bool ConsumeNode()
{
var result = true;
var path = Node.Path;
if (path != null)
result = ConsumeFirstStep(path);
else
Name = Node.Name;
Node = Node.Parent;
return result;
}
private void LoadConferenceDayData(IXmlNode nodeDay)
{
Day day = new Day();
day.Index = int.Parse(nodeDay.Attributes.GetNamedItem("index").InnerText);
day.Date = DateTime.Parse(nodeDay.Attributes.GetNamedItem("date").InnerText);
Conference.Days.Add(day);
XmlNodeList nodesRooms = nodeDay.SelectNodes("room");
foreach (IXmlNode item in nodesRooms)
{
LoadConferenceRoomData(item, day);
}
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
var serializable = (IXmlSerializable) Activator.CreateInstance(node.ClrType);
using (var reader = new XmlSubtreeReader(node, XmlDefaultSerializer.Root))
{
// Do NOT pre-read containing element
// ...IXmlSerializable is not a symmetric contract
serializable.ReadXml(reader);
}
return serializable;
}
public override void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, object oldValue, ref object value)
{
var serializable = (IXmlSerializable) value;
var root = XmlDefaultSerializer.Root;
using (var writer = new XmlSubtreeWriter(node))
{
// Pre-write containing element
writer.WriteStartElement(string.Empty, root.ElementName, root.Namespace);
serializable.WriteXml(writer);
writer.WriteEndElement();
}
}
public static string GetNodeValue(IXmlNode n)
{
if (n.NodeType == XmlNodeType.Element || n.NodeType == XmlNodeType.Document)
{
var txt = new StringBuilder();
n.IterateChildren(c =>
{
txt.Append(GetNodeValue(c));
});
return txt.ToString().Trim();
}
return n.Value;
}
private void LoadConferenceEventData(IXmlNode nodeEvent, Day day, Room room)
{
Event conferenceEvent = new Event();
conferenceEvent.Id = nodeEvent.Attributes.GetNamedItem("id").InnerText;
conferenceEvent.Start = day.Date.Add(DateTime.Parse(nodeEvent.SelectSingleNode("start").InnerText).TimeOfDay);
conferenceEvent.Duration = TimeSpan.Parse(nodeEvent.SelectSingleNode("duration").InnerText);
conferenceEvent.Room = room;
conferenceEvent.Day = day;
conferenceEvent.Slug = nodeEvent.SelectSingleNode("slug").InnerText;
conferenceEvent.Title = nodeEvent.SelectSingleNode("title").InnerText;
conferenceEvent.Subtitle = nodeEvent.SelectSingleNode("subtitle").InnerText;
string trackName = nodeEvent.SelectSingleNode("track").InnerText;
conferenceEvent.Track = Conference.Tracks.FirstOrDefault(item => item.Name == trackName);
if (conferenceEvent.Track == null)
{
conferenceEvent.Track = new Track() { Name = trackName };
Conference.Tracks.Add(conferenceEvent.Track);
}
string typeName = nodeEvent.SelectSingleNode("type").InnerText;
conferenceEvent.Type = Conference.EventTypes.FirstOrDefault(item => item.Name == typeName);
if (conferenceEvent.Type == null)
{
conferenceEvent.Type = new EventType() { Name = typeName };
Conference.EventTypes.Add(conferenceEvent.Type);
}
conferenceEvent.Language = nodeEvent.SelectSingleNode("language").InnerText;
conferenceEvent.Abstract = nodeEvent.SelectSingleNode("abstract").InnerText;
conferenceEvent.Description = nodeEvent.SelectSingleNode("description").InnerText;
conferenceEvent.Persons = new List<Person>();
IXmlNode nodesPersons = nodeEvent.SelectSingleNode("persons");
XmlNodeList nodesPersonList = nodesPersons.SelectNodes("person");
foreach (IXmlNode item in nodesPersonList)
{
Person person = LoadConferencePersonData(item);
conferenceEvent.Persons.Add(person);
}
conferenceEvent.Links = new List<Link>();
IXmlNode nodesLinks = nodeEvent.SelectSingleNode("links");
XmlNodeList nodesLinkList = nodesLinks.SelectNodes("link");
foreach (IXmlNode item in nodesLinkList)
{
Link link = new Link();
link.Name = item.InnerText;
link.Url = item.Attributes.GetNamedItem("href").InnerText;
conferenceEvent.Links.Add(link);
}
Conference.Events.Add(conferenceEvent);
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
return(GetValueCore(node.Save(), parent, accessor));
}
protected abstract IXmlCursor Cursor(IXmlNode parent, CompiledXPath path, IXmlIncludedTypeMap includedTypes, CursorFlags flags);
public bool UnderlyingPositionEquals(IXmlNode node)
{
return(this.node.UnderlyingPositionEquals(node));
}
public override IXmlCursor SelectPropertyNode(IXmlNode node, bool create)
{
var flags = CursorFlags.AllNodes.MutableIf(create);
return(node.Select(path, this, Context, flags));
}
private object GetPropertyValueCore(IXmlNode parentNode, IDictionaryAdapter parentObject, XmlReferenceManager references, bool orStub)
{
return(SelectsNodes
? base.GetPropertyValue(parentNode, parentObject, references, orStub)
: Evaluate(parentNode));
}
public override void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, object oldValue, ref object value)
{
node.Value = value.ToString();
}
public override IXmlCursor SelectCollectionItems(IXmlNode node, bool create)
{
var flags = CursorFlags.AllNodes.MutableIf(create) | CursorFlags.Multiple;
return(node.Select(path, this, Context, flags));
}
public Entry(int id, IXmlNode node) : this(node)
{
Id = id;
}
public Entry(IXmlNode node)
{
Node = node.Save();
}
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
var adapter = new XmlAdapter(node.Save(), XmlAdapter.For(parent).References);
return(parent.CreateChildAdapter(node.ClrType, adapter));
}
public Reference(int id, IXmlNode node)
{
Id = id;
Node = node;
}
public virtual IXmlCursor SelectPropertyNode(IXmlNode parentNode, bool mutable)
{
throw Error.NotSupported();
}
public virtual IXmlCursor SelectCollectionNode(IXmlNode parentNode, bool mutable)
{
return(SelectPropertyNode(parentNode, mutable));
}
public virtual IXmlCursor SelectCollectionItems(IXmlNode parentNode, bool mutable)
{
throw Error.NotSupported();
}
public void SetAttributeNode(IXmlNode attribute)
{
this._element.SetAttributeNode((XmlAttribute)((XmlNodeWrapper)attribute).WrappedNode);
}
public bool OnAssigningNull(IXmlNode node, object oldValue)
{
object token, newValue = null;
return(OnAssigningValue(node, oldValue, ref newValue, out token));
}
public void SetAttributeNode(IXmlNode attribute)
{
XmlNodeWrapper xmlNodeWrapper = (XmlNodeWrapper)attribute;
this._element.SetAttributeNode((XmlAttribute)xmlNodeWrapper.WrappedNode);
}
public abstract void SetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor, object oldValue, ref object value);
public override object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
return(node.Value);
}
public abstract object GetValue(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor);
public override IXmlCursor SelectCollectionNode(IXmlNode node, bool create)
{
return(node.SelectSelf(ClrType));
}
public virtual object GetStub(IXmlNode node, IDictionaryAdapter parent, IXmlAccessor accessor)
{
throw Error.NotSupported();
}
private object GetDefaultPropertyValue(IXmlNode parentNode, IDictionaryAdapter parentObject, XmlReferenceManager references, bool orStub)
{
return(defaultAccessor != null
? defaultAccessor.GetPropertyValue(parentNode, parentObject, references, orStub)
: null);
}
public XmlSelfCursor(IXmlNode node, Type clrType)
{
this.node = node;
this.clrType = clrType;
Reset();
}
public override bool IsPropertyDefined(IXmlNode parentNode)
{
return(SelectsNodes &&
base.IsPropertyDefined(parentNode));
}
public override object GetPropertyValue(IXmlNode parentNode, IDictionaryAdapter parentObject, XmlReferenceManager references, bool orStub)
{
return(GetPropertyValueCore(parentNode, parentObject, references, orStub)
?? GetDefaultPropertyValue(parentNode, parentObject, references, orStub));
}
